Добавление ИКЗ

TEMA1/Pr0

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Бушманов Артём Сергеевич
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('/Users/ArtyomBushmanov/python-labs/TEMA1')

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме1 Бушманова Артёма Сергеевича
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir("/Users/ArtyomBushmanov/python-labs/TEMA1")

TEMA1/Protocol.py

@@ -0,0 +1,8 @@
+#Протокол по Теме 1 Бушманов Артём Сергеевич
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir("/Users/ArtyomBushmanov/python-labs/TEMA1")
+import Pr0
+import prb1
+help(print);help(input)

TEMA1/test.md

@@ -0,0 +1,14 @@
+# Индивидуальное контрольное задание по теме 1
+Бушманов Артём Сергеевич А-01-23
+
+## Задание 
+Какие способы могут использоваться для получения помощи при работе со средой Python?
+
+### Решение
+Через меню Help в IDLE: IDLE Help и Python Docs (локальная/онлайн документация), а также встроенная функция help() в Shell и контекстная справка по выделенному слову.
+## Меню Help и Python Docs
+В главном меню IDLE есть раздел «Помощь (Help)», откуда открывается «Python Docs» с официальной справочной подсистемой; то же окно вызывается клавишей F1 для быстрого доступа к документации прямо из среды.
+## Встроенная функция help()
+В командном окне IDLE можно получить оперативную помощь по объектам и функциям вызовом вида help(print), что выводит описание и сигнатуры; допускается ввод нескольких запросов в одну строку через точку с запятой, например help(print); help(input) для последовательного просмотра.
+## Указатель (Index) и поиск терминов
+В окне справочной подсистемы доступна вкладка «Указатель (Index)» с алфавитным списком терминов языка; выбор, например, пункта print() (built-in function) открывает соответствующую страницу справки с описанием функции.

TEMA2/report.md

@@ -0,0 +1,531 @@
+# Отчет по теме 2  Основы программирования Python
+### Бушманов Артём Сергеевич, А-01-23.
+### 1. Запуск оболочки IDLE
+Установка рабочего каталога.
+```Python
+import os
+os.chdir('/Users/ArtyomBushmanov/python-labs/TEMA2')
+```
+### 2.1 Изучение простых обьектов
+```python 
+>>> f1=16
+>>> f2=3
+>>> f1,f2
+(16, 3)
+>>> f1;f2
+16
+3
+```
+
+```python 
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+
+>>> dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+
+>>> type(f2)
+<class 'int'>
+
+>>> del f1,f2
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+### 3. Изучение правил именования объектов в Python
+Правила именования:
+-  имена должны состоять из латинских букв, цифр и символов подчеркивания;
+-  имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
+-  имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;
+-  большие и малые буквы в именах различаются (имена – чувствительные к регистру)!
+С учетом этих правил в командном окне IDLE выполним следующие операции.
+```python 
+>>> gg1=1.6
+>>> hh1='Строка'
+>>> 73sr=3
+SyntaxError: invalid decimal literal
+>>> and=7
+SyntaxError: invalid syntax
+```
+### 4. Вывод списка ключевых слов с помощью инструкции.
+```python 
+>>> 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']
+```
+### 5. Вывод списка встроенных идентификаторов с помощью инструкций
+ ```python 
+ >>> 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', '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.1 Изучение функций (abs, len, max, min, pow, round, sorted, sum, zip)
+#### abs()
+```python 
+>>> abs(-7)
+7
+```
+ Возвращает модуль числа
+#### len()
+```python 
+>>> len([1, 2, 3])
+3
+```
+ Возвращает количество элементов в объекте (например, в списке)
+#### max()
+```python 
+>>> max(3, 5, 2)
+5
+```
+ Возвращает максимальное значение
+#### min()
+```python 
+>>> abs(-7)
+7
+```
+Возвращает модуль числа
+#### pow()
+```python 
+>>> pow(2, 3)
+8
+```
+ Возводит число 2 в 3ью степень = 8
+#### round()
+```python 
+>>> round(3.1415926, 2)
+3.14
+```
+Округляет число до заданного количества знаков после запятой
+#### sorted()
+```python 
+>>> sorted([3, 1, 2])
+[1, 2, 3]
+```
+ Возвращает отсортированный список
+#### sum()
+```python 
+>>> sum([1, 2, 3])
+6
+```
+ Возвращает сумму всех элементов в последовательности
+#### zip()
+```python 
+>>> list(zip([1, 2, 3], ['a', 'b', 'c']))   
+[(1, 'a'), (2, 'b'), (3, 'c')]
+```
+Создаёт пары элементов из нескольких последовательностей
+### 6. Малые и большие буквы различаются
+```python 
+>>> Gg1=45
+>>> gg1, Gg1
+(1.6, 45)
+```
+### 7. Изучение базовых типов объектов
+Базовые типы объектов:
+#### Логический (**bool**) 
+```python 
+>>> bb1=True
+>>> bb2=False
+>>> bb1;bb2
+True
+False
+>>> type(bb1)
+<class 'bool'>
+```
+#### Целый (**int**) 
+```python 
+>>> ii1=-1234567890
+```
+#### Вещественный (**float**) 
+```python 
+>>> a = 3.67
+>>> b = -0.45
+>>> ff1=-8.9876e-12  #экспоненциальная форма записи вещественного числа
+```
+#### Комплексный (**complex**) 
+```python 
+>>> cc1=2-3j
+>>> z = -1j
+>>> cc2=complex(a,b)  #Создается комплексное число
+>>> cc2
+(3.67-0.45j)
+```
+#### Строка символов (**str**)
+```python 
+>>> ss1 = 'Это - строка символов'
+>>> ss1 = "Это - строка символов"
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+ 	 
+>>> ss1b= 'Меня зовут: \n <Подольский НК>'
+>>> print(ss1b)
+Меня зовут: 
+ <Подольский НК>
+```
+
+```python 
+>>> mnogo = """Нетрудно заметить , что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+```python 
+>>> ss1[0]
+'Э'
+>>> ss1[8]
+'р'
+>>> ss1[-2]
+'о'
+>>> ss1[6:9]  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)
+'стр'
+>>> ss1[13:]
+'символов'
+>>> ss1[:13]
+'Это - строка '
+>>> ss1[5:-8]
+' строка '
+>>> ss1[3:17:2]
+'  тоасм'
+>>> ss1[17:3:-2]
+'омсаот '
+>>> ss1[-4:3:-2]
+'омсаот '
+```
+
+```python 
+>>> ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#67>", line 1, in <module>
+    ss1[4]='='  # Будет диагностика!
+TypeError: 'str' object does not support item assignment
+```
+Будет диагностика!
+
+```python 
+>>> ss1=ss1[:4]+'='+ss1[5:]
+>>> ss1
+'Это = строка символов'
+```
+
+```python 
+>>> ss1b[3:10]
+'я зовут'
+>>> ss1b[5:15]
+'зовут: \n <'
+>>> ss1b[2:-5:2]
+'н оу:\n<ооьк'
+```
+### 8. Типы объектов (списки (list) , кортежи (tuple), словари (dict), множества (set))
+### 8.1 Списки
+	Список - это упорядоченная изменяемая последовательность объектов произвольных типов, доступ к элементам которой осуществляется по индексам; длина списка практически не ограничена, а элементы можно добавлять, удалять и изменять.
+
+```python 
+>>> spis1=[111,'Spisok',5-9j]
+>>> spis1
+[111, 'Spisok', (5-9j)]
+```
+
+```python 
+>>> stup=[0,0,1,1,1,1,1,1,1]
+>>> stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+```
+
+```python 
+>>> spis=[1,2,3,4,
+
+      5,6,7,
+
+      8,9,10]
+>>> spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+```python 
+>>> spis1[-1]
+(5-9j)
+
+>>> stup[-8::2]
+[0, 1, 1, 1]
+
+>>> spis1[1]='Список'
+>>> spis1
+[111, 'Список', (5-9j)]
+```
+
+```python 
+>>> len(spis1)
+3
+```
+
+```python 
+>>> help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+```
+
+```python 
+>>> spis1.append('New item')
+>>> spis1
+[111, 'Список', (5-9j), 'New item']
+>>> spis1+['New item']
+[111, 'Список', (5-9j), 'New item', 'New item']
+>>>spis1
+[111, 'Список', (5-9j), 'New item']
+```
+
+#### Удаление элемента списка
+```python 
+>>> spis1.pop(1)   #Из списка удален элемент с индексом 1
+'Список'
+>>> spis1
+[111, (5-9j), 'New item']
+```
+
+#### insert
+```python 
+>>> lst = [1, 2, 3]
+>>> lst.insert(1, 100) 
+[1, 100, 2, 3]
+```
+#### remove
+```python 
+>>> lst = [1, 2, 3]
+>>> lst.remove(2)
+[1, 3]
+```
+#### extend
+```python 
+>>> lst = [1, 2]
+>>> lst.extend([3, 4]) 
+[1, 2, 3, 4]
+```
+#### clear
+```python 
+>>> lst = [1, 2, 3]
+>>> lst.clear() 
+[]
+```
+#### sort
+```python 
+>>> lst = [3, 1, 2]
+>>> lst.sort() 
+[1, 2, 3]
+```
+#### reverse
+```python 
+>>> lst = [1, 2, 3]
+>>> lst.reverse()
+[3, 2, 1]
+```
+#### copy
+```python 
+>>> lst = [1, 2, 3]
+>>> new_lst = lst.copy() 
+[1, 2, 3]
+```
+#### count
+```python 
+>>> lst = [1, 2, 2, 3]
+>>> lst.count(2)
+2
+```
+#### index
+```python 
+>>> lst = [10, 20, 30]
+>>> lst.index(20) 
+1
+```
+
+#### Вложенный список
+```python 
+>>> spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два спискa
+>>> spis2
+[[111, (5-9j), 'New item'], [4, 5, 6, 7]]
+```
+
+```python 
+>>> spis2[0][1]  #обращение к элементу списка spis1
+(5-9j)
+>>> spis2[0][1]=78  #Убедитесь, что значение элемента заменено на 78
+>>> spis1
+[111, 78, 'New item']
+```
+При создании spis2 = [spis1, [4,5,6,7]] первый элемент списка spis2 не копирует spis1, а хранит ссылку на него.
+Поэтому когда мы изменили элемент spis2[0][1] = 78, это изменение произошло непосредственно в объекте spis1.
+В результате сам spis1 изменился, и его второй элемент 'Список' был заменён на 78.
+
+```python 
+>>> my_list = [42, "Привет, мир!", True, [1, 2, 3]]
+>>> print(my_list)
+[42, 'Привет, мир!', True, [1, 2, 3]]
+```
+
+### 8.2 Объект - кортеж
+	Объект-кортеж похож на список, но его нельзя изменить – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки. Кортежи также поддер­живают включение в них объектов различных типов и операции, типич­ные для последовательностей.
+
+ ```python 
+ >>> kort1=(222,'Kortezh',77+8j)
+ >>> kort1
+(222, 'Kortezh', (77+8j))
+
+>>> kort1= kort1+(1,2)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+>>> kort1= kort1+(ss1b,)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n <Подольский НК>')
+>>> kort2=kort1[:2]+kort1[3:]
+>>> kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n <Подольский НК>')
+ ```
+
+#### Важные методы кортежа
+##### Определение индекса заданного элемента:
+``` python 
+  >>> kort1.index(2)
+  4
+```
+
+##### Подсчет числа вхождений заданного элемента в кортеже:
+``` python 
+>>> kort1.count(222) 
+1
+```
+
+##### Операция замены элемента кортежа
+``` python
+>>> kort1[2]=90   
+Traceback (most recent call last):
+  File "<pyshell#112>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+
+#### Создание объекта-кортежа с элементами разных типов:
+``` python
+>>> my_tuple = (99, "Python", [1, 2, 3], (True, False))
+>>> print(my_tuple)
+(99, 'Python', [1, 2, 3], (True, False))
+```
+
+### 8.3 Объект - словарь
+``` python
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+```
+
+``` python
+>>> dic1['Orel']
+56
+```
+
+``` python 
+>>> dic1['Pskov']=78
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+
+```python
+>>> sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+
+>>> sorted(dic1.values())
+[45, 56, 78, 145]
+```
+
+##### Создадим словарь
+``` python
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}
+>>> dic2
+{1: 'mean', 2: 'standart deviation', 3: 'correlation'}
+
+>>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+>>> dic3
+{'statistics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']}
+
+>>> dic3['statistics'][2]
+'standart deviation'
+
+>>> dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+>>> dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n <Подольский НК>'}
+
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+>>> dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n <Подольский НК>'}
+```
+
+```python
+# кортеж с 7 элементами
+>>> keys_tuple = ('a', 'b', 'c', 'd', 'e', 'f', 'g')
+
+# список с 5 элементами
+>>> values_list = [1, 2, 3, 4, 5]
+
+>>> my_dict = dict(zip(keys_tuple, values_list))
+>>> print(my_dict)
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
+
+>>> len(my_dict)
+5
+```
+- У нас есть **7 ключей** и **5 значений**.
+- Функция zip работает до тех пор, пока хватает элементов в самой короткой последовательности.
+- Так как в списке только 5 элементов, то сформировалось 5 пар «ключ–значение».
+### 8.4 Объект-множество – это неупорядоченная совокупность неповторяющихся элементов
+```python
+
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+
+>>> mnoz1
+
+{'датчик', 'линия связи', 'двигатель', 'микропроцессор'}
+
+>>> len(mnoz1)
+
+4
+
+>>> 'датчик' in mnoz1
+
+True
+
+>>> mnoz1.add('реле')
+
+>>> mnoz1
+
+{'двигатель', 'датчик', 'микропроцессор', 'реле', 'линия связи'}
+
+>>> mnoz1.remove('линия связи')
+
+>>> mnoz1
+
+{'двигатель', 'датчик', 'микропроцессор', 'реле'}
+
+Самостоятельно придумал объект-множество с элементами разных
+``` python
+>>> mnoz2 = {1, 'число',(15, 30, 45), 3.14}
+>>> mnoz2
+{1, (15, 30, 45), 3.14, 'число'}
+>>> len(mnoz2)  # количество элементов
+4
+>>> 'число' in mnoz2 
+True
+>>> mnoz2.add(False)
+>>> mnoz2
+>>> {False, 1, 3.14, 'число', (15, 30, 45)}
+>>> mnoz2.remove(1)
+>>> mnoz2
+
+{False, 3.14, 'число', (15, 30, 45)}
+```
+### 1.16 Завершаем работу со средой.
+Выбираем File и exit.
+### 1.17 Контрольные вопросы.

TEMA2/task.md

@@ -0,0 +1,77 @@
+# Общее контрольное задание по теме 2
+Бушманов Артём Сергеевич, А-01-23
+## Задание
+**Общее контрольное задание**
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+· Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+· Создать переменную со значением, совпадающим с первой буквой из familia.
+· Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+· Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+· Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+· Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
+· Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+· Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+## Решение
+
+### 1. Создаю переменную familia
+
+```python
+>>> familia = 'Bushmanov'
+```
+
+### 2. Создаю переменную которая = первой букве familia
+
+```python
+>>> fam1=familia[0]
+>>> fam1
+'B'
+```
+
+### 3. Создаю переменную с именем sp_kw, значение – списк всех ключевых слов Python.
+
+```python
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+### 4. Удаляю из списка sp_kw значение 'nonlocal', затем убедился, что это значение удалено из списка.
+
+```python
+>>> sp_kw.remove('nonlocal')
+>>> sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+### 5. Создаю кортеж kort_nam с моим и еще 3-х студентов из группы именами. Проверяю, что тип переменной – это tuple.
+
+```python
+>>> kort_nam = ("Nikita", "Vadim", "Artem", "Dima")
+>>> type(kort_nam)
+<class 'tuple'>
+```
+
+### 6. Добавляю в kort_nam имена двух студентов.
+
+```python
+>>> kort_nam += ("Vanya", "Pasha")
+>>> kort_nam
+('Nikita', 'Vadim', 'Artem', 'Dima', 'Vanya', 'Pasha')
+```
+
+### 7. Определяю, сколько раз в кортеже присутствуют студенты с именем «Vanya».
+
+```python
+>>> kort_nam.count("Vanya")
+1
+```
+
+### 8. Создаю словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+```python
+>>> dict_bas = {"строка": familia, "список": sp_kw, "кортеж": kort_nam,}
+>>> dict_bas
+{'строка': 'Bushmanov', 'список': ['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'], 'кортеж': ('Artyom', 'Dmitriy', 'Maksim', 'Denis', 'Pavel', 'Aleksandr')}
+```

TEMA2/task2.md

@@ -0,0 +1,16 @@
+# Индивидуальное контрольное задание по теме 2 
+Бушманов Артём Сергеевич, А-01-23
+## Задание (Вариант 5)
+Создайте объект
+gg=(11,2,-4,23,12,56)
+
+К какому классу относится этот объект? Подсчитайте сумму его элементов, расположенных на нечетных позициях.
+
+## Решение
+``` python
+gg = (11, 2, -4, 23, 12, 56)
+print(gg)
+print("Класс:", type(gg))
+s = sum(gg[0::2])
+print("Сумма (нечетных):", s) 
+```

TEMA2/task2.py

@@ -0,0 +1,5 @@
+gg = (11, 2, -4, 23, 12, 56)
+print(gg)
+print("Класс:", type(gg))
+s = sum(gg[0::2])
+print("Сумма (нечетных):", s) 

TEMA3/task.md

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

TEMA3/test.md

@@ -0,0 +1,57 @@
+# Индивидуальное контрольное задание
+Бушманов Артём Сергеевич A-01-23
+## Вопрос M1_9
+
+1) В каком месте инструкции и как можно написать комментарий?
+
+2) Создайте объект список с 10 элементами - русскоязычными названиями продуктов. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3) Удалите из списка 5 и 6 элементы, считая от первого. Определите число оставшихся элементов. Замените 4-й элемент на "трюфель". Отобразите получившийся объект.
+
+4) Преобразуйте список в кортеж. Отобразите полученный объект. Создайте новый кортеж с удалением из ранее созданного кортежа элемента "трюфель".
+
+5) Напишите инструкцию проверки наличия в списке элемента "молоко". Если его нет в списке, добавьте его туда, иначе - удалите его из списка.
+## Ответ: 
+1) Комментарий можно писать в любой части строки после символа "#"
+2) 
+```python
+>>>products = ["хлеб", "молоко", "сыр", "яблоко", "груша", "картофель", "морковь", "капуста", "тыква", "лук"]
+>>>products
+['хлеб', 'молоко', 'сыр', 'яблоко', 'груша', 'картофель', 'морковь', 'капуста', 'тыква', 'лук']
+>>>type(products) == list #Проверка на то что это список
+True #Верно это список
+>>>dir(products)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+```
+3)
+```python
+>>>del products[5]  # Удаляем 6-й элемент ("картофель")
+>>>del products[4]  # Удаляем 5-й элемент ("груша")
+>>>len(products) # Определяем сколько осталось элементов
+>>>products[3] = "трюфель" #Замена 4 элемента
+>>>products
+['хлеб', 'молоко', 'сыр', 'трюфель', 'груша', 'морковь', 'капуста', 'тыква', 'лук']
+```
+4)
+```python
+>>>products_tuple = tuple(products)
+>>>products_tuple
+('хлеб', 'молоко', 'сыр', 'трюфель', 'морковь', 'капуста', 'тыква', 'лук')
+products_tuple = tuple(products)
+print(products_tuple)
+#Удаляем трюфель
+>>>products_list = list(products_tuple) 
+>>>products_list.remove("трюфель")
+>>>products_tuple_no_truffle = tuple(products_list)
+>>>products_tuple_no_truffle
+```
+5)
+```python
+#Проверка на наличие элемента "молоко"
+if "молоко" in products:
+    products.remove("молоко")
+else:
+    products.append("молоко")
+
+print(products)
+```

TEMA3/Отчет по теме 3.md

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

TEMA4/report.md

@@ -0,0 +1,658 @@
+# Отчет по теме 4
+## Бушманов Артём Сергеевич А-01-23
+## 1. Запуск интерактивной оболочки IDLE
+
+## 2. Стандартные функции
+
+### 2.1. Функция round – округление числа с заданной точностью
+```python
+>>>round(123.456,1)
+123.5
+>>>type(round(123.456,1))
+<class 'float'>
+>>>round(123.456,0)
+123.0
+>>>type(round(123.456,0))
+<class 'float'>
+>>>round(123.456)
+123
+>>>type(round(123.456))
+<class 'int'>
+```
+Если ndigits не указан — возвращает округлённое целое число.
+Если ndigits указан (даже 0) — возвращает число с плавающей точкой.
+Использует банковское округление: если число посередине между двумя возможными, выбирается ближайшее чётное.
+
+### 2.2. Функция range – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+
+```python
+>>>gg = range(76, 123, 9)
+>>>list(gg)
+[76, 85, 94, 103, 112, 121]
+>>>range(23)
+range(0, 23)
+>>>type(range(23))
+<class 'range'>
+>>>list(range(0,26))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
+```
+Объект range(26) будет содержать последовательность целых чисел, начиная с 0 и до 25 (так как 26 не включается). Чтобы это увидить, необходимо применить list(). range — это легковесный объект, который генерирует числа на лету, а не хранит их все в памяти, поэтому преобразование в list нужно только для просмотра. Границы диапазона: от 0 и до 23, проход с шагом 1 по умолчанию.
+
+### 2.3. Функция zip - создание итерируемого объекта из кортежей
+Объединяет несколько последовательностей в кортежи поэлементно.
+Идёт до самой короткой последовательности.
+Возвращает итератор класса zip, а не список. Для вывода: list(zip(...)).
+Используется для параллельной обработки нескольких списков.
+```python
+>>>qq = ["Bushmanov", "Podolskiy", "Terehov", "Butko"]
+>>>ff = zip(gg, qq)
+>>>ff
+<zip object at 0x0000021278293500>
+>>>tuple(ff)
+((76, 'Bushmanov'), (85, 'Podolskiy'), (94, 'Terehov'), (103, 'Butko'))
+```
+Длина получившегося объекта соответствует длине меньшего объекта-параметров(длина 4 значения). 
+```python
+>>>ff[1]
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+К объекту ff нельзя обратиться по индексу из-за того что он не итерируемый, так же он является не изменяемым.
+
+### 2.4. Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки. 
+Вычисляет строку как выражение Python и возвращает результат.
+Можно использовать для динамических вычислений.
+Опасна: при вводе непроверенного текста может выполняться произвольный код.
+
+```python
+>>>fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=55
+>>>fff
+55.0
+>>>dan
+119.0
+```
+### 2.5. Функция exec – чтение и выполнение объекта-аргумента функции.
+```python
+>>>exec(input('введите инструкции:'))        
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>>gg          
+221.456
+```
+- Исполняет строку как инструкцию Python.Отличие от eval: не возвращает значение, может создавать переменные и функции.
+- Опасна при работе с вводом пользователя.
+
+### 2.6. Функции abs, pow, max, min, sum, divmod, len, map. 
+- Функция abs(возвращение модуля):
+```python
+>>>x = abs(-10)           
+>>>x            
+10
+```
+- Функция pow(возведение в степень)
+```python
+>>>pow(2, 10)         
+1024
+>>>pow(4,5,10) # 4**5 = 1024, затем 1024 % 10 = 4           
+4
+```
+- Функции max и min(выбор максимального и минимального значения соответственно)
+```python
+>>>max(40, 50, 6)        
+50
+>>>min(-3, 57, 30)           
+-3
+```
+- Функция sum(суммирование элементов)
+```python
+>>>sum([1,2,3,4,5])           
+15
+>>>sum([1,2,3,4,5], -5)            
+10
+```
+- Функция divmod(возвращение кортежа из целой части и остатка от деления)
+```python
+>>>divmod(36, 5)          
+(7, 1)
+```
+- Функция len(длина списка)
+```python
+>>>len([1,2,3,4,5,6])          
+6
+```
+- Функция map ( это встроенная функция Python, которая применяет заданную функцию к каждому элементу итерируемого объекта (списка, кортежа и т.д.) и возвращает итератор с результатами.)
+```python
+>>>a = [10, 20, 30]
+>>>a
+[10, 20, 30]
+>>>b = [30, 20, 10]
+>>>b
+[30, 20, 10]
+>>>result = list(map(lambda x, y: x + y, a, b))
+>>>result
+[40, 40, 40]
+```
+
+## 3. Функции из стандартного модуля math – совокупность разнообразных математических функций.
+```python
+>>>import math
+>>>dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(x, /)
+    Find x!.
+    
+    Raise a ValueError if x is negative or non-integral.
+
+>>>math.factorial(5)
+120
+```
+Аналогичным образом изучим и попробуем применить некоторые другие функции из этого модуля: sin, acos, degrees, radians, exp, log, log10, sqrt, ceil, floor, pi.
+- Функция sin - - тригонометрия в радианах.
+```python
+>>>help(math.sin)
+Help on built-in function sin in module math:
+sin(x, /)
+    Return the sine of x (measured in radians).
+>>>math.sin(math.pi / 3)
+0.8660254037844386
+```
+- Функция acos - обратные функции.
+```python
+>>>help(math.acos)
+Help on built-in function acos in module math:
+acos(x, /)
+    Return the arc cosine (measured in radians) of x.
+    
+    The result is between 0 and pi.
+>>>math.acos(1)
+0.0
+```
+- Функция degrees - перевод между градусами и радианами.
+```python
+>>>help(math.degrees)
+Help on built-in function degrees in module math:
+degrees(x, /)
+    Convert angle x from radians to degrees.
+>>>math.degrees(math.pi / 2)
+90.0
+```
+- Функция radians - перевод между градусами и радианами.
+```python
+>>>help(math.radians)
+Help on built-in function radians in module math:
+
+radians(x, /)
+    Convert angle x from degrees to radians.
+>>>math.radians(360)
+6.283185307179586
+>>>math.radians(157)
+2.7401669256310974
+```
+- Функция exp - e**x
+```python
+>>>help(math.exp)
+Help on built-in function exp in module math:
+exp(x, /)
+    Return e raised to the power of x.
+>>>math.exp(3)         
+20.085536923187668
+>>>math.exp(5)            
+148.4131591025766
+```
+- Функция log - логарифм (натуральный или по базе).
+```python
+>>>help(math.log)          
+Help on built-in function log in module math:
+
+log(...)
+    log(x, [base=math.e])
+    Return the logarithm of x to the given base.
+    
+    If the base not specified, returns the natural logarithm (base e) of x.
+>>>math.log(10)           
+2.302585092994046
+>>>math.log(math.e)            
+1.0
+```
+- Функция log10 - десятичный логарифм.
+```python
+>>>help(math.log10)       
+Help on built-in function log10 in module math:
+
+log10(x, /)
+    Return the base 10 logarithm of x.
+>>>math.log10(10)           
+1.0
+>>>math.log10(100)
+2.0
+>>>math.log10(105)           
+>>>2.0211892990699383
+```
+- Функция sqrt - корень (ошибка при отрицательных).
+```python
+>>>help(math.sqrt)         
+Help on built-in function sqrt in module math:
+
+sqrt(x, /)
+    Return the square root of x.
+>>>math.sqrt(16)           
+4.0
+>>>math.sqrt(25)           
+5.0
+```
+- Функция ceil(округление в большую сторону)
+```python
+help(math.ceil)         
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+    
+    This is the smallest integer >= x.
+
+>>>math.ceil(4.56)           
+5
+>>>math.ceil(130.1)            
+131
+```
+- Функция floor(округление в меньшую сторону)
+```python
+>>>help(math.floor)           
+Help on built-in function floor in module math:
+
+floor(x, /)
+    Return the floor of x as an Integral.
+    
+    This is the largest integer <= x.
+
+>>>math.floor(99.999)          
+99
+```
+- Функция pi
+```python
+>>>math.pi
+3.141592653589793
+```
+
+## 4.  Функции из модуля cmath – совокупность функций для работы с комплексными числами.
+```python
+>>>import cmath
+>>>dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+>>>cmath.sqrt(1.2-0.5j) # извлечения квадратного корня из комплексного числа (возвращает комплексный результат даже для отрицательных)
+(1.118033988749895-0.22360679774997896j)
+>>>cmath.phase(1-0.5j) # функция расчета фазы(аргумент (фаза) комплексного числа в радианах)
+-0.4636476090008061
+```
+## 5. Стандартный модуль random – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+```python
+>>>import random
+>>>dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>>help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+    
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+    
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+    
+    If *a* is an int, all bits are used.
+    
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+>>>random.seed()
+```
+Фиксирует исходное состояние генератора (повторяемость результатов).
+random.seed(x) инициализирует внутреннее состояние генератора Mersenne Twister. Однаковый seed => одна и та же последовательность псевдослучайных значений при том же порядке вызовов.
+- Функци random(равномерно распределенное случайное число от 0 до 1)
+```python
+>>>help(random.random)
+Help on built-in function random:
+
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+
+>>>random.random()
+0.15224090837130377
+>>>random.random()
+0.8451183120672832
+>>>random.random()
+0.8392090272295469
+```
+
+- Функция uniform (равномерно распределенное случайное число)
+```python
+>>>help(random.uniform)
+Help on method uniform in module random:
+
+uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+
+>>>random.uniform(1, 5)
+1.4822447721210175
+>>>random.uniform(1, 500)
+11.101749613668387
+```
+равномерно от a до b.
+- Функция gauss(нормально распределенное случайное число)
+```python
+>>>help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu, sigma) method of random.Random instance
+    Gaussian distribution.
+    
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+    
+    Not thread-safe without a lock around calls.
+
+>>>random.gauss(1, 5)
+5.705708773458442
+>>>random.gauss(12, 57)
+-14.33510203993609
+```
+нормально распределённое число.
+- Функция randint(случайные целые числа)
+```python
+>>>help(random.randint)
+Help on method randint in module random:
+
+randint(a, b) method of random.Random instance
+    Return random integer in range [a, b], including both end points.
+
+>>>random.randint(3, 19)
+4
+>>>random.randint(3, 19)
+5
+```
+целое от a до b включительно.
+- Функция choice (случайный выбор из совокупности)
+```python
+>>>help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+
+>>>random.choice([True, "ababba", 35, 90.3, 3+5j])
+90.3
+>>>random.choice([True, "ababba", 35, 90.3, 3+5j])
+(3+5j)
+```
+
+- Функця shuffle (случайная перестановка элементов списка)
+```python
+>>>help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x, random=None) method of random.Random instance
+    Shuffle list x in place, and return None.
+    
+    Optional argument random is a 0-argument function returning a
+    random float in [0.0, 1.0); if it is the default None, the
+    standard random.random will be used.
+
+>>>lst = [True, "ababba", 35, 90.3, 3+5j]
+>>>random.shuffle(lst)
+>>>lst
+[35, 'ababba', 90.3, (3+5j), True]
+```
+- Функция sample (случайный выбор подмножества элементов)
+```python
+>>>help(random.sample)
+Help on method sample in module random:
+
+sample(population, k, *, counts=None) method of random.Random instance
+    Chooses k unique random elements from a population sequence or set.
+    
+    Returns a new list containing elements from the population while
+    leaving the original population unchanged.  The resulting list is
+    in selection order so that all sub-slices will also be valid random
+    samples.  This allows raffle winners (the sample) to be partitioned
+    into grand prize and second place winners (the subslices).
+    
+    Members of the population need not be hashable or unique.  If the
+    population contains repeats, then each occurrence is a possible
+    selection in the sample.
+    
+    Repeated elements can be specified one at a time or with the optional
+    counts parameter.  For example:
+    
+        sample(['red', 'blue'], counts=[4, 2], k=5)
+    
+    is equivalent to:
+    
+        sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
+    
+    To choose a sample from a range of integers, use range() for the
+    population argument.  This is especially fast and space efficient
+    for sampling from a large population:
+    
+        sample(range(10000000), 60)
+
+>>>random.sample(lst, 5)
+['ababba', 90.3, True, (3+5j), 35]
+>>>random.sample(lst, 1)
+['ababba']
+```
+- Функция betavariate(случайное число с бета-распределением)
+```python
+>>>help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+    
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+>>>random.betavariate(1, 2)
+0.3174347054415454
+>>>random.betavariate(1, 2)
+0.17833765040946833
+```
+
+- Функция gammavariate(случайное число с гамма-распределением)
+```python
+>>>help(random.gammavariate)
+Help on method gammavariate in module random:
+
+gammavariate(alpha, beta) method of random.Random instance
+    Gamma distribution.  Not the gamma function!
+    
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    
+    The probability distribution function is:
+    
+                x ** (alpha - 1) * math.exp(-x / beta)
+      pdf(x) =  --------------------------------------
+                  math.gamma(alpha) * beta ** alpha
+
+>>>random.gammavariate(2, 5)
+18.174658510394487
+>>>random.gammavariate(2, 5)
+29.01757536081825
+```
+
+- Создание списка с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям и с любыми допустимыми значениями параметров этих распределений.
+```python
+>>>ls_r = [0] * 4
+>>>ls_r[0] = random.uniform(0, 5)
+>>>ls_r[1] = random.gauss(0, 2)
+>>>ls_r[2] = random.betavariate(1, 3)
+>>>ls_r[3] = random.gammavariate(3, 2)
+>>>ls_r
+[2.1956405045678467, -2.238234699654799, 0.30508834143011926, 1.9912119529312582]
+```
+## 6. Функции из модуля time – работа с календарем и со временем.
+- UNIX время и текущее время
+```python
+>>>import time
+>>>dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+c1=time.time()
+c1
+1759739386.6377628
+>>>c2=time.time()-c1 # временной интервал в секундах, со времени ввода предыдущей инструкции
+>>>c2
+26.08662247657776
+>>>dat = time.gmtime() # Эта функция возвращает, так называемое, «Всемирное координированное время» (UTC)
+>>>dat.tm_mon # получение номера месяца
+10
+>>>dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=8, tm_min=57, tm_sec=30, tm_wday=0, tm_yday=279, tm_isdst=0)
+
+```
+
+- Текущее время с учетом часового пояса
+```python
+>>>mestn = time.localtime()                     
+>>>list(mestn)                   
+[2025, 10, 24, 12, 18, 35, 0, 279, 0]
+```
+
+- Функция asctime (преобразование представления времени из кортежа в строку) 
+```python
+>>>time.asctime(mestn)
+                      
+'Mon Oct  24 12:18:35 2025'
+```
+- Функция ctime (преобразование времени в секундах, прошедшего с начала эпохи, в строку)
+```python
+>>>time.ctime()
+                      
+'Mon Oct  24 12:22:01 2025'
+```
+
+- Функция sleep (прерывание работы программы на заданное время)
+```python
+>>>time.sleep(5)
+```
+
+- Функция mktime (преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи)
+```python
+>>>time.mktime(mestn)
+                      
+1759742315.0
+```
+
+- Обратное преобразование из секунд в местное время 
+```python
+>>>time.localtime(c1)
+                      
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=6, tm_hour=11, tm_min=29, tm_sec=46, tm_wday=0, tm_yday=279, tm_isdst=0)
+```
+
+
+## 7. Графические функции
+
+Импортируем модули mathplotlib и pylab для  построения графика.
+
+-Создание и отображение графика x(t):
+
+```python
+>>>import matplotlib
+>>>import pylab
+
+>>>x=list(range(-3,55,4))
+>>>t=list(range(15))
+>>>pylab.plot(t,x) #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x0000021222D40400>]
+>>>pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>>pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>>pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>>pylab.show() #Отображение графика на экране
+```
+![График](figure0.pn
+g)
+
+- Рассмотрим способ построения нескольких графиков на одном рисунке.
+```python
+>>>X1 = [12, 6, 8, 10, 7]
+>>>X2 = [5, 7, 9, 11, 13]
+>>>pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000021222DF35B0>]
+>>>pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000021222DF38B0>]
+>>>pylab.show()
+```
+![График](figure1.png)
+
+
+- Теперь изучим возможность построения круговой диаграммы.
+```python
+>>>region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>>naselen=[65,12,23,17] # Значения для диаграммы
+>>>pylab.pie(naselen, labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000021225094EB0>, <matplotlib.patches.Wedge object at 0x0000021225094DF0>, <matplotlib.patches.Wedge object at 0x0000021225095900>, <matplotlib.patches.Wedge object at 0x0000021225095E70>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>>pylab.show()  #Отображение диаграммы
+```
+![График](figure2.png)
+
+
+- Построение гистограммы
+```python
+>>>pylab.show()
+>>>data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
+>>>pylab.hist(data)
+(array([1., 0., 2., 0., 0., 3., 0., 2., 0., 1.]), array([1. , 1.4, 1.8, 2.2, 2.6, 3. , 3.4, 3.8, 4.2, 4.6, 5. ]), <BarContainer object of 10 artists>)
+>>>pylab.title('Простая гистограмма')
+Text(0.5, 1.0, 'Простая гистограмма')
+>>>pylab.xlabel('Значения')
+Text(0.5, 0, 'Значения')
+>>>pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+>>>pylab.show()
+```
+
+![График](figure3.png)
+
+
+- Построение столбиковой диаграммы
+```python
+>>>fruits = ["apple", "date", "apricot", "raspberry", "watermelon"]
+>>>values = [13, 16, 8, 25, 6]
+>>>pylab.bar(fruits, values, color='green')
+<BarContainer object of 5 artists>
+>>>pylab.show()
+```
+
+![График](figure4.png)
+
+
+Все графики, диаграммы и гистограммы сохранены в папку в формате "jpg".
+
+## 8. Статистический модуль statistics
+
+```python
+>>>data = [10, 20, 30, 40, 50]
+>>>statistics.mean(data) # Нахождение математического ожидания
+30
+>>>statistics.median(data) # Нахождение медианы
+30
+>>>statistics.stdev(data) # Нахождение среднеквадратичного отклонения
+15.811388300841896
+>>>statistics.variance(data) # Нахождение дисперсии
+250
+>>>statistics.mode(data) # Нахождение моды
+10
+```
+
+## 9. Завершение работы

TEMA4/task.md

@@ -0,0 +1,44 @@
+# Общее контрольное задание по теме 4
+Бушманов Артём Сергеевич А-01-23 
+## Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+·      Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+
+·      Создайте объект класса **struct****_****time** с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+·      Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+
+·      Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+·      Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+·      Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+## Выполнение
+```Python
+>>>import math
+>>>import cmath
+>>>import random
+>>>divmod((round(cmath.phase(0.2 + 0.8j), 2) * 20), 3)
+(8.0, 2.6000000000000014)
+>>>msc_t  = time.localtime()
+>>>msc_t
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=12, tm_min=30, tm_sec=42, tm_wday=4, tm_yday=297, tm_isdst=0)
+>>>nows = str(msc_t.tm_hour) + " " + str(msc_t.tm_min)
+>>>nows
+'12 30'
+>>>liist = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
+>>>random.sample(liist, 3)
+['четверг', 'понедельник', 'вторник']
+>>>random.choice(range(14, 33, 3))
+29
+>>>N = round(random.gauss(15,4))
+>>>N
+9
+>>>spis = list('qawsedrftgyhujikol')
+>>>spis = list('qawsedrftgyhujikolp')
+???random.sample(spis, N)
+['d', 'u', 'h', 's', 'e', 'y', 'o', 'r', 'w']
+>>>(time.mktime(time.localtime()) - time.mktime(msc_t)) / 60
+1.1666666666666667
+```

TEMA4/test.md

@@ -0,0 +1,16 @@
+# Индивидуальное контрольное задание по теме 4
+## Бушманов Артём Сергеевич А-01-23
+# Задание:
+Напишите инструкцию создания переменной со значением – календарными данными момента начала выполнения контрольного задания. Создайте кортеж с последовательностью элементов со значениями от -26 до 46 с шагом 9. Подсчитайте число элементов в созданном кортеже. Отобразите результат в виде строки по шаблону: «Число элементов = <значение>». Напишите инструкцию определения числа секунд, прошедших с начала выполнения контрольного задания.
+# Выполнение задания:
+```python
+>>>from datetime import datetime 
+>>>start = datetime.now() 
+>>>kortezh = tuple(range(-26, 47, 9)) 
+>>>n = len(kortezh) 
+>>>print("Число элементов =", n) 
+Число элементов = 9 
+>>>seconds = (datetime.now() - start).total_seconds() 
+>>>print("Прошло секунд:", seconds) 
+Прошло секунд: 101.565234
+```

TEMA5/report.md

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

TEMA5/task.md

@@ -0,0 +1,150 @@
+# Общее контрольное задание по теме 5
+
+## Задание:
+
+- Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+- Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+- Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+
+## Решение:
+
+```
+# Часть 1
+>>>text = "Python is a programming language that lets you work quickly and integrate systems more effectively"
+>>>text
+'Python is a programming language that lets you work quickly and integrate systems more effectively'
+>>>alphabet = "abcdefghijklmnopqrstuvwxyz"
+>>>for now  in range(len(text)):
+    low = text.lower()
+    letter = low[now]
+    if letter in alphabet:
+        print("Буква ", letter, " Порядковый номер: ", alphabet.index(letter) + 1)
+    else: continue 
+Буква  p  Порядковый номер:  16
+Буква  y  Порядковый номер:  25
+Буква  t  Порядковый номер:  20
+Буква  h  Порядковый номер:  8
+Буква  o  Порядковый номер:  15
+Буква  n  Порядковый номер:  14
+Буква  i  Порядковый номер:  9
+Буква  s  Порядковый номер:  19
+Буква  a  Порядковый номер:  1
+Буква  p  Порядковый номер:  16
+Буква  r  Порядковый номер:  18
+Буква  o  Порядковый номер:  15
+Буква  g  Порядковый номер:  7
+Буква  r  Порядковый номер:  18
+Буква  a  Порядковый номер:  1
+Буква  m  Порядковый номер:  13
+Буква  m  Порядковый номер:  13
+Буква  i  Порядковый номер:  9
+Буква  n  Порядковый номер:  14
+Буква  g  Порядковый номер:  7
+Буква  l  Порядковый номер:  12
+Буква  a  Порядковый номер:  1
+Буква  n  Порядковый номер:  14
+Буква  g  Порядковый номер:  7
+Буква  u  Порядковый номер:  21
+Буква  a  Порядковый номер:  1
+Буква  g  Порядковый номер:  7
+Буква  e  Порядковый номер:  5
+Буква  t  Порядковый номер:  20
+Буква  h  Порядковый номер:  8
+Буква  a  Порядковый номер:  1
+Буква  t  Порядковый номер:  20
+Буква  l  Порядковый номер:  12
+Буква  e  Порядковый номер:  5
+Буква  t  Порядковый номер:  20
+Буква  s  Порядковый номер:  19
+Буква  y  Порядковый номер:  25
+Буква  o  Порядковый номер:  15
+Буква  u  Порядковый номер:  21
+Буква  w  Порядковый номер:  23
+Буква  o  Порядковый номер:  15
+Буква  r  Порядковый номер:  18
+Буква  k  Порядковый номер:  11
+Буква  q  Порядковый номер:  17
+Буква  u  Порядковый номер:  21
+Буква  i  Порядковый номер:  9
+Буква  c  Порядковый номер:  3
+Буква  k  Порядковый номер:  11
+Буква  l  Порядковый номер:  12
+Буква  y  Порядковый номер:  25
+Буква  a  Порядковый номер:  1
+Буква  n  Порядковый номер:  14
+Буква  d  Порядковый номер:  4
+Буква  i  Порядковый номер:  9
+Буква  n  Порядковый номер:  14
+Буква  t  Порядковый номер:  20
+Буква  e  Порядковый номер:  5
+Буква  g  Порядковый номер:  7
+Буква  r  Порядковый номер:  18
+Буква  a  Порядковый номер:  1
+Буква  t  Порядковый номер:  20
+Буква  e  Порядковый номер:  5
+Буква  s  Порядковый номер:  19
+Буква  y  Порядковый номер:  25
+Буква  s  Порядковый номер:  19
+Буква  t  Порядковый номер:  20
+Буква  e  Порядковый номер:  5
+Буква  m  Порядковый номер:  13
+Буква  s  Порядковый номер:  19
+Буква  m  Порядковый номер:  13
+Буква  o  Порядковый номер:  15
+Буква  r  Порядковый номер:  18
+Буква  e  Порядковый номер:  5
+Буква  e  Порядковый номер:  5
+Буква  f  Порядковый номер:  6
+Буква  f  Порядковый номер:  6
+Буква  e  Порядковый номер:  5
+Буква  c  Порядковый номер:  3
+Буква  t  Порядковый номер:  20
+Буква  i  Порядковый номер:  9
+Буква  v  Порядковый номер:  22
+Буква  e  Порядковый номер:  5
+Буква  l  Порядковый номер:  12
+Буква  y  Порядковый номер:  25
+
+# Часть 2 
+>>>spis = text_2.split(" ")
+>>>spis
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта.', 'Для', 'этого', 'списка', '–', 'определите,', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение,', 'и', 'выведите', 'соответствующее', 'сообщение:', 'либо', 'о', 'нахождении', 'элемента,', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся,', 'так', 'и', 'с', 'отсутствующим', 'словом']
+target = "заданное"
+>>>if target in spis:
+    print("The word was find")
+	else:    
+	    print("Not found")  
+The word was find
+>>>target = "задать"
+>>>if target in spis:
+        print("The word was find")
+	else:
+	    print("Not found") 
+Not found
+
+# Часть 3
+>>>students = ['Podolskiy', 'Melnikov', 'Zhalnin']
+>>>summer_marks = [4.20, 4.13, 4.15]
+>>>students2 = ['Zhalnin', 'Melnikov', 'Podolskiy']
+>>>winter_marks = [4.3, 4.4, 4.5]
+>>>stud = input("Введите фамилию: ")
+>>>if stud not in students or stud not in students2:
+    print("Такого студента нет в списках.")
+else:
+    idx_summer = students.index(stud)
+    idx_winter = students2.index(stud)
+    print("Летний средний балл: ", summer_marks[idx_summer])
+    print("Зимний средний балл: ", winter_marks[idx_winter])
+
+Введите фамилию: Bushmanov
+Такого студента нет в списках.
+
+Введите фамилию: Podolskiy
+Летний средний балл:  4.2 
+Зимний средний балл:  4.5
+
+Введите фамилию: Zhalnin
+Летний средний балл:  4.15 
+Зимний средний балл:  4.3
+```

TEMA5/test.md

@@ -0,0 +1,42 @@
+# Индивидуальное контрольное задание
+
+Бушманов Артём, А-01-23
+
+## Задание:
+Запросите у пользователя ввод списка с двумя числовыми элементами. Обеспечьте проверку корректности ввода (что введено, действительно, два элемента) и проверку совпадения знаков у введенных чисел. Если проверка дала негативный результат, выдать сообщение и обеспечить повторение ввода. Если все хорошо, отобразить введенный список с заголовком.
+
+## Решение:
+```python
+while True:  
+    s = input("Введите ДВА числа через пробел: ")  
+    parts = s.split()  
+    if len(parts) != 2:  
+        print("Нужно ввести ровно два элемента!")  
+        continue  
+    a = float(parts[0])  
+    b = float(parts[1])  
+    if (a > 0 and b > 0) or (a < 0 and b < 0) or (a == 0 and b == 0):  
+        nums = [a, b]  
+        print("Введённый список с одинаковым знаком элементов:", nums)  
+        break  
+    else:  
+        print("Знаки чисел не совпадают, попробуйте ещё раз.")
+```
+
+## *Проверка:*
+```python
+Введите ДВА числа через пробел: 12 12 12
+Нужно ввести ровно два элемента!
+Введите ДВА числа через пробел: 12
+Нужно ввести ровно два элемента!
+Введите ДВА числа через пробел: 12 -12
+Знаки чисел не совпадают, попробуйте ещё раз.
+Введите ДВА числа через пробел: -12 12
+Знаки чисел не совпадают, попробуйте ещё раз.
+Введите ДВА числа через пробел: 12 12 
+Введённый список с одинаковым знаком элементов: [12.0, 12.0]
+Введите ДВА числа через пробел: 321 123
+Введённый список с одинаковым знаком элементов: [321.0, 123.0]
+
+``` 
+

TEMA6/IKZ.py

@@ -0,0 +1,37 @@
+import pickle
+workers = ['Ivanov', 'Petrov', 'Sidorov', 'Smirnov', 'Kuznetsov']
+salaries = (40000, 45000, 42000, 48000, 50000)
+firm_name = input("Введите название фирмы латиницей: ")
+firm_name = firm_name.replace(' ', '')   # убираем пробелы
+print("Название фирмы (без пробелов):", firm_name)
+
+firm_dict = {}
+i = 0
+while i < len(workers):
+    fam = workers[i]
+    pay = salaries[i]
+    firm_dict[fam] = pay
+    i = i + 1
+
+print("Словарь с данными по сотрудникам:")
+print(firm_dict)
+
+
+summa = 0
+j = 0
+while j < len(salaries):
+    summa = summa + salaries[j]
+    j = j + 1
+
+average = summa / len(salaries)
+print("Средний оклад сотрудников фирмы:", average)
+
+
+file_name = firm_name + '.bin'
+fp = open(file_name, 'wb')
+pickle.dump(workers, fp)
+pickle.dump(salaries, fp)
+pickle.dump(firm_dict, fp)
+fp.close()
+
+print("Данные записаны в файл:", file_name)

TEMA6/report.md

@@ -0,0 +1,452 @@
+# Отчет по теме 6
+Бушманов А.С. , А-01-23
+
+## 1. Запуск интерактивной оболочки IDLE. 
+
+## 2. Вывод данных на экран дисплея.
+### 2.1. Вывод в командной строке.
+```python
+>>>stroka='Автоматизированная система управления'
+>>>stroka
+'Автоматизированная система управления'
+```
+Этот способ называется «эхо-выводом». Он пригоден при работе в командной строке, однако в пользовательских функциях, которые будут изучаться дальше, этот способ применять нельзя!
+
+
+### 2.2. Вывод с использованием функции  print. 
+Вывод объектов на экран:
+```python
+>>>fff = 234.5; gg = 'Значение температуры='
+>>>print(gg, fff)  # Можно вывести несколько объектов за одно обращение к функции
+Значение температуры= 234.5
+>>>print(gg, fff, sep='/') # Указание разделителя с помощью sep
+Значение температуры=/234.5
+>>>print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры=/234.5***____
+```
+
+Для простого перехода на новую строку, можно использовать такое обращение:
+```python
+>>>print()
+```
+
+Для большого текста оператор вывода может располагаться на нескольких строках с использованием тройных кавычек:
+```python
+>>>print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+```
+
+Или:
+```python
+>>>print("Здесь может выводиться",
+     "большой текст,",
+     "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+Разница воспроизведения текста на экран видна. В первом случае текст воспринимается как один объект, поэтому имеем соответствующий вывод. Во втором случае наблюдаем работу обычного вывода print() с разделением объектов через пробелы.
+
+
+### 2.3. Вывод с использованием метода write  объекта sys.stdout. 
+```python
+>>>sys.stdout.write('Функция write')
+Функция write13
+```
+Обратим внимание, что этот метод после вывода строки не осуществляет переход на новую строку. Если это требуется, то следует в конце строки добавить один или несколько символов “\n”:
+```python
+>>>sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+Как видим, в этом методе, в обоих случаях, выводится количество введенных символов.
+В этом контексте 14 — это не результат вычисления, а возвращаемое значение функции write в интерактивной консоли, показывающее, сколько символов она успешно вывела.
+
+## 3. Ввод данных с клавиатуры.
+```python
+>>>psw = input('Введите пароль:')
+Введите пароль:123rkn567
+>>>psw
+'123rkn567'
+>>>type(psw)
+<class 'str'>
+```
+
+Пример 1:
+```python
+>>>while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach<17.5 or znach>23.8:
+		print('Ошибка!')
+	else:
+		break	    
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+```
+
+Пример 2:
+```python
+>>>import math
+>>>print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+Введенная через input() строка передается в функцию eval(), которая вычисляет выражение, записанное в этой строке, как код Python. Результат вычисления (возвращаемое значение eval()) передается в функцию print(), которая выводит его на экран. 
+
+## 4. Ввод-вывод при работе с файлами.
+### 4.1. Функции для работы с путем к файлу.
+```python
+>>>import os
+>>>os.getcwd()
+'/Users/ArtyomBushmanov'
+>>>Bushmanov = os.getcwd()
+>>>Bushmanov
+'/Users/ArtyomBushmanov'
+>>>print(Bushmanov)
+/Users/ArtyomBushmanov
+>>>os.chdir('/Users/ArtyomBushmanov/python-labs/TEMA6')
+>>>os.getcwd()
+'/Users/ArtyomBushmanov/python-labs/TEMA6'
+```
+
+ Создание каталога (mkdir)
+```python
+>>>os.chdir("/Users/ArtyomBushmanov/Documents/tmp5")
+>>>os.mkdir("testdir")
+>>>os.chdir("/Users/ArtyomBushmanov/Documents/tmp5/testdir")
+>>>os.getcwd()
+'/Users/ArtyomBushmanov/Documents/tmp5/testdir'
+
+```
+Создаем каталог, затем опускаемся на уровень ниже, чтобы проверить, что каталог создан.
+
+Удаление каталога (rmdir)
+Для удаления каталога необходимо подняться на уровень выше.
+```python
+>>>os.chdir('../')
+>>>os.getcwd()
+'/Users/ArtyomBushmanov/Documents/tmp5'
+>>>os.rmdir("testdir")
+>>>os.rmdir("testdir")
+Traceback (most recent call last):
+  File "<pyshell#18>", line 1, in <module>
+    os.rmdir("testdir")
+FileNotFoundError: [Errno 2] No such file or directory: 'testdir'
+```
+
+ Показать список всех файлов и папок, вложенных в текущую директорию (listdir)
+```python
+>>>os.chdir("/Users/ArtyomBushmanov/python-labs/TEMA6")
+>>>os.listdir()
+['.gitkeep', 'testdir']
+```
+ Проверка существования каталога (os.path.isdir)
+```python
+>>>os.chdir("/Users/ArtyomBushmanov/python-labs/TEMA6")
+>>>os.getcwd()
+'/Users/ArtyomBushmanov/python-labs/TEMA6'
+>>>os.path.isdir("testdir")
+True
+>>>os.path.isdir("netestdir")
+False
+```
+
+Получение символьной строки, содержащей имя файла вместе с полным  путем доступа к нему с помощью функции os.path.abspath:
+```python
+>>>fil=os.path.abspath("oplata.dbf")
+>>>fil
+'/Users/ArtyomBushmanov/python-labs/TEMA6/oplata.dbf'
+>>>fil=os.path.abspath("test.txt")
+>>>fil
+'/Users/ArtyomBushmanov/python-labs/TEMA6/test.txt'
+```
+
+Отделение из абсолютного пути только каталога/только имени файла.
+```python
+>>>drkt = os.path.dirname(fil)
+>>>print(drkt)
+/Users/ArtyomBushmanov/python-labs/TEMA6
+>>>bsnm = os.path.basename(fil)
+>>>print(bsnm)
+test.txt
+```
+Функция os.path.dirname() из абсолютного пути выделяется путь доступа (от диска до последней
+папки). Функция os.path.basename(), наоборот, убирает из абсолютного пути все, кроме имени
+файла.
+
+ Разделение на кортеж из пути и из имени файла.
+```python
+>>>os.path.split(fil)
+('/Users/ArtyomBushmanov/python-labs/TEMA6', 'test.txt')
+>>>type(os.path.split(fil))
+<class 'tuple'>
+```
+ Проверка существования пути, заданного в символьной строке (os.path.exists).
+```python
+>>>os.path.exists("/TEMA9")
+False
+>>>os.path.exists("TEMA9")
+False
+>>>os.path.exists("/Users/ArtyomBushmanov/python-labs/TEMA9")
+True
+```
+ Проверка существования файла.
+```python
+>>>os.path.isfile(fil)
+True
+>>>os.path.isfile(os.path.dirname(fil)+'fil1.txt')
+False
+```
+Первая строка работает корректно - проверяет существование файла fil. Вторая строка содержит ошибку - неправильное объединение путей приводит к несуществующему пути.
+
+### 4.2. Общая схема работы с файлом
+Для обмена данными с файлом необходимо выполнить следующие операции:
+ Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+ Выполнение одной или нескольких операций обмена данными с файлом;
+ Закрытие файла.
+
+### 4.3. Открытие файла для записи или чтения данных – функция open.
+```python
+>>>fp = open(file = drkt+'\\zapis1.txt', mode = 'w')
+>>>type(fp)
+<class '_io.TextIOWrapper'>
+>>>fp
+<_io.TextIOWrapper name='/Users/ArtyomBushmanov/python-labs/TEMA6\\zapis1.txt' mode='w' encoding='UTF-8'>
+```
+Здесь fp – это файловый объект, который в других языках программирования обычно называют файловой переменной. Он сохраняет ссылку на открываемый файл и позволяет в дальнейшем ссылаться на файл, не указывая путь и имя открытого файла.  В аргументе функции с именем file указывается путь и имя открываемого файла, а в аргументе с именем mode – предполагаемая цель его использования (w=write – для записи). 
+
+Аргументы функции с их именами могут располагаться в любом порядке. Если имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать и просто вводить:
+```python
+>>>fp = open(drkt+'\\zapis1.txt', 'w')
+>>fp
+<_io.TextIOWrapper name='/Users/ArtyomBushmanov/python-labs/TEMA6\\zapis1.txt' mode='w' encoding='UTF-8'>
+```
+
+Если путь в переменной drkt совпадает с рабочим каталогом, то его можно опустить, оставив только имя открываемого файла:
+```python
+>>>fp = open('zapis1.txt', 'w')
+>>>fp
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
+>>>type(fp)
+<class '_io.TextIOWrapper'>
+>>>dir(fp)
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+```
+
+Если требуются другие операции с открываемым файлом, то для второго аргумента «mode=…» могут  быть заданы следующие значения:
+	w – запись с созданием нового файла или перезапись существующего файла,
+	w+ - чтение и запись/перезапись файла,
+r – только чтение (это значение - по умолчанию),
+	r+ - чтение и/или запись в существующий файл,
+	a – запись в конец существующего файла или, если его нет, запись с созданием файла,
+	a+ - то же, что и в «a», но с возможностью чтения из файла.
+В зависимости от значения этого аргумента тип создаваемой файловой переменной может быть разным.
+
+Пример открытия бинарного файла:
+```python
+>>>fp1 = open(drkt+'\\zapis2.bin', mode = 'wb+')
+>>>fp1
+<_io.BufferedRandom name='/Users/ArtyomBushmanov/python-labs/TEMA6\\zapis2.bin'>
+```
+
+### 4.4. Закрытие файла. 
+```python
+>>>fp.close()
+>>>fp
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='UTF-8'>
+```
+После закрытия на объект все еще можно посмотреть.
+
+### 4.5. Запись информации в файл с помощью метода write.
+Метод write относится к объекту – файловой переменной.
+Создание списка с элементами-числами от 1 до 12 и запись их в файл по 4 числа на строке:
+```python
+>>>sps = list(range(1, 13))
+>>>fp2 = open('zapis3.txt', 'w')
+>>>fp2.write(str(sps[:4])+'\n')
+13
+>>>fp2.write(str(sps[4:8])+'\n')
+13
+>>>fp2.write(str(sps[8:])+'\n')
+16
+>>>fp2.close()
+```
+Файл из текстового редактора:
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+
+Создание списка с элементами-списками:
+```python
+>>>sps3 = [['Иванов И.',1], ['Петров П.',2], ['Сидоров С.',3]]
+>>>sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>>fp3 = open('zapis4.txt', 'w')
+>>>for i in range(len(sps3)):
+    stroka4 = sps3[i][0] + ' ' + str(sps3[i][1])
+    fp3.write(stroka4)
+11
+11
+12
+>>>fp3.close()
+```
+Файл в текстовом редакторе:
+Иванов И. 1Петров П. 2Сидоров С. 3 - Видно, что вывод в файл получился не качественный
+
+Попробуем изменить код:
+```python
+>>>gh=open('zapis5.txt','w')
+>>>for r in sps3:
+    gh.write(r[0] + ' '+str(r[1]) + '\n')   
+12
+12
+13
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+12
+12
+13
+gh.close()
+```
+Добавился перенос на следующую строку на каждой итерации цикла и пробел в нужном месте. Результат:
+ 
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+
+### 4.6. Первый способ чтения информации из текстового файла.
+```python
+>>>sps1 = []
+>>>fp = open('zapis3.txt')
+>>>for stroka in fp:
+    stroka=stroka.rstrip('\n')
+    stroka=stroka.replace('[','')
+    stroka=stroka.replace(']','')
+    sps1=sps1+stroka.split(',') # В этой строке целые числа превращаются в строки
+>>>fp.close()
+print(sps1)
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+```
+Здесь, перед занесением строки в список с помощью метода rstrip, из неё удаляется символ конца строки, а с помощью метода replace – скобки.
+Заметно, что полученный список отличается от исходного sps типом данных. В sps1 заметна некорректность работы программы(остались лишние пробелы).
+Способ преобразования sps1 в sps:
+```python
+>>>sps2 = [int(i.strip()) for i in sps1]
+>>>sps2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+.strip - убирает пробелы с двух сторон.
+
+
+### 4.7. Чтение информации из файла с помощью метода read.
+Метод read, как и write, относится к объекту – файловой переменной. В качестве аргумента этого метода может задаваться целое число – количество символов или, если открыт бинарный файл, - количество байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла, начиная с текущего положения маркера. Если указанное число превышает количество оставшихся символов (байт) в файле, то считываются все оставшиеся символы (байты). Если это число не указано, то считываются вся информация от маркера до конца файла. Метод возвращает строку с символами или совокупность байт, прочитанных из файла. 
+```python
+>>>fp = open('zapis3.txt')
+>>>stroka1 = fp.read(12) # Чтение первых 12 символов(байт), курсор остановится на 13-ом (/n)
+>>>stroka2 = fp.read() # Чтение всех оставшихся символов вплоть до EOF
+>>>fp.close()
+>>>print(stroka1)
+[1, 2, 3, 4]
+>>>print(stroka2)
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+### 4.8.  Чтение информации с помощью методов readline и readlines.
+Эти методы позволяют прочитать из файла, начиная с текущего положения маркера, соответственно, одну строку символов (совокупность байт)  или все строки (все байты). 
+```python
+>>>file = open("zapis5.txt")
+>>>file.readline()
+'Иванов И. 1\n'
+>>>file.seek(0)# Вовзращение указателя обратно в начало, чтобы нагляднее выполнить
+                    readlines
+
+0
+>>>file.readlines()
+['Иванов И. 1\n', 'Петров П. 2\n', 'Сидоров С. 3\n']
+```
+
+
+### 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
+```python
+>>>import pickle
+>>>mnoz1={'pen','book','pen','iPhone','table','book'} #Объект типа «множество»
+>>>fp=open('zapis6.mnz','wb') # Бинарный файл – на запись
+>>>pickle.dump(mnoz1,fp) #dump – метод записи объекта в файл
+>>>fp.close()
+```
+
+Запись, произведенная в файл:
+耄锣   鐨谅瑡扬斔谄扯潫钌٩偨潮斔调灥溔逮 (Эти символы - это результат попытки прочитать бинарные данные как текст)
+
+Теперь прочитаем данные из файла в объект mnoz2:
+```python
+>>>fp=open('zapis6.mnz','rb')
+>>>mnoz2=pickle.load(fp) #load – метод чтения объекта из бинарного файла
+>>>fp.close()
+>>>print(mnoz2)
+{'table', 'book', 'iPhone', 'pen'}
+>>>print(mnoz1)
+{'table', 'book', 'iPhone', 'pen'}
+>>>mnoz1 == mnoz2
+True
+```
+
+mnoz1 не совпадает с тем, что было задано, так как множество исключает повторяющиеся элементы, оставляя только один.
+
+С использованием тех же функций запишем в файл, а затем прочитаем два объекта разных типов: то же множество mnoz1 и ранее созданный список sps3. При считывании объекты извлекаются из файла в той же последовательности, в которой они в него записывались.
+```python
+>>>fp=open('zapis7.2ob','wb')
+>>>pickle.dump(mnoz1,fp)
+>>>pickle.dump(sps3,fp)
+>>>fp.close()
+>>>fp=open('zapis7.2ob','rb')
+>>>obj1=pickle.load(fp)
+>>>obj2=pickle.load(fp)
+>>>fp.close()
+>>>print(obj1)
+{'table', 'book', 'iPhone', 'pen'}
+>>>print(obj2)
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>>mnoz1 == obj1
+True
+>>>sps3 == obj2
+True
+```
+
+## 5. Перенаправление потоков ввода и вывода данных.
+```python
+>>>import sys
+>>>vr_out = sys.stdout #Запоминаем текущий поток вывода
+>>>fc = open('Stroka.txt', 'w') #Откроем файл вывода
+>>>sys.stdout = fc #Перенацеливаем стандартный поток вывода на файл
+>>>print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>>sys.stdout=vr_out #Восстановление текущего потока
+>>>print('запись строки на экран')  #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+>>>fc.close
+<built-in method close of _io.TextIOWrapper object at 0x00000232E4FDA330>
+```
+В файле Stroka.txt находится: запись строки в файл
+
+Точно также можно перенаправить поток ввода – sys.stdin – вместо клавиатуры – из файла.
+```python
+>>> tmp_in = sys.stdin
+>>> fd = open("Stroka.txt", "r")
+>>> sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+>>> sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>	
+>>> while True:
+	try:                
+	   line = input() #Считываем из файла строку
+	   print(line) # Отображаем считанное
+	except EOFError:
+		break
+запись строки в файл
+>>> fd.close()
+>>> sys.stdin = tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+```
+
+## 6. Завершение сеанса в среде IDLE

TEMA6/task.md

@@ -0,0 +1,48 @@
+# Общее контрольное задание по теме 6
+
+## Задание:
+- Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+- Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+- Записывается кортеж в бинарный файл.
+- Записывается в этот же файл список и закрывается файл.
+- Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+- Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+- Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Решение:
+```python
+import random
+import pickle
+rn = tuple(str(random.randint(6, 56)) for i in range(125))
+print(rn)
+('22', '53', '30', '47', '19', '13', '50', '11', '45', '30', '9', '20', '41', '38', '8', '34', '51', '33', '29', '23', '19', '19', '31', '10', '32', '48', '31', '51', '46', '8', '42', '11', '19', '12', '45', '38', '40', '41', '6', '16', '11', '53', '15', '35', '45', '39', '11', '51', '55', '44', '54', '16', '10', '11', '32', '18', '17', '54', '48', '37', '13', '19', '34', '18', '28', '17', '36', '24', '34', '51', '15', '23', '8', '15', '33', '25', '12', '56', '24', '28', '37', '11', '31', '10', '54', '50', '31', '26', '29', '55', '11', '30', '19', '16', '6', '27', '54', '16', '52', '47', '20', '49', '46', '44', '54', '13', '11', '52', '49', '26', '9', '25', '38', '28', '46', '9', '56', '9', '52', '52', '38', '30', '15', '22', '26')
+spis = ["Bushmanov", "Podolskii", "Terehov", "Kovalenko", "Zhalnin"]
+fp = open('data.bin', 'wb')
+pickle.dump(rn, fp)
+pickle.dump(spis, fp)
+fp.close()
+fp = open('data.bin', 'rb')
+rn1 = pickle.load(fp)
+print(rn1)
+('22', '53', '30', '47', '19', '13', '50', '11', '45', '30', '9', '20', '41', '38', '8', '34', '51', '33', '29', '23', '19', '19', '31', '10', '32', '48', '31', '51', '46', '8', '42', '11', '19', '12', '45', '38', '40', '41', '6', '16', '11', '53', '15', '35', '45', '39', '11', '51', '55', '44', '54', '16', '10', '11', '32', '18', '17', '54', '48', '37', '13', '19', '34', '18', '28', '17', '36', '24', '34', '51', '15', '23', '8', '15', '33', '25', '12', '56', '24', '28', '37', '11', '31', '10', '54', '50', '31', '26', '29', '55', '11', '30', '19', '16', '6', '27', '54', '16', '52', '47', '20', '49', '46', '44', '54', '13', '11', '52', '49', '26', '9', '25', '38', '28', '46', '9', '56', '9', '52', '52', '38', '30', '15', '22', '26')
+spis1 = pickle.load(fp)
+print(spis)
+['Bushmanov', 'Podolskii', 'Terehov', 'Kovalenko', 'Zhalnin']
+if rn == rn1:
+    print("Переменные rn и rn1 совпадают")
+else:
+    print("Переменные не совпадают")
+Переменные rn и rn1 совпадаютif spis == spis1:
+    print("Переменные spis и spis1 совпадают")
+else:
+    print("Переменные не совпадают")   
+Переменные spis и spis1 совпадают
+for i in range(125 // 5):
+    exec('list' + str(i) + '=' + str(list(rn1[i:i+5])))
+print(list1)
+['53', '30', '47', '19', '13']
+print(list2)
+['30', '47', '19', '13', '50']
+print(list5)
+['13', '50', '11', '45', '30']
+```

TEMA6/test.md

@@ -0,0 +1,65 @@
+# Индивидуальное контрольное задание
+
+Бушманов Артём, А-01-23
+
+## Задание:
+1) Создайте список с 5 фамилиями сотрудников некоторой фирмы (фамилии придумайте сами). Создайте кортеж с 5 числовыми элементами - окладами сотрудников из списка.
+2) Запросите у пользователя и введите символьную строку с названием фирмы (латиницей). Удалите из названия пробелы.
+3) Создайте словарь с именем - названием фирмы, ключами - фамилиями сотрудников из списка и значениями - их окладами из кортежа. Отобразите словарь.
+4) Рассчитайте среднее значение оклада сотрудников фирмы и отобразите с заголовком.
+5) Запишите список, кортеж и словарь в бинарный файл с именем - названием фирмы и расширением '.bin'.
+## Решение:
+```python
+import pickle  
+familii = ['Ivanov', 'Petrov', 'Sidorov', 'Smirnov', 'Kuznetsov']  
+okladi = (40000, 45000, 42000, 48000, 50000)  
+namefirmi= input("Введите название фирмы латиницей: ")  
+namefirmi = namefirmi.replace(' ', '')  
+print("Название фирмы (без пробелов):", namefirmi)  
+  
+exec(namefirmi + " = {}")  
+  
+i = 0  
+while i < len(familii):  
+    fam = familii[i]  
+    pay = okladi[i]  
+    exec(namefirmi + "['" + fam + "'] = " + str(pay))  
+    i = i + 1  
+  
+print("Словарь с данными по сотрудникам:")  
+firm_dict = eval(namefirmi)  
+print(firm_dict)  
+  
+  
+summa = 0  
+j = 0  
+while j < len(okladi):  
+    summa = summa + okladi[j]  
+    j = j + 1  
+  
+itog = summa / len(okladi)  
+print("Средний оклад сотрудников фирмы:", itog)  
+  
+  
+file_name = namefirmi + '.bin'  
+fp = open(namefirmi, 'wb')  
+pickle.dump(familii, fp)  
+pickle.dump(okladi, fp)  
+pickle.dump(eval(namefirmi), fp)  
+fp.close()  
+  
+print("Данные записаны в файл:", file_name)
+```
+
+## *Проверка:*
+```python
+Введите название фирмы латиницей: FDSFSDv
+Название фирмы (без пробелов): FDSFSDv
+Словарь с данными по сотрудникам:
+{'Ivanov': 40000, 'Petrov': 45000, 'Sidorov': 42000, 'Smirnov': 48000, 'Kuznetsov': 50000}
+Средний оклад сотрудников фирмы: 45000.0
+Данные записаны в файл: FDSFSDv.bin
+
+
+``` 
+

TEMA7/report.md

@@ -0,0 +1,525 @@
+# Отчет по теме 7
+Бушманов Артём, А-01-23
+
+## 1. Запуск интерактивной оболочки IDLE. Создание рабочего каталога.
+```
+>>>import os
+>>>os.chdir('/Users/ArtyomBushmanov/python-labs/TEMA7')
+```
+
+## 2. Создание пользовательской функции.
+В общем виде функция в языке Python представляется так:
+def  <Имя функции>([<Список аргументов >]):
+[<отступы>"""<Комментарий по назначению функции>"""]
+<отступы><Блок инструкций – тело функции>
+[<отступы>return <Значение или вычисляемое выражение>]
+
+Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то выполнение функции прекращается с возвратом значения, следующего за этой инструкцией. Однако наличие этой инструкции в функции является необязательным.
+
+### 2.1. Функция – без аргументов.
+```python
+>>>def uspeh():
+    """Подтверждение успеха операции"""
+    
+    print('Выполнено успешно!')
+
+>>>uspeh()
+Выполнено успешно!
+>>>type(uspeh)
+<class 'function'>
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+>>>help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+Видно, что help вернуло имя функции и то описание, которое было указано в тройных кавычках при её определении. Это называется docstring или документ-строка. Они используются для написания документации. Она должна быть первой строкой внутри блока.
+
+### 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
+```
+Выполнение функции с аргументами - символьными строками:
+```python
+>>>sravnenie("big", "small")
+big  меньше  small
+```
+Из-за не конкретизированной функции, мы можем задать любые данные, которые можно сравнить. Если что-то нельзя сравнить,
+вернется TypeError.
+
+### 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)
+>>>print(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)  #Сложение списков
+>>>print(q)
+[1, 2, -1, -2, 0, 2, -1, -1]
+>>>slozh((1, 2), (5, 0), (-1, -3), (-6, 2)) # Сложение кортежей
+(1, 2, 5, 0, -1, -3, -6, 2)
+>>>slovar1 = {'a' : 1}; slovar2 = {'b' : 2}; slovar3 = {'c' : 3}; slovar4 = {'d' : 4}
+>>>slozh(slovar1, slovar2, slovar3, slovar4) # Сложение словарей
+Traceback (most recent call last):
+  File "<pyshell#44>", line 1, in <module>
+    slozh(slovar1, slovar2, slovar3, slovar4)
+  File "<pyshell#35>", line 3, in slozh
+    return a1 + a2 + a3 + a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+>>>slozh({1,1,1,1}, {2}, {"abc", True, None}, {6, 6, "a"}) # Сложения множеств
+Traceback (most recent call last):
+  File "<pyshell#45>", line 1, in <module>
+    slozh({1,1,1,1}, {2}, {"abc", True, None}, {6, 6, "a"})
+  File "<pyshell#35>", line 3, in slozh
+    return a1 + a2 + a3 + a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+Функция slozh(a1, a2, a3, a4) складывает аргументы с помощью оператора +.
+Для кортежей оператор + определён, поэтому функция будет работать — кортежи просто склеиваются в один. Для словарей и множеств оператор + не определён, поэтому при попытке вызвать функцию с такими аргументами возникает ошибка TypeError. Следовательно, данная реализация функции применима для кортежей (как и для чисел, строк и списков), но не может напрямую использоваться для словарей и множеств.
+
+### 2.5. Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
+
+```python
+>>>def inerz(x,T,ypred):
+    """ Модель устройства с памятью:
+x- текущее значение вх.сигнала,
+T -постоянная времени,
+ypred - предыдущее значение выхода устройства"""
+    y = (x + T * ypred) / (T + 1)
+    return y
+
+>>>sps = [0] + [1] * 100
+>>>spsy = [] #Заготовили список для значений выхода
+>>>TT = 20 #Постоянная времени
+>>>yy = 0  #Нулевое начальное условие
+for xx in sps:
+	yy =inerz(xx, TT, yy)
+	spsy.append(yy)
+>>>import pylab as plt
+>>>plt.plot(spsy, label = "Выходной сигнал")
+[<matplotlib.lines.Line2D object at 0x0000025286FC2E30>]
+>>>plt.show()
+```
+![График](figure_0.png)
+
+
+## Пункт 3. Функции как объекты.
+
+### Пункт 3.1. Получение списка атрибутов объекта-функции.
+```python
+>>>dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
+>>>inerz.__doc__
+' Модель устройства с памятью:\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
+```
+В данном случае происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в
+переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую функцию, что и sravnenie.
+
+### 3.3. Возможность альтернативного определения функции в программе.
+```python
+>>>typ_fun = 8
+>>>if typ_fun == 1:
+    def func():
+        print('Функция 1')
+else:
+    def func():
+        print('Функция 2')
+        
+>>>func()
+Функция 2
+```
+
+Программа выводит сообщение "Функция 2", потому что переменная typ_fun не равна 1, и
+выполняется блок else, в котором функция func определена как выводящая. Функция становится доступной только после того, как интерпретатор достигает
+строки с её определением.
+
+## 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)
+>>>print(zz)
+-2.3318122278318336
+```
+Python передаёт ссылку на объект функции logistfun в переменную fff. Внутри
+функции выполняется операция: a + fff(c, b), что эквивалентно -3 + logistfun(0.7, 1)
+
+### 4.2. Обязательные и необязательные аргументы.
+```python
+>>>def logistfun(a,b=1):   #Аргумент b – необязательный; значение по умолчанию=1
+    """Вычисление логистической функции"""
+    import math
+    return b / (1 + math.exp(-a))
+
+>>>logistfun(0.7)     #Вычисление со значением b по умолчанию
+0.6681877721681662
+>>>logistfun(0.7,2)  #Вычисление с заданным значением b
+1.3363755443363323
+```
+### 4.3. Изучим возможность обращения к функции с произвольным (непозиционным) расположением аргументов. При этом надо в обращении к функции указывать имена аргументов:
+```python
+>>>logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+0.34498724056380625
+```
+
+### 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже.
+```python
+>>>b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+>>>qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+>>>print(qq)
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+Создается список b1234, содержащий 4 элемента: b1, b2, b3, b4. Затем Оператор * выполняет распаковку списка b1234. Вместо передачи одного аргумента (списка), передаются 4 отдельных аргумента.
+
+### 4.5. Пример со значениями аргументов функции, содержащимися в словаре.
+```python
+>>>dic4 = {"a1":1,"a2":2,"a3":3,"a4":4}
+>>>qqq = slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+>>>print(qqq)
+10
+```
+
+### 4.6. Смешанные ссылки.
+```python
+>>>e1=(-1,6);dd2={'a3':3,'a4':9}
+>>>qqqq=slozh(*e1,**dd2)
+>>>print(qqqq)
+17
+```
+
+### 4.7. Переменное число аргументов у функции.
+```python
+>>>def func4(*kort7):
+    """Произвольное число аргументов в составе кортежа"""
+    smm = 0
+    for elt in kort7:
+        smm += elt
+    return smm
+
+>>>func4(-1,2)  #Обращение к функции с 2 аргументами
+1
+>>>func4(-1,2,0,3,6)  #Обращение к функции с 5 аргументами
+10
+```
+
+### 4.8. Комбинация аргументов
+```python
+>>>def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+    """Кортеж - сборка аргументов - должен быть последним!"""
+    smm = 0
+    for elt in kort7:
+        smm += elt
+    return a * smm + b
+
+>>>func4(-1, 2, 0, 3, 6)
+-7
+```
+
+Подобным же образом в списке аргументов функции также можно использовать словарь, предварив его имя двумя звездочками:
+```python
+>>>def func5(a,b=7,**slovar7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+    """Словарь - сборка именованных аргументов!"""
+    smm = 0
+    for key, value in slovar7.items():
+        smm += value
+    return a * smm + b
+
+>>>func5(-1, 2, x=0, y=3, z=6)
+-7
+```
+
+### 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
+Такое изменение возможно только у объектов изменяемого типа.
+```python
+>>>a=90    # Числовой объект – не изменяемый тип
+>>>def func3(b):
+    b = 5*b + 67
+    print(b)
+    
+>>>func3(a)
+517
+>>>print(a)
+90
+```
+Значени a не изменилось
+
+- Пример со списком:
+```python
+>>>sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+>>>def func2(sps):
+    sps[1] = 99
+
+>>>func2(sps1)
+>>>print(sps1)
+[1, 99, 3, 4]
+```
+В отличие от предыдущего примера с переменной численного типа, список передается по ссылке, а не по значению, поэтому изменяется именно тот объект, который был передан.
+
+- Пример с кортежем:
+```python
+>>>kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+>>>func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#170>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#166>", line 2, in func2
+    sps[1] = 99
+TypeError: 'tuple' object does not support item assignment
+```
+Кортеж - неизменяемая коллекция, поэтому значение заменить не получилось.
+
+## 5. Специальные типы  пользовательских функций.
+
+### 5.1. Анонимные функции.
+Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени (поэтому их и называют анонимными), определяемые по следующей схеме:
+lambda [<Аргумент1>[,<Аргумент2>,…]]:<Возвращаемое значение или выражение>
+Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
+
+```python
+>>>import math
+>>>anfun1=lambda: 1.5+math.log10(17.23)  #Анонимная функция без аргументов
+>>>anfun1()   # Обращение к объекту-функции
+2.7362852774480286
+>>>anfun2=lambda a,b : a+math.log10(b)  #Анонимная функция с 2 аргументами
+>>>anfun2(17,234)
+19.369215857410143
+>>>anfun3 = lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
+>>>anfun3(100)
+102.36921585741014
+```
+
+### 5.2. Функции-генераторы.
+Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. Для этого в функцию включают инструкцию yield приостанавливающую её выполнение и возвращающую очередное значение.
+
+```python
+>>>def func5(diap,shag):
+    """ Итератор, возвращающий значения
+из диапазона от 1 до diap с шагом shag"""
+    for j in range(1,diap+1,shag):
+        yield j
+
+        
+>>>for mm in func5(7,3):
+    print(mm)   
+1
+4
+7
+```
+
+Здесь при каждом обращении к функции будет генерироваться только одно очередное значение.
+При программировании задач у таких функций часто используют метод __next__, активирующий очередную итерацию выполнения функции.
+```python
+>>>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#196>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+В конце вывело ошибку, т.к. все возможные значения уже были выведены на экран (диапазон закончился).
+
+## 6. Локализация объектов в функциях.
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции. Они определены в пространствах имен вне функции.
+Локализация может быть переопределена путем прямого объявления объектов как глобальных с помощью дескриптора global.
+
+- Одноименные локальный и глобальный объекты:
+```python
+>>>def func8(arg):
+    locl = 15
+    print(glb)
+    glb = 8
+    return locl*arg
+
+>>>res = func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#209>", line 1, in <module>
+    res = func8(glb)
+  File "<pyshell#208>", line 3, in func8
+    print(glb)
+UnboundLocalError: local variable 'glb' referenced before assignment
+```
+Мы получили ошибку потому, что на локальную переменную glb код ссылается перед назначением. 
+Если переменной присваивается значение внутри функции, она считается локальной для всей функции. Даже если такое же имя есть в глобальной области, внутри функции будет создана новая локальная переменная.
+
+
+- Переопределение локализации объекта:
+```python
+>>>glb = 11
+>>>def func7(arg):
+    locl = 15
+    global glb
+    print(glb)
+    glb = 8
+    return locl * arg
+
+>>>res = func7(glb)
+11
+>>>print(res)
+165
+>>>print(glb)
+8
+```
+Здесь мы явно указали, что в функции имеем в виду глобальную переменную, так что она изменилась.
+
+### 6.2. Выявление локализации объекта с помощью функций locals() и globals() из builtins.
+
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
+
+```python
+>>>def func8(arg):
+    loc1 = 15
+    glb = 8
+    print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+    print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+    return loc1*arg
+
+>>>hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'slovar1', 'slovar2', 'slovar3', 'slovar4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'func8', 'res'])
+dict_keys(['arg', 'loc1', 'glb'])
+```
+Как мы видим, перечень глобальных объектов остался без изменений, а перечень локальных объектов вывел только локальные объекты функции.
+
+Проверка наличие объекта glb в перечне глобальных объектов:
+```python
+>>>'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__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'slovar1', 'slovar2', 'slovar3', 'slovar4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'func8', 'res', 'hh', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])# Содержит только объекты, определенные внутри func9_1, а также объект, переданный как аргумент функции
+
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])# Содержит все то же, что и locl_func9_1, но еще и arg3, переданный func9 и саму func9_1
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'slovar1', 'slovar2', 'slovar3', 'slovar4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'func8', 'res', 'hh', 'func9']) # Тоже самое, что и glob_func9_1
+```
+
+### 6.4. Большой пример – моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа «зона нечувствительности», при подаче на неё синусоидального входного сигнала.
+
+```python
+>>>znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=6, 5, 8, 10, 3, 0.5, 1500
+>>>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))
+ 
+>>>print(vhod)
+[0.0, -1.4695761589768238e-15, -2.9391523179536475e-15, …, 2.9174217636433927e-12, -4.033155768249364e-12, -6.979687886698152e-14, -7.0203744107597384e-12]
+
+
+>>>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 -gran <= xtt <= gran:
+        ytt = 0
+    elif xtt > gran:
+        ytt = xtt - gran
+    else:  # 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)
+y= [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27.421883254961507, -159.8455361225524, 760.8726454041447, -3488.73566888214, 15869.602621377877, -72062.25788892987, 327102.1123783949, -1484643.5574000787, 6738340.865317245,..., nan, nan, nan, nan, nan]
+```
+## 7. Завершение сеанса в среде IDLE

TEMA7/task.md

@@ -0,0 +1,65 @@
+# Общее контрольное задание по теме 7
+
+## Задание:
+- Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+- Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+- Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+
+## Решение:
+```python
+# 1
+>>>def delay_signal(signal, T):
+    for i in range(len(signal)):
+        signal[i] += T
+    return signal
+
+>>>vhod_signal = [1, 2, 3.69, 4, 5.32, 6.5, 7, 8]
+>>>T_zad = 3
+>>>vyhod_signal = delay_signal(vhod_signal, T_zad)
+>>>print(vyhod_signal)
+[4, 5, 6.6899999999999995, 7, 8.32, 9.5, 10, 11]
+
+# 2
+import random
+import matplotlib.pyplot as plt
+def histogram(data, num):
+    min_val, max_val = min(data), max(data)
+    parts = np.linspace(min_val, max_val, num + 1)
+    rows = [0] * num
+    for now in data:
+        for i in range(num):
+            if parts[i] <= now < parts[i + 1]:
+                rows[i] += 1
+                break
+    if now == max_val:
+        rows[-1] += 1
+    plt.hist(data, bins=parts)
+    plt.xlabel('Значения выборки')
+    plt.ylabel('Число элементов')
+    plt.title('Гистограмма выборки')
+    plt.show()
+    return rows
+
+sl_vel = [random.gauss(random.random(), random.random()) for _ in range(random.randint(1,50))]
+intervals = 5
+output = histogram(sl_vel, intervals)
+print(output)
+[4, 5, 18, 17, 5]
+
+# 3
+>>>predict = lambda b1, b2, X: b1 + b2 * X
+>>>b1  =  0.5
+>>>b2 = 0.8
+>>>X = 5
+>>>print(predict(b1, b2, X))
+4.5
+```
+
+![График](figure_1.png)
+
+- Гистограммы для значений из методических указаний:
+
+![График](figure_2.png)
+![График](figure_3.png)

TEMA7/test.md

@@ -0,0 +1,125 @@
+# ИКЗ, тема 7 (вариант 8)
+ 
+Бушманов Артём, А-01-23
+# Задание:
+8. Разработайте анонимную функцию, вычисляющую значение a*sin(x)/x, где a,x – аргументы функции. Рассчитайте эту функцию в интервале значений х:  0<x≤50 с шагом 0.5 и при некотором значении коэффициента a. Обеспечьте запись рассчитанных значений в текстовый файл по одному значению на строке. Отобразите рассчитанные значения в виде графика.
+# Решение:
+```python
+import math  
+from pylab import plot, show, grid  
+a = float(input('a='))  
+f = lambda a, x: a*math.sin(x)/x  
+x_list = [i*0.5 for i in range(1, 101)]  
+y_list = [f(a, x) for x in x_list]  
+with open('lambda_sin.txt', 'w', encoding='utf-8') as fl:  
+    for y in y_list:  
+        fl.write(str(y) + '\n')  
+plot(x_list, y_list)  
+grid(True)  
+show()
+```
+# Вывод:
+# Txt файл со значениями:
+46.983702783211896  
+41.23207825558693  
+32.58483622906578  
+22.277786957229203  
+11.730054024437546  
+2.304960131644498  
+-4.910965187654678  
+-9.270830567522122  
+-10.644216836797723  
+-9.397457891698757  
+-6.28572290053622  
+-2.281893235291228  
+1.6216737563543016  
+4.598906191031523  
+6.128266514928295  
+6.059819260568213  
+4.60304335512365  
+2.2437561974273414  
+-0.38762156869775327  
+-2.665703443357912  
+-4.105246879867794  
+-4.454501829180407  
+-3.730187526933304  
+-2.1910060818351096  
+-0.2599818376167067  
+1.5837065234234928  
+2.9174397704466237  
+3.4671257449320465  
+3.159300532462722  
+2.1242736111799148  
+0.6527036525775505  
+-0.8817039072867625  
+-2.1137867743083048  
+-2.7710868883587225  
+-2.7317528153108412  
+-2.0443541717673406  
+-0.9071108272978926  
+0.3865254354465613  
+1.5216130059620743  
+2.236715864282688  
+2.382666337544447  
+1.952196489917464  
+1.0748981930984005  
+-0.01971427978317227  
+-1.0609578271362208  
+-1.8028173828079723  
+-2.081107207276188  
+-1.8488891557635236  
+-1.1827150597302487  
+-0.25940943019163515  
+0.6899552685131862  
+1.437129387442328  
+1.8108877174374316  
+1.7356452034007648  
+1.245918601858174  
+0.47408512953877086  
+-0.3847026796194044  
+-1.121312425049497  
+-1.563069118942533  
+-1.613784986018341  
+-1.274204417488753  
+-0.6386401490590383  
+0.13062693107605064  
+0.8443721056513387  
+1.3326046385767907  
+1.4847176104623059  
+1.2742047763668551  
+0.7625015182317991  
+0.08164888194612474  
+-0.5994557372946114  
+-1.1166737899826316  
+-1.3499212171864632  
+-1.2507980138323445  
+-0.8522532036349453  
+-0.25845709819164403  
+0.3821594830726284  
+0.9137858453457289  
+1.2109224084082129  
+1.207813350102631  
+0.9127636215872024  
+0.4042816707548792  
+-0.18957343344953026  
+-0.7232637950794704  
+-1.069275139234906  
+-1.148429144773179  
+-0.9478363346232865  
+-0.5224588570852309  
+0.01971350750375603  
+0.5449299002264893  
+0.9265393933815956  
+1.0754055549049835  
+0.9606006311911229  
+0.6156050029301289  
+0.1288315535003399  
+-0.3789044654226395  
+-0.7842599667679099  
+-0.991222958588696  
+-0.953752652759472  
+-0.6858861163121431  
+-0.2571273566298502
+
+### График:
+![[figure_4.png]]

TEMA8/MM0.py

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

TEMA8/MM1.py

@@ -0,0 +1,19 @@
+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

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/Mod0.py

@@ -1,5 +1,6 @@
 #Модуль Mod0
 import Mod1
+Mod1.perm1 = str(int(Mod1.perm1)*3)
 print('perm1=',Mod1.perm1)
 from Mod2 import alpha as al
 tt=al()

TEMA8/data1.txt

@@ -0,0 +1,4 @@
+2 7 1
+8 2
+8 1 8
+2 8

TEMA8/data2.txt

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

TEMA8/modtask0.py

@@ -0,0 +1,9 @@
+import modtask1
+mu = float(input("Введите мат. ожидание (mu): "))
+var = float(input("Введите дисперсию (var): "))
+n = int(input("Введите число отсчетов (n): "))
+filename = input("Введите имя файла: ").strip()
+s = modtask1.shum(mu, var, n, filename)
+print("Готово! Список получен и записан в файл.")
+print("Длина списка:", len(s))
+print("Первые 10 значений:", s[:10])

TEMA8/modtask1.py

@@ -0,0 +1,17 @@
+import random
+import math
+
+def shum(mu, var, n, filename):
+    sigma = math.sqrt(var)
+    data = []
+    f = open(filename, "w", encoding="utf-8")
+    for i in range(n):
+        x = random.gauss(mu, sigma)
+        data.append(x)
+        if (i + 1) % 3 == 0:
+            f.write(f"{data[i-2]} {data[i-1]} {data[i]}\n")
+        elif i == n - 1:
+            start = i - (i % 3)
+            f.write(" ".join(str(v) for v in data[start:]) + "\n")
+    f.close()
+    return data

TEMA8/module1.py

@@ -0,0 +1,13 @@
+# module1.py
+# Модуль 1: чтение числового списка из текстового файла
+def read_file(filename):
+    numbers = []
+    f = open(filename, "r", encoding="utf-8")
+
+    for line in f:
+        parts = line.split()          # разбиваем строку по пробелам
+        for p in parts:
+            numbers.append(float(p))  # добавляем число в список
+
+    f.close()
+    return numbers

TEMA8/module2.py

@@ -0,0 +1,24 @@
+# Модуль 2: коэффициент корреляции Пирсона
+import math
+
+def correlation(l1, l2):
+    n = min(len(l1), len(l2))
+    x = l1[:n]
+    y = l2[:n]
+
+    sx = sum(x)
+    sy = sum(y)
+
+    sxx = 0
+    syy = 0
+    sxy = 0
+
+    for i in range(n):
+        sxx += x[i] * x[i]
+        syy += y[i] * y[i]
+        sxy += x[i] * y[i]
+
+    num = n * sxy - sx * sy
+    den = math.sqrt((n * sxx - sx * sx) * (n * syy - sy * sy))
+
+    return num / den

TEMA8/module3.py

@@ -0,0 +1,13 @@
+# Модуль 3: ввод имён файлов, чтение списков и вывод корреляции
+import module1
+import module2
+
+file1 = input("Введите имя первого файла: ")
+file2 = input("Введите имя второго файла: ")
+
+a = module1.read_file(file1)
+b = module1.read_file(file2)
+
+r = module2.correlation(a, b)
+
+print(f"Coef cor: {r:.3f}")

TEMA8/report.md

@@ -0,0 +1,374 @@
+# Отчет по теме 8
+Бушманов Артём, А-01-23
+
+## 1. Запуск интерактивной оболочки IDLE. Импорт библиотек.
+
+```python
+>>> import os
+>>> os.getcwd()
+'/Users/ArtyomBushmanov'
+>>> import os,sys,importlib
+>>> os.chdir('/Users/ArtyomBushmanov/python-labs/TEMA8')
+>>> os.getcwd()
+    '/Users/ArtyomBushmanov/python-labs/TEMA8'
+```
+
+## 2. Создание и использование модулей в среде Python.
+
+### 2.1. Запуск модуля на выполнение путем его импорта.
+
+```python
+>>>perm1=input('Mod1:Введите значение = ')
+>>>print('Mod1:Значение perm1=',perm1)
+>>>import Mod1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>>Mod1.perm1
+'5'
+```
+Все следующие после первого вызовы не инициируют ввод значения
+perm1. В Python модули импортируются один раз в рамках одного запуска интерпретатора.
+Если попытаться импортировать модуль повторно, используется уже загруженная версия из кэша.
+Если нужно повторно импортировать модуль как в первый раз, можно сделать так:
+```python
+>>>importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod1.py'>
+>>>Mod1.perm1
+'3'
+```
+
+### 2.2. Импортированные модули заносятся в словарь – значение атрибута sys.modules. 
+```python
+>>>print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_osx_support', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfigdata__darwin_darwin', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', 'abc', 'array', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', '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', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posix', '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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>>sys.modules.pop('Mod1')
+<module 'Mod1' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod1.py'>
+>>>print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_osx_support', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfigdata__darwin_darwin', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', 'abc', 'array', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', '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', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posix', '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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>>import Mod1
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod1.py'>
+>>> per
+['__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_distutils_hack', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_locale', '_lzma', '_opcode', '_operator', '_pickle', '_queue', '_random', '_sha512', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_thread', '_tkinter', '_warnings', '_weakref', '_weakrefset', '_winapi', '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', 'imp', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'msvcrt', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'signal', 'site', 'socket', 'socketserver', 'sre_compile', 'sre_constants', 'sre_parse', 'stat', 'string', 'struct', 'subprocess', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+importlib.reload() обновляет модуль, выполняя его код заново на том же месте в памяти, что сохраняет существующие ссылки на него. sys.modules.pop() полностью удаляет модуль из кэша, и при следующем импорте будет создан новый объект в памяти, разрывая связь со старыми зависимостями.
+
+
+ ### 2.3. Запуск модуля на выполнение с помощью функции exec().
+```python
+>>>exec(open('Mod1.py').read())
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+>>>perm1
+'1'
+>>>exec(open('Mod1.py').read())
+Mod1:Введите значение = 123
+Mod1:Значение perm1= 123
+>>>perm1
+'123'
+>>>exec(open('Mod1.py').read())
+Mod1:Введите значение = 567
+Mod1:Значение perm1= 567
+>>>perm1
+'567'
+```
+При использовании import Python по умолчанию считает, что файл имеет кодировку UTF-8, а также учитывает псевдокомментарии. При использовании open() Python считает, что у файла «системная» кодировка, которая в Linux обычно UTF-8, а в Windows — UTF-16. Поэтому, если файл в UTF-8, то нужно передать open() дополнительный аргумент для указания кодировки, иначе код модуля будет выполнен, но вместо кириллицы будут кракозябры.
+
+
+### 2.4. Использование инструкции from … import …
+- Пример 1:
+```python
+>>>sys.modules.pop('Mod1')
+<module 'Mod1' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod1.py'>
+>>>print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_osx_support', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfigdata__darwin_darwin', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', 'abc', 'array', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', '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', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posix', '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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> from Mod1 import perm1
+Mod1:Введите значение = 52
+Mod1:Значение perm1= 52
+>>> print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_osx_support', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfigdata__darwin_darwin', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', 'abc', 'array', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', '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', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posix', '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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>>perm1
+'52'
+```
+Как видно, объект Mod1 всё же появился в sys.modules.keys(). Аналогично обычному import, при первом импорте команда инициализирует ввод, но при последующих снова ничего записать не удается.
+
+- Пример 2:
+```python
+>>>from Mod2 import beta
+>>>g = beta(2)
+>>>print(g)
+535.4916555247646
+>>>print(sorted(sys.modules.keys()))
+['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_osx_support', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfigdata__darwin_darwin', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', 'abc', 'array', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', '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', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posix', '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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+
+Объект mod2 появился в списке всех модулей.
+
+```python
+>>>alpha()
+Traceback (most recent call last):
+  File "<pyshell#52>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+>>>from Mod2 import alpha as al # Эта функция была не просто импортирована из модуля, но ей еще был присвоен псевдоним al, поэтому обращаться к ней надо так:
+>>>al()
+****ALPHA****
+Значение t=42
+'42'
+>>>del al, beta
+>>>from Mod2 import alpha as al, beta as bt
+>>>['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_osx_support', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfigdata__darwin_darwin', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', 'abc', 'array', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', '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', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posix', '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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>>sys.modules.pop('Mod2')
+<module 'Mod2' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod2.py'>
+>>>sys.modules.pop('Mod1')
+<module 'Mod1' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod1.py'>
+>>>from Mod2 import *
+>>>print(sorted(sys.modules.keys()))
+['Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_osx_support', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfigdata__darwin_darwin', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', 'abc', 'array', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', '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', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posix', '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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>>tt = alpha()
+****ALPHA****
+Значение t=0.12
+>>>uu = beta(float(tt))
+>>>print(uu)
+1.4578913609506803
+```
+
+## 3. Создание многомодульных программ.
+### 3.1. Пример простой многомодульной программы
+Файл Mod0:
+```python
+#Модуль Mod0
+>>>import Mod1
+>>>print('perm1=',Mod1.perm1)
+>>>from Mod2 import alpha as al
+>>>tt=al()
+>>>print('tt=',tt)
+>>>from Mod2 import beta
+>>>qq=beta(float(tt))
+>>>print('qq=',qq)
+```
+Этот модуль содержит программу, вызывающую на выполнение ранее созданные модули Mod1, Mod2. Теперь наша программа будет состоять из 5 частей: главная программа, которой является командная строка IDLE и из которой будет вызываться модуль Mod0, и 3 модуля, вызываемых из модуля Mod0. 
+
+```python
+>>>sys.modules.pop('Mod2')
+<module 'Mod2' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod2.py'>
+>>>sys.modules.pop('Mod1')
+Traceback (most recent call last):
+  File "<pyshell#70>", line 1, in <module>
+    sys.modules.pop('Mod1')
+KeyError: 'Mod1'
+>>>['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_osx_support', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfigdata__darwin_darwin', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', 'abc', 'array', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', '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', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posix', '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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>>import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+****ALPHA****
+Значение t=3
+tt= 3
+qq= 12391.647807916694
+>>>Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+'3'
+12391.647807916694
+'10'
+```
+Обратим внимание на доступ к значению объекта perm1: здесь пришлось указывать не только имя модуля Mod0, но и вызываемого модуля Mod1, в котором локализован этот объект.
+
+### 3.2. Еще пример.
+- MM1:
+```python
+>>>def realdvig(xtt,kk1,TT,yti1,ytin1):
+    #Модель реального двигателя
+    yp = kk1 * xtt  #усилитель
+    yti1 = yp + yti1  #Интегратор
+    ytin1 = (yti1+TT*ytin1)/(TT+1)
+    return [yti1, ytin1]
+
+>>>def tahogen(xtt,kk2,yti2):
+    #Модель тахогенератора
+    yp = kk2 * xtt   #усилитель
+    yti2 = yp + yti2 #интегратор
+    return yti2
+
+>>>def nechus(xtt,gran):
+    if (xtt < gran) and (xtt > (-gran)):
+        ytt = 0
+    elif xtt >= gran:
+        ytt = xtt - gran
+    elif xtt <= (-gran):
+        ytt = xtt + gran
+    return ytt
+```
+- MM2:
+```python
+>>>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)
+```
+
+Тест модульной программы:
+```python
+>>>import MM0
+k1,T,k2,Xm,A,F,N=10,15,4,12,4,0.25,1200
+y= [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1.0183086292055208, 0, 26.39885775889784, -36.65029553691161, -34.19982663883278, 196.29963397615063, -151.6919482160481, -388.32493988337274, 1057.8073200868555, -308.3186572590445, -2798.051869998873, 5004.749701095182, 1362.331454336744, -17303.76245797908, 20708.797073656922, 23131.712847291765, -96666.92589990808, 68334.1768518288, 197345.02344536444, -493052.7705410587, 105903.31715345399, 1355721.0376349306, -2274997.365100845, -872836.4101142843, 8214772.983431362, -9152152.524615865, -11955927.01886036, 45200002.40717218, -28477641.195253134, -97272710.87371413, 227091911.21265164,...]
+```
+
+### 3.3. Области действия объектов в модулях.
+- Обращение в функции alpha к функции beta:
+```python
+>>>def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    beta(int(t))
+    return t
+
+>>>def beta(q):
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+
+Проведём тест:
+```python
+>>>sys.modules.pop('Mod0')
+<module 'Mod0' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod0.py'>
+>>>sys.modules.pop('Mod1')
+<module 'Mod1' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod1.py'>
+>>>sys.modules.pop('Mod2')
+<module 'Mod2' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod2.py'>
+>>>import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+****ALPHA****
+Значение t=5
+tt= 5
+****BETA****
+qq= 6635623.99934113
+```
+
+- Обращение в функции beta к функции alpha:
+```python
+>>>def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+>>>def beta(q):
+    import math
+    expi = int(alpha())*math.pi
+    return math.exp(expi)
+
+```
+
+Проведём тест:
+```python
+>>>sys.modules.pop('Mod0')
+<module 'Mod0' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod0.py'>
+>>>sys.modules.pop('Mod1')
+<module 'Mod1' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod1.py'>
+>>>sys.modules.pop('Mod2')
+<module 'Mod2' from '/Users/ArtyomBushmanov/python-labs/TEMA8/Mod2.py'>
+>>>import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+****ALPHA****
+Значение t=5
+tt= 5
+****ALPHA****
+Значение t=5
+qq= 6635623.99934113
+```
+Ввод запускается два раза - первый от самой функции alpha, а второй - от той, которая
+упоминалась в beta.
+
+- Отображение на экране в модуле Mod0 значения объектов t и expi:
+```python
+>>>import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+****ALPHA****
+Значение t=5
+tt= 5
+****ALPHA****
+Значение t=5
+qq= 153552935.39544657
+Traceback (most recent call last):
+  File "<pyshell#95>", line 1, in <module>
+    import Mod0
+  File "D:\test\Mod0.py", line 10, in <module>
+    print(t, expi)
+NameError: name 't' is not defined. Did you mean: 'tt'?
+```
+К этим переменным (t из alpha и expi из beta) нельзя обратиться напрямую по их именам извне функций, так как они являются локальными внутри соответствующих модулей.
+
+- В модуле Mod0 увеличим в 3 раза значение объекта perm1 и отобразим его после этого на экране:
+```python
+#Модуль Mod0
+>>>import Mod1
+>>>Mod1.perm1 = str(int(Mod1.perm1)*3)
+>>>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)
+```
+Проведём тест:
+```python
+>>>import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 30
+****ALPHA****
+Значение t=5
+tt= 5
+****BETA****
+qq= 6635623.99934113
+```
+
+- Увеличение в 2 раза значений объектов perm1, tt, qq в командной строке:
+```python
+>>>import Mod0
+Mod1:Введите значение = 9
+Mod1:Значение perm1= 9
+perm1= 27
+****ALPHA****
+Значение t=6
+tt= 6
+****ALPHA****
+Значение t=6
+qq= 153552935.39544657
+>>>Mod0.Mod1.perm1 * 2
+'3030'
+>>>Mod0.tt * 2
+'55'
+>>>Mod0.qq * 2
+13271247.99868226
+```
+perm1 и tt, имеют строковый тип, так что умножение дублирует содержимое строки.

TEMA8/task.md

@@ -0,0 +1,86 @@
+# Общее контрольное задание по теме 8
+## Бушманов А.С. А-01-23
+## Задание:
+Разработайте программу, состоящую из трех модулей:
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки. Подготовьте два текстовых файла с числовыми данными и проверьте по ним работу программы.
+
+
+## Решение:
+```python
+#1 
+def read_file(filename):
+    numbers = []
+    f = open(filename, "r", encoding="utf-8")
+
+    for line in f:
+        parts = line.split()          # разбиваем строку по пробелам
+        for p in parts:
+            numbers.append(float(p))  # добавляем число в список
+
+    f.close()
+    return numbers
+#2
+import math
+
+def correlation(l1, l2):
+    n = min(len(l1), len(l2))
+    x = l1[:n]
+    y = l2[:n]
+
+    sx = sum(x)
+    sy = sum(y)
+
+    sxx = 0
+    syy = 0
+    sxy = 0
+
+    for i in range(n):
+        sxx += x[i] * x[i]
+        syy += y[i] * y[i]
+        sxy += x[i] * y[i]
+
+    num = n * sxy - sx * sy
+    den = math.sqrt((n * sxx - sx * sx) * (n * syy - sy * sy))
+
+    return num / den
+#3
+import module1
+import module2
+
+file1 = input("Введите имя первого файла: ")
+file2 = input("Введите имя второго файла: ")
+
+a = module1.read_file(file1)
+b = module1.read_file(file2)
+
+r = module2.correlation(a, b)
+
+print(f"Coef cor: {r:.3f}")
+```
+## Ответ:
+```python
+import module3.py
+Введите имя первого файла: data1.txt
+Введите имя второго файла: data2.txt
+Coef cor: 0.105
+```
+
+## Файлы:
+data1.txt
+```
+2 7 1
+8 2
+8 1 8
+2 8
+
+```
+data2.txt
+```
+3 1 4 1
+5 9
+2 6 5
+3
+
+```

TEMA8/task1

@@ -0,0 +1,2 @@
+4.903428780465844 0.587814428103369 4.692004162944187
+1.7931553860723835 5.797829782338331 2.3303270038829353

TEMA8/test.md

@@ -0,0 +1,58 @@
+# Индивидуальное контрольное задание  по теме 8
+Бушманов А.С. А-01-23
+## Задание: Вариант 2
+### Из темы 7:
+Разработайте функцию с 4 аргументами, создающую последовательность отсчетов случайного, нормально распределенного сигнала типа белого шума с заданными параметрами: математическое ожидание и дисперсия, число отсчетов (аргументы функции). Сигнал должен быть записан построчно, по 3 элемента в строке с разделителем - пробел в текстовый файл с заданным именем (4-й аргумент функции), а также возвращен в вызывающую программу в виде списка.
+### Из темы 8: 
+По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+## Решение:
+#### Модуль 1: modtask1.py
+```python
+import random
+import math
+
+def shum(mu, var, n, filename):
+    sigma = math.sqrt(var)
+    data = []
+    f = open(filename, "w", encoding="utf-8")
+    for i in range(n):
+        x = random.gauss(mu, sigma)
+        data.append(x)
+        if (i + 1) % 3 == 0:
+            f.write(f"{data[i-2]} {data[i-1]} {data[i]}\n")
+        elif i == n - 1:
+            start = i - (i % 3)
+            f.write(" ".join(str(v) for v in data[start:]) + "\n")
+    f.close()
+    return data
+```
+#### Модуль 2: modtask0.py
+```python
+import modtask1
+mu = float(input("Введите мат. ожидание (mu): "))
+var = float(input("Введите дисперсию (var): "))
+n = int(input("Введите число отсчетов (n): "))
+filename = input("Введите имя файла: ").strip()
+s = modtask1.shum(mu, var, n, filename)
+print("Готово! Список получен и записан в файл.")
+print("Длина списка:", len(s))
+print("Первые 10 значений:", s[:10])
+```
+## Ответ:
+```python
+import modtask0
+Введите мат. ожидание (mu): 3
+Введите дисперсию (var): 6
+Введите число отсчетов (n): 6
+Введите имя файла (например noise.txt): task1
+Готово! Список получен и записан в файл.
+Длина списка: 6
+Первые 10 значений: [4.903428780465844, 0.587814428103369, 4.692004162944187, 1.7931553860723835, 5.797829782338331, 2.3303270038829353]
+```
+#### Файл txt:
+```
+4.903428780465844 0.587814428103369 4.692004162944187
+1.7931553860723835 5.797829782338331 2.3303270038829353
+
+```

TEMA9/M0.py

@@ -0,0 +1,3 @@
+import M2
+result = M2.run()
+print("\nГотово. Результаты получены.")

TEMA9/M1.py

@@ -0,0 +1,38 @@
+import math
+def stats(sample):
+    x = list(sample)
+    n = len(x)
+    mn = min(x)
+    mx = max(x)
+    razmah = mx - mn
+    mean = sum(x) / n
+    if n > 1:
+        s = math.sqrt(sum((xi - mean) ** 2 for xi in x) / (n - 1))
+    else:
+        s = 0.0
+    if s == 0:
+        ratio = None
+    else:
+        ratio = razmah / s
+    return mn, mx, razmah, s, ratio
+def intervals(sample, m):
+    mn, mx, razmah, s, ratio = stats(sample)
+    x = sorted(sample)
+    n = len(x)
+    borders = [mn]
+    for k in range(1, m):
+        idx = int(k * n / m)
+        borders.append(x[idx])
+    borders.append(mx)
+    counts = [0] * m
+    for v in sample:
+        placed = False
+        for i in range(m - 1):
+            if borders[i] <= v < borders[i + 1]:
+                counts[i] += 1
+                placed = True
+                break
+        if not placed:
+            if borders[m - 1] <= v <= borders[m]:
+                counts[m - 1] += 1
+    return borders, counts

TEMA9/M2.py

@@ -0,0 +1,49 @@
+import os
+import M1
+import matplotlib.pyplot as plt
+def read_sample(filename):
+    data = []
+    with open(filename, "r", encoding="utf-8") as f:
+        for line in f:
+            for t in line.split():
+                data.append(float(t))
+    return data
+def run():
+    while True:
+        fname = input("Введите имя файла с выборкой: ").strip()
+        if os.path.exists(fname):
+            break
+        print("Файл не найден. Попробуйте ещё раз.")
+    sample = read_sample(fname)
+    print("Размер выборки:", len(sample))
+    m = int(input("Введите число интервалов m: "))
+    mn, mx, razmah, s, ratio = M1.stats(sample)
+    borders, counts = M1.intervals(sample, m)
+    print("\n--- Статистики ---")
+    print("min =", mn)
+    print("max =", mx)
+    print("размах =", razmah)
+    print("std =", s)
+    print("размах/std =", ratio)
+    print("\n--- Интервалы ---")
+    for i in range(m):
+        left = borders[i]
+        right = borders[i+1]
+        print(f"[{left}; {right}) -> {counts[i]}" if i < m-1 else f"[{left}; {right}] -> {counts[i]}")
+    labels = []
+    for i in range(m):
+        a = borders[i]
+        b = borders[i+1]
+        if i < m-1:
+            labels.append(f"[{a:.2f};{b:.2f})")
+        else:
+            labels.append(f"[{a:.2f};{b:.2f}]")
+
+    plt.bar(labels, counts)
+    plt.xticks(rotation=45, ha="right")
+    plt.title("Распределение элементов по интервалам")
+    plt.xlabel("Интервалы")
+    plt.ylabel("Число элементов")
+    plt.tight_layout()
+    plt.show()
+    return mn, mx, razmah, s, ratio, borders, counts

TEMA9/Mod3.py

@@ -0,0 +1,10 @@
+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)

TEMA9/SAU.py

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

@@ -0,0 +1,14 @@
+###main_SAU
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+from SAU import *
+xx=[0]+[1]*20 #Входной сигнал – «ступенька»
+SAUe=SAU(prm)   # Создаём экземпляр класса
+yt=[]
+for xt in xx:   # Прохождение входного сигнала
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+import pylab
+pylab.plot(yt)
+pylab.show()

TEMA9/report.md

@@ -0,0 +1,278 @@
+# Отчет по теме 9
+Бушманов Артём Сергеевич А-01-23
+## 1. Запуск интерактивной оболочки IDLE.
+
+## 2.  Создание классов и их наследников
+**Класс** — это “шаблон” (чертёж) для создания объектов.
+Он описывает:
+**какие данные** будет хранить объект (атрибуты),
+**что он умеет делать** (методы).
+**Объект (экземпляр класса)** — конкретная “копия” этого шаблона.
+Например: класс Employee — шаблон сотрудника, а emp_1 и emp_2 — два конкретных сотрудника.
+#### **Зачем нужны классы**
+**Упорядочивают код**: всё, что относится к одной сущности, хранится вместе (данные + действия).
+**Повторное использование**: один класс можно применять много раз (создать 100 объектов).
+**Удобно моделировать “реальные вещи”**: сотрудник, студент, счёт, датчик, модель системы и т.д.
+**Меньше ошибок**: легче контролировать, какие данные и как меняются.
+### 2.1. Создание автономного класса
+
+Создаем класс с именем Class1, содержащий 2 функции, реализующие его методы
+```python
+>>>class Class1:               #Объявление класса
+	def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
+		self.data=znach # self - ссылка на экземпляр класса
+	def otobrazh(self):     # Метод 2 класса1
+		print(self.data)#Отображение данных экземпляра класса
+>>>z1=Class1()   #Создаём 1-й экземпляр класса
+>>>z2=Class1()   #Создаём 2-й экземпляр класса
+>>>z1.zad_zn('экз.класса 1')  #Обращение к методу класса у 1-го экз.
+>>>z2.zad_zn(-632.453)         #Обращение к методу класса у 2-го экз.
+>>>z1.otobrazh()      # Обращение ко второму методу класса
+экз.класса 1
+>>>z2.otobrazh()
+-632.453
+>>>z1.data='Новое значение атрибута у экз.1'
+>>>z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+
+### 2.2. Создание класса-наследника
+```python
+>>>class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+		print('значение=',self.data)#Отображение данных экземпляра
+>>>z3 = Class2() # Экземпляр второго класса
+>>>z3
+<__main__.Class2 object at 0x100e75190>
+>>>dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+>>>z3.zad_zn('Совсем новое')
+>>>z3.otobrazh()
+значение= Совсем новое
+```
+При вызове z3.otobrazh() сработал метод класса Class2, потому что z3 принадлежит классу Class2.
+```python
+>>>z1.otobrazh()
+>>>Новое значение атрибута у экз.1
+```
+Как видим значение не изменилось.
+Удаление экземпляров классов инструкцией:
+```python
+>>>del z1, z2, z3
+```
+
+## 3. Использование классов, содержащихся в модулях
+Создадим модуль с именем Mod3, в который запишите следующее:
+```python
+>>>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)
+```
+Импортируем первый класс из модуля с помощью обычной инструкции:
+```python
+>>>from Mod3 import Class1 
+>>>z4 = Class1()
+>>>z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#171>", line 1, in <module>
+    z4.otobrazh()
+  File "/Users/ArtyomBushmanov/python-labs/TEMA9/Mod3.py", line 5, in otobrazh
+    print(self.data)
+AttributeError: 'Class1' object has no attribute 'data'
+```
+Данная ошибка возникает потому, что метод otobrazh() пытается обратиться к self.data, а Атрибут data еще не был создан для экземпляра z4. Мы не вызывали метод zad_zn(), который создает атрибут data.
+
+```python
+>>>from Mod3 import Class1
+>>>z4 = Class1()
+>>>	z4.data = 'значение данного data у экз.4'
+>>>z4.otobrazh()
+значение данного data у экз.4
+```
+
+Удаление экземпляра z4 и после этого импорт модуля целиком.
+```python
+>>>del z4
+>>>dir(z4)
+Traceback (most recent call last):
+  File "<pyshell#179>", line 1, in <module>
+    dir(z4)
+NameError: name 'z4' is not defined
+>>>import Mod3  #Полный импорт содержимого модуля
+>>>z4 = Mod3.Class2()
+```
+Здесь otobrazh - это уже просто функция, глобально определенная в модуле mod3. Она определена вне пользовательского класса, поэтому атрибута data в ее зоне доступа нет. Так что эта функция принимает один обязательный параметр - выводимую переменную.
+
+## 4.  Использование специальных методов
+Имена специальных методов предваряются одним или двумя подчерками и имеют вид: __<имя специального метода>
+```python
+>>>class Class3(Class2):  #Наследник класса Class2, а через него – и класса Class1
+    def __init__(self,znach): #Конструктор-вызывается при создании нового экземпляра класса
+        self.data=znach
+    def __add__(self,drug_zn):  #Вызывается, когда экземпляр участвует в операции «+»
+        return Class3(self.data+drug_zn)
+    def zad_dr_zn(self,povtor):  #А это - обычный метод
+	    self.data*=povtor
+```
+Метод __add__ - это один из методов, осуществляющих так называемую «перегрузку» операторов.
+
+Для иллюстрации работы этих методов создадим экземпляр класса Class3 и отобразим его:
+```python
+>>>z5=Class3('abc') #При создании экземпляра срабатывает конструктор
+>>>z5.otobrazh()
+значение= abc
+>>>z6 = z5 + 'def'
+>>>z6.otobrazh()
+значение= abcdef
+>>>z6.zad_dr_zn(3)
+>>>z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+
+## 5. Присоединение атрибутов к классу.
+```python
+>>>dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>>Class3.fio='Иванов И.И.'
+>>>dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>>z7=Class3(123)
+>>>dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>>dir(z7)==dir(Class3)
+False 
+>>>print(z7.fio)
+Иванов И.И.
+>>>z7.fio == Class3.fio
+True 
+>>>dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>>dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+Атрибут rozden у класса не появился.
+
+## 6. Выявление родительских классов.
+```python
+>>> Class3.__bases__ 
+(<class '__main__.Class2'>,)
+>>> Class2.__bases__
+(<class '__main__.Class1'>,)
+>>> Class1.__bases__ 
+(<class 'object'>,)
+>>> Class3.__mro__ 
+(<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
+>>> ZeroDivisionError.__mro__ 
+(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+
+## 7. Создание свойства класса.
+Свойство (property) класса – это особый атрибут класса, с которым можно производить операции чтения или задания его значения, а также удаление значения этого атрибута.
+```python
+class Class4:
+	def __init__(sam,znach):
+		sam.__prm=znach
+	def chten(sam):
+...                                 return sam.__prm
+... 	def zapis(sam,znch):
+... 		sam.__prm=znch
+... 	def stiran(sam):
+... 		del sam.__prm
+... 	svojstvo=property(chten,zapis,stiran)
+... 
+... 	
+>>> exempl=Class4(12)
+>>> exempl.svojstvo
+12
+>>> exempl.svojstvo=45
+>>> print(exempl.svojstvo)
+45
+>>> del exempl.svojstvo
+>>> exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#226>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#218>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+Такой вывод происходит, потому что этот атрибут уже удален.
+
+## 8. Пример представления в виде класса модели системы автоматического регулирования (САР), состоящей из последовательного соединения усилителя и двух инерционных звеньев, охваченных отрицательной обратной связью с усилителем.
+
+Создание модуля SAU.py с классом:
+```python
+>>>class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+    
+    def model(self):
+        def inerz(x,T,yy):
+            return (x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3]
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) 
+        y3=inerz(y2,self.param[2],self.ypr[1]) 
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])
+```
+
+Тестирование класса:
+```python
+###mainSAU
+>>>prm=[2.5,4,1.3,0.8] 
+>>>from SAU import *
+>>>xx=[0]+[1]*20 
+>>>SAUe=SAU(prm)   
+>>>yt=[]
+>>>for xt in xx:   
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+>>>import pylab
+>>>pylab.plot(yt)
+>>>pylab.show()
+>>>import mainSAU
+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
+```
+
+![График](Figure_1.png)
+
+
+## 9. Завершение работы со средой IDLE.

TEMA9/sample1.txt

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

TEMA9/sample2.txt

@@ -0,0 +1,4 @@
+-5 -4 -3 -2 -1 0
+0 0 1 1 2 2
+3 5 8 13 21
+34

TEMA9/task.md

@@ -0,0 +1,74 @@
+# Общее контрольное задание по теме 9
+## Бушманов А.С. А-01-23
+## Задание:
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+
+- конструктор, задающий четырем атрибутам (fio,otdel,dolzhnost,oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+- метод для обеспечения перевода сотрудника из одного отдела в другой;
+- метод для изменения должности сотрудника;
+- свойство, содержащее перечень (список) поощрений сотрудника.
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+
+## Решение:
+```python
+class Employee:
+    def __init__(self, fio="", otdel="", dolzhnost="", oklad=0):
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+        self._pooshreniya = []   # список поощрений
+
+    def info(self):
+        print(f"{self.fio}, {self.otdel}, {self.dolzhnost}, оклад: {self.oklad}")
+
+    def povyshenie_oklada(self, summa):
+        self.oklad += summa
+
+    def perevod(self, new_otdel):
+        self.otdel = new_otdel
+
+    def smena_dolzhnosti(self, new_dolzhnost):
+        self.dolzhnost = new_dolzhnost
+
+    # property: только чтение списка поощрений
+    @property
+    def pooshreniya(self):
+        return self._pooshreniya
+
+    # добавить поощрение
+    def add_pooshrenie(self, text):
+        self._pooshreniya.append(text)
+
+    # удалить поощрение
+    def del_pooshrenie(self, text):
+        if text in self._pooshreniya:
+            self._pooshreniya.remove(text)
+```
+## Ответ:
+```python
+>>> emp_1 = Employee("Обычайко Д.С.", "Кафедра Управления и информационных технологий", "Ассистент", 100000)
+>>> emp_2 = Employee("Бобряков А.В.", "Кафедра Управления и информационных технологий", "Заведующий кафедрой", 1500000)
+>>> emp_1.info()
+Обычайко Д.С., Кафедра Управления и информационных технологий, Ассистент, оклад: 100000
+>>> emp_2.info()
+Бобряков А.В., Кафедра Управления и информационных технологий, Заведующий кафедрой, оклад: 1500000
+>>> emp_1.povyshenie_oklada(15000)
+>>> emp_1.add_pooshrenie("Премия за научную работу")
+>>> emp_2.smena_dolzhnosti("Декан факультета")
+>>> emp_2.perevod("Деканат")
+>>> emp_2.add_pooshrenie("Надбавка за руководство")
+>>> print("Поощрения", emp_1.fio, ":", emp_1.pooshreniya)
+Поощрения Обычайко Д.С. : ['Премия за научную работу']
+>>> print("Поощрения", emp_2.fio, ":", emp_2.pooshreniya)
+Поощрения Бобряков А.В. : ['Надбавка за руководство']
+>>> emp_1.del_pooshrenie("Премия за научную работу")
+>>> print("После удаления поощрения у", emp_1.fio, ":", emp_1.pooshreniya)
+После удаления поощрения у Обычайко Д.С. : []
+>>> emp_1.info()
+Обычайко Д.С., Кафедра Управления и информационных технологий, Ассистент, оклад: 115000
+>>> emp_2.info()
+Бобряков А.В., Деканат, Декан факультета, оклад: 1500000
+```

TEMA9/test.md

@@ -0,0 +1,192 @@
+# Индивидуальное контрольное задание  по теме 9
+Бушманов А.С. А-01-23
+## Задание: Вариант 14
+M3_14
+### Создайте модуль М1, содержащий две функции:
+
+функция 1: аргумент - список или кортеж с выборкой; функция должна произвести расчет по выборке списка с наименьшим и наибольшим значениями, размахом (разность наибольшего и наименьшего значений), оценкой стандартного отклонения и отношением размаха к стандартному отклонению;
+
+функция 2: аргументы - список или кортеж с выборкой и целочисленный параметр m; функция должна обратиться к функции 1 и затем определить границы m непересекающихся интервалов в диапазоне величины между наибольшим и наименьшим значениями по выборке, содержащих примерно одинаковое число элементов выборки; функция должна вернуть 2 списка: со значениями границ интервалов и с числами элементов в интервалах.
+### Создайте еще один модуль М2, в котором должны выполняться следующие операции:
+
+запрашивается имя текстового файла с выборкой, проверяется его наличие и при отсутствии - повторяется запрос;
+
+выборка вводится из файла и записывается в список (в строках файла может быть разное число значений, разделенных пробелами);
+
+запрашиваются у пользователя число интервалов разбиения;
+
+с помощью функций 1 и 2 производится определение границ интервалов и чисел элементов в них.
+
+отображается столбиковая диаграмма с интервалами и числами элементов выборки в них.
+### Создайте модуль М0 - главную программу, которая вызывает М2 и отображает результаты расчета на экране.
+### Проведите расчеты при 2-х разных файлах с выборками
+## Решение:
+#### Модуль 1: M1
+```python
+import math
+def stats(sample):
+    x = list(sample)
+    n = len(x)
+    mn = min(x)
+    mx = max(x)
+    razmah = mx - mn
+    mean = sum(x) / n
+    if n > 1:
+        s = math.sqrt(sum((xi - mean) ** 2 for xi in x) / (n - 1))
+    else:
+        s = 0.0
+    if s == 0:
+        ratio = None
+    else:
+        ratio = razmah / s
+    return mn, mx, razmah, s, ratio
+def intervals(sample, m):
+    mn, mx, razmah, s, ratio = stats(sample)
+    x = sorted(sample)
+    n = len(x)
+    borders = [mn]
+    for k in range(1, m):
+        idx = int(k * n / m)
+        borders.append(x[idx])
+    borders.append(mx)
+    counts = [0] * m
+    for v in sample:
+        placed = False
+        for i in range(m - 1):
+            if borders[i] <= v < borders[i + 1]:
+                counts[i] += 1
+                placed = True
+                break
+        if not placed:
+            if borders[m - 1] <= v <= borders[m]:
+                counts[m - 1] += 1
+    return borders, counts
+
+```
+#### Модуль 2: M2
+```python
+import os
+import M1
+import matplotlib.pyplot as plt
+def read_sample(filename):
+    data = []
+    with open(filename, "r", encoding="utf-8") as f:
+        for line in f:
+            for t in line.split():
+                data.append(float(t))
+    return data
+def run():
+    while True:
+        fname = input("Введите имя файла с выборкой: ").strip()
+        if os.path.exists(fname):
+            break
+        print("Файл не найден. Попробуйте ещё раз.")
+    sample = read_sample(fname)
+    print("Размер выборки:", len(sample))
+    m = int(input("Введите число интервалов m: "))
+    mn, mx, razmah, s, ratio = M1.stats(sample)
+    borders, counts = M1.intervals(sample, m)
+    print("\n--- Статистики ---")
+    print("min =", mn)
+    print("max =", mx)
+    print("размах =", razmah)
+    print("std =", s)
+    print("размах/std =", ratio)
+    print("\n--- Интервалы ---")
+    for i in range(m):
+        left = borders[i]
+        right = borders[i+1]
+        print(f"[{left}; {right}) -> {counts[i]}" if i < m-1 else f"[{left}; {right}] -> {counts[i]}")
+    labels = []
+    for i in range(m):
+        a = borders[i]
+        b = borders[i+1]
+        if i < m-1:
+            labels.append(f"[{a:.2f};{b:.2f})")
+        else:
+            labels.append(f"[{a:.2f};{b:.2f}]")
+
+    plt.bar(labels, counts)
+    plt.xticks(rotation=45, ha="right")
+    plt.title("Распределение элементов по интервалам")
+    plt.xlabel("Интервалы")
+    plt.ylabel("Число элементов")
+    plt.tight_layout()
+    plt.show()
+    return mn, mx, razmah, s, ratio, borders, counts
+```
+#### Модуль 3: M0
+```python
+import M2
+result = M2.run()
+print("\nГотово. Результаты получены.")
+```
+## Ответ c sampe1.txt:
+```python
+import M0
+Введите имя файла с выборкой: sample1
+Файл не найден. Попробуйте ещё раз.
+Введите имя файла с выборкой: sample1.txt
+Файл не найден. Попробуйте ещё раз.
+Введите имя файла с выборкой: sample1.txt
+Размер выборки: 20
+Введите число интервалов m: 5
+
+--- Статистики ---
+min = 1.0
+max = 12.0
+размах = 11.0
+std = 3.216323497738569
+размах/std = 3.4200539864022432
+
+--- Интервалы ---
+[1.0; 3.0) -> 4
+[3.0; 4.0) -> 3
+[4.0; 6.0) -> 5
+[6.0; 9.0) -> 4
+[9.0; 12.0] -> 4
+
+Готово. Результаты получены.
+```
+![[test_figure_1.png]]
+## Ответ c sampe2.txt:
+```python
+import M0
+Введите имя файла с выборкой: sample2.txt
+Размер выборки: 18
+Введите число интервалов m: 8
+
+--- Статистики ---
+min = -5.0
+max = 34.0
+размах = 39.0
+std = 9.751319669363612
+размах/std = 3.9994586704534942
+
+--- Интервалы ---
+[-5.0; -3.0) -> 2
+[-3.0; -1.0) -> 2
+[-1.0; 0.0) -> 1
+[0.0; 1.0) -> 3
+[1.0; 2.0) -> 2
+[2.0; 5.0) -> 3
+[5.0; 13.0) -> 2
+[13.0; 34.0] -> 3
+
+Готово. Результаты получены.
+```
+![[test_figure_2.png]]
+#### Файл sample1.txt:
+```
+1 2 3 4 5 6
+2 2 3 3 4 4
+5 6 7 8 9
+10 11 12
+```
+#### Файл sample2.txt:
+```
+-5 -4 -3 -2 -1 0
+0 0 1 1 2 2
+3 5 8 13 21
+34
+```