zadanie

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 <Цветкова Т. А.>
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1')

TEMA1/laba1.md

@@ -0,0 +1,156 @@
+# Отчет.
+## Модуль 1 Основы языка программирования Python. 
+## Тема 1. Знакомство с интерпретатором и интерактивной оболочкой IDLE.
+
+## Пункт1:
+Была создана папка и распакован архив Tema1/
+
+## Пункт2:
+Запустили на выполнение интерпетатор Python 3.11
+
+## Пункт3:
+Ввели команду print и убедились в ее работоспособности. 
+```py
+>>> print('Hello')
+Hello
+```
+
+## Пункт4:
+Изучили команду input.
+```py
+>>> h=input('Your Name=')
+Your Name=Tanya
+>>> h
+'Tanya'
+```
+
+## Пункт5:
+Завершили работу интерпретатора с помощью команды 
+```py
+>>>exit().
+```
+
+## Пункт6:
+Запустили IDLE Python 3.11 
+
+## Пункт7:
+Изучили устройство главного командного окна
+
+## Пункт8: 
+Ввели инструкции настройки рабочего каталога среды
+```py
+>>>import os
+>>>os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1')
+```
+
+## Пункт9:
+Установили в среде шрифт типа Arial CYR, размер 11, размер начального окна - высота 50 символов, ширина 100 символов, подкраска комментариев - коричневая
+
+## Пункт10:
+Создали новый фйл Pr0.py
+```py
+Программа по Теме 1 <ЦветковаТА>
+>>>print('Hello')
+>>>h=input('Your name=')
+>>>import os
+>>>os.chdir('C:\\Users\\Admin\\Desktop\\TsvetkovaTA\\Tema1\\')
+```
+
+Запустили модуль и получили результат
+```py
+>>>import Pr0
+Hello
+Your name=Tanya
+```
+
+## Пункт11:
+Запустили модуль prb1 
+```py
+>>>import prb1
+Как Вас зовут? Таня
+Привет, Таня
+```
+
+## Пункт12:
+Попробовали открыть файл Pr0.cpython-34.pyc и поняли, что из-за скомпилированного бинарного файла текстовый редактор как раз-таки выдает ошибку, тк не может считать файл .рус, ожидая стандартную для него кодировку.
+Комплиляция программ необходима, чтобы перевести команды из человекопонятной формы в машинный код, который может быть обработан процессором.
+При выполнении скрипта Python сначала преобразовывает его в байт-код (.рус), а затем уже он компилируется с помощью виртуальный машины. 
+Это ускорит повторную загрузку программы. 
+
+## Пункт13:
+В текстовом редакторе оболочки IDLE открыли новое окно. 
+Сохранили все из командного окна 
+
+## Пункт14:
+В разделе помощи можно увидеть следующее
+```py
+About IDLE - информация о версии IDLE
+IDLE Help - документация по самой IDLE
+Python Docs - документация по языку Python
+Turtle Demo - окно работы и помощь модуля для работы с графикой turtle
+```
+```py
+>>>help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+```
+```py
+>>>help(print), help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+```
+при F1 открывается справочное окно
+
+## Пункт15:
+Узнали, что опция Окно (Window)» помогает перемещаться между открытыми окнами
+```py
+>>>import  tdemo_chaos
+>>>tdemo_chaos.main()
+'Done!'
+```
+
+Вывели на экран графическое представление
+программы с часами. Есть и другие примеры программ модуля turtle,
+которые можно брать за основу собственных программ, изменять или реализовывать
+свои идеи
+
+## Пункт16:
+Звершили работу со средой 
+```py
+>>>exit
+```

TEMA1/protocol.py

@@ -0,0 +1,15 @@
+ #Программа по Теме 1 <Цветкова Т. А.>
+
+import os
+os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1')
+
+import Pr0
+Hello
+Your name=Tatyana
+
+import os
+os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1')
+
+import prb1
+Как Вас зовут? Tatyana
+Привет, Tatyana

TEMA2/lab2.md

@@ -0,0 +1,604 @@
+# Протокол по Теме 2 <ЦветковаТА>»
+## пункт2:
+изучили простые объекты и присваивание
+```py
+>>>f1=16; f2=3
+>>>f1,f2
+(16, 3)
+```
+Или через точку с запятой. тогда друг за другом:
+```py
+>>> f1; f2
+16
+3
+```
+Узнаем какие объекты уже существуют в среде
+```py
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']
+```
+
+Еще эта функция может показать атрибуты объекта:
+```py
+
+>>> dir (f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__',
+ '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__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__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag',
+ 'numerator', 'real', 'to_bytes']
+```
+Функция del необходима для удаления объекта
+```py
+>>> del f1,f2
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
+```
+## Пункт3:
+```py
+>>>gg1=1.6  #значение в виде вещественного числа
+>>>hh1='Строка'  #значение в виде символьной строки
+>>>73sr=3   #неправильное имя – начинается с цифры - будет диагностика!
+SyntaxError: invalid decimal literal
+>>>and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!
+SyntaxError: invalid syntax
+```
+## Пункт4:
+Вывели список ключевых слов и присвоили команду к переменной 
+```py
+>>>import keyword
+>>>keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>>k=keyword.kwlist
+k
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+## Пункт5:
+Выведем список встроенных идеентификаторов 
+```py
+>>>import builtins
+>>>dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+модуль
+```py
+>>>abs(-7)
+7
+```
+длинна
+```py
+>>>len([1,2])
+2
+```
+максимум и минимум
+```py
+>>>max(20,5)
+20
+>>>min(20,5)
+5
+```
+
+возведение в степень 
+```py
+>>>pow(4,2)
+16
+```
+возведение в степень по модулю
+```py
+>>>pow (5, 2, 2)
+1
+```
+округление
+```py
+>>>round (33.2)
+33
+```
+округление с определенной точностью
+```py
+>>>round (33.45826, 3)
+33.458
+```
+сумма
+```py
+>>>sum ([2, 5])
+7
+```
+сортировка и иобратная сортировка
+```py
+>>>sorted ([5, 4, 18, 40, -6, 0])
+[-6, 0, 4, 5, 18, 40]
+>>>sorted ([5, 4, 18, 40, -6, 0], reverse = True)
+[40, 18, 5, 4, 0, -6]
+```
+Объединение объектов в кортеж (возвращается указатель на участок памяти)
+```py
+>>> list1 = [1, 2, 3]
+>>> list2 = [4, 5, 6]
+>>> zip (list1, list2)
+<zip object at 0x0000000002C42E88>
+Это итератор - указатель на объект памяти. Чтобы увидеть сам кортеж, итератор надо
+преобразовать в другой объект
+>>> list(zipped)
+[(1, 4), (2, 5), (3, 6)]
+```
+## Пункт6:
+Регестрочувствительность 
+```py
+>>>Gg=45
+>>>Gg
+45
+>>>gg
+Traceback (most recent call last):
+  File "<pyshell#39>", line 1, in <module>
+    gg
+NameError: name 'gg' is not defined. Did you mean: 'Gg'?
+```
+## Пункт7:
+Типы объектов
+```py
+>>>bb1=True; bb2=False
+>>>bb1;bb2
+True
+False
+>>>type(bb1)
+<class 'bool'>
+тип (класс) объекта
+```
+Целое число (десятичное)
+```py
+>>> ii1 = 1234567890
+>>> type(ii1)
+<class 'int'>
+```
+
+Экспоненциальная форма записи числа
+```py
+>>> ff1 = 8.987e-12
+>>> type(ff1)
+<class 'float'>
+```
+Двоичное число (префикс 0b - binary)
+```py
+>>> dv1 = 0b1100101
+>>> type(bb1)
+<class 'bool'>
+```
+Восьмеричное число (0о - octal)
+```py
+>>> vsm1 = 0o52765
+>>> type(vsm1)
+<class 'int'>
+```
+Шестнадцатеричное число (0х - hexadecimal)
+```py
+>>> shest1 = 0x7109af6 
+>>> type(shest1)
+<class 'int'>
+```
+Комплексное число
+```py
+>>> cc1 = 2 - 3j
+>>> type(cc1)
+<class 'complex'>
+```
+```py
+>>> a = 3.67
+>>> b = 0.45
+>>> cc2 = complex (a, b)
+>>> cc2
+(3.67+0.45j)
+>>> type (cc2)
+<class 'complex'>
+```
+Строка символов
+```py
+>>> ss1='Это - строка символов'
+>>> ss1="Это - строка символов"
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ",
+         выводимая на двух строках
+>>> ss1b= 'Меня зовут: \n <Цветкова ТА>'
+>>> print(ss1b)
+Меня зовут:
+ <Цветкова ТА>
+```
+```py
+>>> mnogo="""Нетрудно заметить , что в результате операции
+... над числами разных типов получается число,
+... имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.
+
+
+Обратимся к отдельным элементам с помощью квадратных кавычек
+(нумерация с нуля):
+```py
+>>> mnogo[5]
+'д'
+```
+Обращение начиная с последнего элемента:
+```py
+>>> ss1b[-1]
+'>'
+```
+Срезы:
+```py
+>>> ss1[7:10]
+'тро'
+```
+Срез с шагом в 2:
+```py
+>>> ss1[7:14:2]
+'тоас'
+```
+```py
+>>> ss1[5:-8]
+' строка '
+```
+
+Задав шаг -1, можно вывести строку в обратном порядке:
+```py
+>>> ss1[::-1]
+'воловмис акортс - отЭ'
+```
+К элементу можно обратиться как по нумерации с начала, так и с конца:
+```py
+>>> ss1[17:3:-2]
+'омсаот '
+>>> ss1[-4:3:-2]
+'омсаот '
+```
+
+Строка является неизменяемым объектом
+```py
+>>> ss1[4]='=' # Будет диагностика!
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'str' object does not support item assignment
+>>> ss1=ss1[:4]+'='+ss1[5:]
+>>> print(ss1)
+Это = строка символов
+```
+Новый объект на основе среза из старого:
+```py
+>>> ss1b_cut  = ss1b [::-1]
+>>> ss1b_cut
+'>АТ авоктевЦ< \n :тувоз янеМ'
+```
+## Пункт8:
+Список
+```py
+>>> spis1 = ["111", 'spisok', 5 - 9j]
+>>> stup=[0,0,1,1,1,1,1,1,1]
+>>> stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> pis=[1,2,3,4,
+... 5,6,7,
+... 8,9,10]
+>>> pis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+>>> spis1 [-1]
+(5-9j)
+>>> stup [-8 :: 2]
+[0, 1, 1, 1]
+>>> spis1[1]='Список'
+>>> spis1
+['111', 'Список', (5-9j)]
+>>> len(spis1)
+3
+```
+Методы списка
+Добавление в конец (append)
+```py
+>>> help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+>>> spis1.append('New item')  # В конец списка добавлен элемент «New item»
+>>> spis1
+['111', 'Список', (5-9j), 'New item']
+>>> spis1+['New item']
+Только возвращает результат, но не фиксирует такое значение!
+['111', 'Список', (5-9j), 'New item', 'New item']
+```
+Удаление элемента по индексу
+```py
+>>> spis1.pop(1)
+'Список'
+>>> spis1
+['111', (5-9j), 'New item', 'Меня зовут: \n <Цветкова ТА>']
+```
+Вставка элемента в определенное место по индексу (insert)
+```py
+>>> spis1.insert(2, "hello")
+>>> spis1
+['111', (5-9j), 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>']
+```
+Удаление элемента по значению (remove)
+```py
+ >>> help(spis1.remove)
+Help on built-in function remove:
+
+remove(value, /) method of builtins.list instance
+    Remove first occurrence of value.
+    
+    Raises ValueError if the value is not present.
+
+>>> spis1.remove(111)
+>>> spis1
+[(5-9j), 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>']
+```
+```py
+>>> spis1.remove('222')
+Traceback (most recent call last):
+  File "<pyshell#39>", line 1, in <module>
+    spis1.remove('222')
+```
+  Добавление элементов объекта в конец другого объекта (extend)
+ ```py   
+    >>> help(spis1.extend)
+Help on built-in function extend:
+
+extend(iterable, /) method of builtins.list instance
+    Extend list by appending elements from the iterable.
+>>> end1 = [77, "lab"]
+>>> spis1.extend(end1)
+>>> spis1
+[(5-9j), 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>', '77', 'lab']
+    ```
+    
+Полное очищение списка (clear)
+```py
+    >>> help(spis1.clear)
+Help on built-in function clear:
+
+clear() method of builtins.list instance
+    Remove all items from list.
+
+>>> end1.clear()
+>>> end1
+[]
+```
+ Сортировка списка БЕЗ создания нового объекта (sort)
+```py
+    >>> help(spis1.sort)
+Help on built-in function sort:
+
+sort(*, key=None, reverse=False) method of builtins.list instance
+    Sort the list in ascending order and return None.
+    
+    The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
+    order of two equal elements is maintained).
+    
+    If a key function is given, apply it once to each list item and sort them,
+    ascending or descending, according to their function values.
+    
+    The reverse flag can be set to sort in descending order.
+>>> abc = [4,7,-3,0]
+>>> abc.sort(key = abs, reverse = True)
+>>> abc
+[7, 4, -3, 0]
+```
+При этом некоторые key's не применимы для некоторых типов (у string нет abs,
+у complex нет длины и т.д.)
+
+  Создание копии списка (copy)
+```py
+    >>> help(abc.copy)
+Help on built-in function copy:
+
+copy() method of builtins.list instance
+    Return a shallow copy of the list.
+
+>>> abccopy=abc.copy()
+>>> abccopy
+[7, 4, -3, 0]
+```
+ Поиск индекса по значению (index)
+```py
+>>> help(abccopy.index)
+Help on built-in function index:
+
+index(value, start=0, stop=9223372036854775807, /) method of builtins.list instance
+    Return first index of value.
+
+    Raises ValueError if the value is not present.
+
+>>> abccopy.index(0)
+3
+```
+  Подсчет количества элементов по значению (count)
+```py
+>>> help(abccopy.count)
+Help on built-in function count:
+
+count(value, /) method of builtins.list instance
+    Return number of occurrences of value.
+
+>>> abccopy.count(4)
+1
+```
+Вложенные списки:
+```py
+>>> spis2=[spis1,[4,5,6,7]]
+>>> spis2
+[['111', (5-9j), 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>', '77', 'lab'], [4, 5, 6, 7]]
+>>> spis2[0][1]
+(5-9j)
+>>> spis2[0][1]=78
+>>> spis2
+[['111', 78, 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>', '77', 'lab'], [4, 5, 6, 7]]
+>>> spis1
+[['111', 78, 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>', '>'
+```
+spis1 тоже изменился. Это происходит потому, что python работает не просто с
+объектами, а с ссылками на участки памяти. То есть, в Python списки передаются по ссылке,
+а не по значению.
+
+Кортеж: последовательность как список, но неизменяемая как строка.
+```py
+>>> kort1=(222,'Kortezh',77+8j)
+>>> kort1= kort1+(1,2)
+>>> kort1= kort1+(ss1b,)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n <Цветкова ТА>')
+>>> kort2=kort1[:2]+kort1[3:]
+>>> kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n <Цветкова ТА>')
+>>> kort1.index(2)
+4
+>>> kort1.count(222)
+1
+>>> kort1[2]=90
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'tuple' object does not support item assignment
+>>> kortstr = ("gjgvu", 4, [1,2,3], (1,2))
+>>> kortstr
+('gjgvu', 4, [1, 2, 3], (1, 2))
+>>> type(kortstr[3])
+<class 'tuple'>
+>>> type(kortstr[2])
+<class 'list'>
+```
+
+Словарь (dictionary) - содержит в себе совокупность пар
+"ключ (key) (неизменяемый)": "значение (value) (любого типа)"
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>> dic1[1]
+Traceback (most recent call last):
+  File "<pyshell#99>", line 1, in <module>  #как видно, обратиться по индексу нельзя
+    dic1[1]
+KeyError: 1
+>>> dic1['Orel']
+56
+>>> dic1['Pskov']=78
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+>>> sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>> sorted(dic1.values())
+[45, 56, 78, 145]
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}
+>>> dic3={'statistics':dic2,'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 <Цветкова ТА>'}
+```
+Создание собственного словаря на основе кортежа из семи элементов и списка из пяти:
+```py
+>>> a0223=('спать', 'учиться','работать', 'кмы','барс','лекции','общежитие')
+>>> a0123=['1', '2', '3', '4', '5']
+>>> MPEI=dict(zip(a0123, a0223))
+>>> MPEI
+{'1': 'спать', '2': 'учиться', '3': 'работать', '4': 'кмы', '5': 'барс'}
+```
+В итоговом словаре пять объектов. Это связано с работой функции zip:
+длина итогового объекта = минимальной длине составляющего
+объекта.
+
+Словари: состоят из НЕповторяющихся неизменяемых элементов
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>> mnoz1
+{'двигатель', 'линия связи', 'датчик', 'микропроцессор'}
+>>> len(mnoz1)
+4
+>>> 'датчик' in mnoz1
+True
+>>> mnoz1.add('реле')
+>>> mnoz1.remove('линия связи')
+>>> mnoz1
+{'реле', 'микропроцессор', 'датчик', 'двигатель'}
+```
+
+
+Общее контрольное задание:
+
+    1. Создать переменную с именем familia и со значением -
+    символьной строкой – своей фамилией в латинской транскрипции.
+```py
+>>> familia = 'Tsvetkova'
+```
+    2. Создать переменную со значением, совпадающим с первой
+    буквой из familia.
+```py
+>>> fam1 = familia[0]
+>>> fam1
+'T'
+```
+    3. Создать переменную с именем sp_kw со значением –
+    списком всей ключевых слов языка Python.
+```py
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> sp_kw
+['False', 'None', 'True', '__peg_parser__', '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'. Выводом списка в
+    командном окне IDLE убедитесь, что это значение удалено из списка.
+```py
+>>> sp_kw.remove('nonlocal')
+>>> sp_kw
+['False', 'None', 'True', '__peg_parser__', '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.
+```py
+>>> kort_nam = ('Stas', 'Dana', 'Katya', 'Tanya')
+>>> type(kort_nam)
+<class 'tuple'>
+```
+    6. Напишите инструкцию, добавляющую в kort_nam имена
+    еще двух студентов. 
+```py
+>>> kort_nam += ('Andrey', 'Nastya')
+>>> kort_nam
+('Stas', 'Dana', 'Katya', 'Tanya', 'Andrey', 'Nastya')
+```
+    7. Напишите инструкцию, позволяющую определить, сколько раз в
+    кортеже присутствуют студенты с именем «Дима».
+```py
+>>> kort_nam.count("Dima")
+0
+```
+    8. Создайте словарь dict_bas, в котором ключами являются русские
+    названия типов переменных, использованных в предыдущих операторах,
+    а значениями – ранее созданные переменные, соответствующие этим типам.
+```py
+>>> dict_bas = {"строка": familia, "символ": fam1, "список": sp_kw,
+                "кортеж": kort_nam,}
+>>> dict_bas
+{'строка': 'Tsvetkova', 'символ': 'T', 'список': ['False', 'None', 'True',
+'__peg_parser__', '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'], 'кортеж': ('Stas', 'Dana', 'Katya', 'Tanya', 'Andrey', 'Nastya')}
+```

TEMA3/Test.md

@@ -0,0 +1,48 @@
+## 1)Для чего предназначено предложение "Окно (Window)" главного меню?
+Для быстрого переключения между различными открытыми окнами в среде IDLE 
+
+## 2)Создайте объект-кортеж с 5 произвольными двоичными элементами. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+```py
+>>> bin(4)
+'0b100'
+>>> bin(6)
+'0b110'
+>>> bin(7)
+'0b111'
+>>> bin(44)
+'0b101100'
+>>> bin(99)
+'0b1100011'
+>>> k=(0b100, 0b110, 0b111, 0b101100,0b1100011)
+>>> type(k)
+<class 'tuple'>
+>>> dir(k)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+
+```
+## 3)Напишите инструкцию создания нового кортежа, в который включите два последних элемента ранее созданного кортежа, и два элемента - символы "a" и "b". Отобразите созданный объект на экране.
+```py
+>>> k1=k[-2:]+('a','b')
+>>> k1
+(44, 99, 'a', 'b')
+```
+## 4)	Преобразуйте кортеж в список. Вставьте в качестве второго элемента списка значение "Автоматизированная система". Отобразите полученный объект. 
+```py 
+>>> spisok=list(k1)
+>>> spisok.insert(1, 'Автоматизированная система')
+>>> spisok
+[44, 'Автоматизированная система', 99, 'a', 'b']
+```
+## 5) Напишите инструкции, обеспечивающие подсчет суммы числовых элементов кортежа. С использованием формата отобразите результат по шаблону: "Сумма элементов=:".
+```py
+>>> sum_rez=0
+>>> for element in k1:
+...     if type(element)==int:
+...         sum_rez += element
+...
+>>> sum_rez
+143
+>>> s="Сумма элементов=:"+str(sum_rez)
+>>> s
+'Сумма элементов=:143'
+```

TEMA3/lab3.md

@@ -0,0 +1,813 @@
+# Отчет
+## Тема 3. 
+Операции с объектами
+## Пункт 2. 
+Преобразование простых базисов типов объектов
+##  2.1 Преобразование в логический тип с помощью функции bool(<Объект>)
+```py
+>>>logiz1=bool(56)
+>>>logiz1
+True
+>>>logiz2=bool(0)
+>>>logiz2
+False
+>>>logiz3=bool("Beta")
+>>>logiz3
+True
+>>>logiz4=bool("")
+>>>logiz4
+False
+```
+## 2.2 Преобразование в целое десятичное число
+```py
+>>>tt1= int(198.6)
+>>>tt1
+198
+>>>tt2=int('-76')
+>>>tt2
+-76
+>>>tt3= int('B',16)
+>>>tt3
+11
+>>>tt4=int("71",8)
+>>>tt4
+57
+>>> tt5=int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#34>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+Функция int() может преобразовывать в целое число только строки, которые содержат целое число (например, "98"). Строка "98.76" содержит десятичную точку, поэтому возникает ошибка.
+Решить эту проблему можно так:
+```py
+>>>tt5 = int(float("98.76"))
+>>>tt5
+98
+```
+## 2.3 Преобразование десятичных чисел в другие системы счисления
+```py
+>>>hh=123
+>>>dv1=bin(hh) #в двоичную сс
+>>>dv1
+'0b1111011'
+>>>vos1=oct(hh) #в восьмеричную сс
+>>>vos1
+'0o173'
+>>>shs1=hex(hh) #в шеснадцатеричную сс
+>>>shs1
+'0x7b'
+```
+Для проверки выполним обратные преобразования 
+
+```py
+>>>int (dv1,2)
+123
+>>int(vos1,8)
+123
+>>int(shs1,16)
+123
+```
+## Пункт 3. 
+Преобразование более сложных базовых типов объектов
+## 3.1 Преобразование в строку символов с помощью функции str(<Объект>)
+```py
+>>>strk=str(23.6)
+>>>strk
+'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(<Объект>)
+```py
+>>>spis1=list("Строка символов")  #Заданная строка разделяется на символы
+>>>spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+>>>spis2=list((124,236,-15,908))   #Кортеж превращается в список
+>>>spis2
+[124, 236, -15, 908]
+>>>spis3=list({"A":1,"B":2,"C":9})  #Преобразование словаря в список
+>>>spis3
+['A', 'B', 'C']
+>>> spis4 = list({"A":1,"B":2,"C":9}.values())
+>>> spis4
+[1, 2, 9]
+```
+## 3.3 Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>)
+```py
+>>>kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+>>>kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+
+>>>kort8=tuple(spis2)   #Преобразование списка в кортеж
+>>>kort8
+(124, 236, -15, 908)
+>>>kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+>>>kort9
+('A', 'B', 'C')
+>>> kort9 = tuple(({"A":1,"B":2,"C":9}.values()))
+>>> kort9
+(1, 2, 9)
+```
+## 3.4. Удаление объектов
+```py
+>>>del strk5, kort8
+Проверим
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1']
+```
+Создадим строку со своей фамилией и инициалами, преобразуем её в список, затем список – в кортеж и, наконец, кортеж – в строку. 
+```py
+>>> f= 'ЦветковаТА'
+>>> spis= list(f)
+>>> spis
+['Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А']
+>>> k=tuple(spis)
+>>> k
+('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')
+>>> kk=str(k)
+>>> kk
+"('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')"
+>>> sttr = ''.join(k)
+>>> sttr
+'ЦветковаТА'
+```
+## Пункт 4. Арифметические операции.
+## 4.1.	 Сложение и вычитание (+ и -)
+```py
+>>> 12+7+90
+109
+>>> 5.689e-1 - 0.456
+0.11289999999999994
+>>> 23.6+54
+77.6
+>>> 14-56.7+89
+46.3
+```
+## 4.2.	 Умножение (*)
+```py
+>>> -6.7*12
+-80.4
+```
+## 4.3.	 Деление (/). Результатом деления всегда будет вещественное число!
+```py
+>>> -234.5/6
+-39.083333333333336
+>>> a=178/45
+>>> a
+3.9555555555555557
+>>> type(a)
+<class 'float'>
+```
+## 4.4. Деление с округлением вниз (//). Здесь результат может быть целым или вещественным. 
+```py
+>>> b=178//45
+>>> b
+3
+>>> type(b)
+<class 'int'>
+>>> c=-24.6//12.1
+>>> c
+-3.0
+>>> type(c)
+<class 'float'>
+```
+## 4.5.	 Получение остатка от деления (%).
+```py
+>>> 148%33
+16
+>>> 12.6%3.8
+1.2000000000000002
+>>> 56.97%6
+2.969999999999999
+```
+## 4.6.	 Возведение в степень (**). 
+```py
+>>> 14**3
+2744
+>>> e=2.7**3.6
+>>> e
+35.719843790663525
+>>> d=2.7**3
+>>> d
+19.683000000000003
+```
+Попробуем проделать арифметические операции над комплексными числами. Создадим два
+комплексных числа
+```py
+>>> k1=(2+1j)
+>>> k2=(1+2j)
+>>> k1+k2
+(3+3j)
+>>> k2-k1
+(-1+1j)
+>>> k1*k2
+5j
+>>> k1/k2
+(0.8-0.6j)
+>>> k1**k2
+(-0.42589434775182566+0.7753703444218832j)
+>>> k1//k2
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+>>>k1//2
+Traceback (most recent call last):
+  File "<pyshell#115>", line 1, in <module>
+    k1//2
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+>>> k1%k2
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+>>>k1%2
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+
+```
+## Пункт 5. Операции с двоичными представлениями целых чисел.
+
+## 5.1 Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0)
+```py
+>>> dv1=9
+>>> dv2=~dv1
+>>> dv2
+-10
+```
+## 5.2 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+```py
+>>> 7&9
+1
+>>> 7&8
+0
+```
+Проверим 
+```py
+>>> bin(7)
+'0b111'
+>>> bin(9)
+'0b1001'
+>>> bin(7&9)
+'0b1'
+```
+## 5.3  Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
+```py
+>>> 7|9  # 0111 или 1001 = 1111
+15
+>>> 7|8 # 0111 или 1000 = 1111
+
+15
+>>> 14|5 # 1110 или 0101 = 1111
+15
+>>> bin(15)
+'0b1111'
+```
+## 5.4.	Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+```py
+>>> 14^5  #1110 ^ 0101 = 1011
+11
+>>> bin(11)
+'0b1011'
+>>> bin(14)
+'0b1110'
+>>> bin(5)
+'0b101'
+```
+## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
+```py
+>>> h=14
+>>> bin(14)
+'0b1110'
+>>> g=h<<2
+>>> bin(g)
+'0b111000'
+>>> g1=h>>1
+>>> bin(g1)
+'0b111'
+>>> g2=h>>2
+>>> bin(g2)
+'0b11'
+```
+Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции.
+```py
+>>> bin(76)
+'0b1001100'
+>>> bin(112)
+'0b1110000'
+>>> 76&112
+64
+>>> bin(64)
+'0b1000000'
+>>> 76|112
+124
+>>> bin(124)
+'0b1111100'
+>>> 76^112
+60
+>>> g=76<<2
+>>> g
+304
+>>> bin(g)
+'0b100110000'
+```
+## 6. Операции при работе с последовательностями (строками, списками, кортежами).
+## 6.1.	 Объединение последовательностей (конкатенация)(+)
+```py
+>>>'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+>>>['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>>('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+## 6.2 Повторение (*)
+```py
+>>> 'ля-'*5
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+
+>>> ('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1=[0]*3+[1]*99
+>>> signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+>>> signal2=(0,)*3+(1,)*5+(0,)*7
+>>> signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+## 6.3.	 Проверка наличия заданного элемента в последовательности (in)
+```py
+>>> stroka='Система автоматического управления'
+>>> 'автомат' in stroka
+True
+>>> 'ку' in ['ку','-']*3
+True
+>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+```
+## 6.4.	Подстановка значений в строку с помощью оператора «%»
+```py
+>>> stroka='Температура=%g %s %g'
+>>> stroka
+'Температура=%g %s %g'
+>>> stroka % (16,' меньше ',25)
+'Температура=16  меньше  25'
+>>> stroka % (66,' меньше ',77)
+'Температура=66  меньше  77'
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+## 7. Оператор присваивания
+## 7.1. Обычное присваивание значения переменной (=)
+```py
+>>> zz=-12
+```
+## 7.2.	Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```py
+>>> zz+=5
+>>> zz
+-7
+>>> zz-=3
+>>> zz
+-10
+>>> stroka='Система'
+>>> stroka+=' регулирования'
+>>> stroka
+'Система регулирования'
+```
+## 7.3.	 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```py
+>>> zz/=2
+>>> zz
+-5.0
+>>> zz*=5
+>>> zz
+-25.0
+```
+## 7.4.	Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) 
+```py
+>>> zz//=2
+>>> zz
+-13.0
+>>> zz**=2
+>>> zz
+169.0
+>>> zz%=5
+>>> zz
+4.0
+```
+## 7.5. Множественное присваивание
+Присваивание одного значения нескольким переменным 
+```py
+>>> w=v=10
+>>> w
+10
+>>> v
+10
+```
+Присваивание кортежа
+```py
+>>> n1,n2,n3=(11,-3,'all')
+>>> n1,n2,n3
+(11, -3, 'all')
+```
+Присваивание списка 
+```py
+>>> a1,a2,a3=[1,2,3]
+>>> a1,a2,a3
+(1, 2, 3)
+```
+Присваивание словаря 
+```py
+>>> s1,s2,s3={'один':1,'два':2,'три':3}
+>>> s1,s2,s3
+('один', 'два', 'три')
+```
+Если необходимо присвоить значения, то это можно сделать через .values()
+```py
+>>> s1,s2,s3={'один':1,'два':2,'три':3}.values()
+>>> s1,s2,s3
+(1, 2, 3)
+```
+Если необходимо присвоить ключи и значения, то это можно сделать через .items()
+```py
+>>> f1,f2,f3={'один':1,'два':2,'три':3}.items()
+>>> f1,f2,f3
+(('один', 1), ('два', 2), ('три', 3))
+>>> f1
+('один', 1)
+>>> f2
+('два', 2)
+>>> f3
+('три', 3)
+```
+Присваивание множества
+```py
+>>> m1,m2,m3={0,89,6}
+>>> m1,m2,m3
+(0, 89, 6)
+```
+Присваивание строки
+```py
+>>> c1,c2,c3='1','2','3'
+>>> c1,c2,c3
+('1', '2', '3')
+```
+## 8. Логические операции (True или False)
+## 8.1.	Операции сравнение 
+```py
+>>> v==w
+True
+>>> v!=w
+False
+>>> v>w
+False
+>>> v<w
+False
+>>> v>=w
+True
+>>> v<=w
+True
+>>> 5==4
+False
+>>> 5!=4
+True
+>>> 5>4
+True
+>>> 5<4
+False
+>>> 5>=4
+True
+>>> 5<=4
+False
+```
+## 8.2. Проверка наличия заданного элемента в последовательности или во множестве, а также  про-верка наличия ключа в словаре (in).
+Операции с множеством 
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+```
+Операции со словарем
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> 'Vologda' in dic1
+True
+>>> 'Pskov' in dic1
+False
+>>> 56 in dic1.values()
+True
+```
+Ещё пример работы со словарем:
+```py
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>> 'UII' in dct1['Depart']
+True
+>>> dct1['Depart'][1] == 'MM'
+False
+```
+## 8.3. Создание больших логических выражений с использованием соединительных слов: логиче-ское «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not). 
+```py
+>>> a=17
+>>> b=-6
+>>> (a>=b)and('book' in mnoz1)and not('Pskov' in dic1 )
+True
+>>> (5==4)or(a==17)
+True
+>>> (5==4)and(a==17)
+False
+>>> ((5==4)and(a==17))or(not(5==4)and(a==17))
+True
+```
+## 8.4.	Проверка ссылок переменных на один и тот же объект (is).
+
+```py
+>>> w=v=10
+>>> w1=['A','B']
+>>> v1=['A','B']
+>>> w1==v2
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name 'v2' is not defined. Did you mean: 'v'?
+>>> w1==v1
+True
+>>> w1 is v1
+False
+>>> w is v
+True
+```
+Оператор is сравнивает адреса объектов в памяти. Целые числа из одной строки хранятся по одному адресу, поэтому is возвращает True. Словари же, созданные отдельно, размещаются в разных местах памяти, и is для них дает False.
+## Пункт 9. Операции с объектами, выполняемые с помощью методов.
+Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например,
+```py
+>>> stroka='Микропроцессорная система управления'
+>>> dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+## 9.1.	Методы для работы со строками
+```py
+>>> stroka.find('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+>>> stroka.count("с")  #Подсчет числа вхождений строки "с" в stroka
+4
+>>> stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  за-данный разделитель
+>>> spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()   #Возвращает строку со всеми заглавными буквами
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+>>> stroka3
+'Микропроцессорная система управления'
+>>> stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+```
+## Mетод format
+Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола.
+```py
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1
+'Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+```
+Здесь цифры в фигурных скобках – это индексы, определяющие порядок использования аргумен-тов формата. Поэтому такой способ называют основанным на позиционных аргументах. Например,
+```py
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+>>> strk3='Момент времени {num}, значение = {znch}'
+```
+Здесь в скобках указаны имена аргументов – вставок. Поэтому такой способ основан на имено-ванных аргументах.
+```py
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+## 9.2.	Методы для работы со списками. 
+```py
+>>> spsk = [1, (2, 3), 'hello Sergey Alexandrovich', 3.14 , 'pi']
+>>> spsk.pop(2) #Удаление элемента по индексу
+'hello Sergey Alexandrovich'
+>>> spsk.append('c') #Вставка элемента в конец
+>>> spsk
+[1, (2, 3), 3.14, 'pi', 'c']
+>>> spsk.insert(2,'a') #Вставка элемента в конкретное место по индексу
+>>> spsk
+[1, (2, 3), 'a', 3.14, 'pi', 'c']
+>>> spsk.count('a') #Подсчет количества элементов по значению
+1
+## 9.3. Mетоды кортежей
+У кортежей методов меньше, тк он являетя неизменяемым и методов на добавление/удаление объекта - нет
+```py
+>>> km2=(5,'пять', 5.55, 'мопсикии',4+1j)
+>>> km2.count(5)
+1
+>>> km2.index('мопсикии')
+3
+```
+## 9.4 Методы словарей
+```py
+>>> d={'key1':1, 'key2':2,'key3':3,'key4':4}
+Cоздание копии
+```py
+>>> d1=d.copy()
+>>> d1
+{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4}
+```
+Возвращение значения по ключу
+```py
+>>> d.get('key3')
+3
+```
+Возвращение кортежей из пар ключ-значение
+```py
+>>> d.items() 
+dict_items([('key1', 1), ('key2', 2), ('key3', 3), ('key4', 4)])
+```
+Возвращение объекта только из ключей
+```py
+>>> d.keys() 
+dict_keys(['key1', 'key2', 'key3', 'key4'])
+```
+Возвращение объекта только из значений
+```py
+>>> d.values() 
+dict_values([1, 2, 3, 4]) 
+```
+Добавление ключ-значения
+```py
+>>> d['key5']=5 
+>>> d
+{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
+```
+Удаление ключ-значения
+```py
+>>> d.pop('key1') 
+1
+>>> d
+{'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
+```
+Очищение словаря
+```py
+>>> d.clear()
+>>> d
+{}
+```
+
+## Методы множеств
+
+```py
+>>> mn={1,'dva',3.33}
+```
+Добавление элемента
+```py
+>>> mn.add(4)
+>>> mn
+{1, 3.33, 4, 'dva'}
+```
+Создание копии
+```py
+>>> cop=mn.copy()
+>>> cop
+{1, 3.33, 4, 'dva'}
+```
+Удаление элемента по значению
+```py
+>>> mn.remove(1)
+>>> mn
+{3.33, 4, 'dva'}
+```
+Удаление элемента по значению
+```py
+>>> mn.discard('dva')
+>>> mn
+{3.33, 4}
+```
+Очищение множества
+```py
+>>> mn.clear()
+>>> mn
+set()
+```
+Удаление и возвращение случайного элемента из множества
+```py
+>>> cop.pop()
+1
+>>> cop
+{3.33, 4, 'dva'}
+```
+Добавление элементов
+```py
+>>> cop.update({False,'t'})
+>>> cop
+{False, 3.33, 4, 't', 'dva'}
+```
+
+## Общее контрольное задание
+Преобразовать восьмеричное значение 45 в целое число.
+```py
+
+>>> octv = '45'
+>>> decv = int(octv, 8)
+>>> decv
+37
+```
+Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12,
+"постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и
+значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж
+от списка?
+```py
+>>> D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78}
+>>> keyD = list(D.keys())
+>>> keyD
+['усиление', 'запаздывание', 'постоянная времени']
+>>> valD = list(D.values())
+>>> valD
+[23, 12, 78]
+>>> tupD = (keyD, valD)
+>>> tupD
+(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
+
+```
+Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с
+округлением вниз, с определением после этого остатка от деления получившегося значения
+на 3 и затем возведения результата в степень 2.4.
+```py
+>>> ((1768 // 24.8) % 3) ** 2.4
+5.278031643091577
+```
+Напишите и выполните единое выражение, последовательно осуществляющее следующие
+операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее
+ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+```py
+>>> ((~(13 & 27)) ^ 14) << 2
+-32
+```
+Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки
+наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов
+этого списка.
+```py
+>>> lst = ["колебат"] * 4
+>>> lst[1] += lst[2]
+>>> lst
+['колебат', 'колебатколебат', 'колебат', 'колебат']
+>>> lst.pop(2)
+'колебат'
+>>> lst
+['колебат', 'колебатколебат', 'колебат']
+>>> 'аткол' in lst[1]
+True
+```
+ Определить список методов, доступных у ранее созданного словаря D. Поочередно
+использовать его методы keys и values, определить, что можно получить с применением
+этих методов.
+```py
+>>> D
+{'усиление': 23, 'запаздывание': 12, 'постоянная времени': 78}
+>>> 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])
+```
+#dict_keys и dict_values особые объекты, которые ссылаются на элементы исходного словаря.
+
+ Создать объект - символьную строку с текстом данного предложения. Из символьной строки
+создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в
+списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить
+получившийся список.
+```py
+>>> sen = "Создать объект - символьную строку с текстом данного предложения"
+>>> senl = sen.split()
+>>> senl
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> senl[senl.index("-")] = ","
+>>> senl
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> senl.remove("данного")
+>>> senl
+['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA4/26.1.md

@@ -0,0 +1,26 @@
+26) Напишите инструкцию определения и запоминания в переменной текущего московского ка-лендарного времени. Создайте список с 40 элементами – числами от 3 с шагом 6. Создайте кортеж с 12 элементами - случайным подмножеством из элементов списка. Создайте новый кортеж с элементами из первого кортежа, упорядоченными по убыванию величина. Рассчитайте сумму элементов второго кортежа, начиная с 4-го от начала и до 8-го. Отобразите ре-зультат на экране в виде «Сумма элементов кортежа = ХХХ». Определите, сколько времени в секундах прошло с начала выполнения задания
+```py
+>>> import time #начальное время
+>>> import random #начальное время для Москвы
+>>> start_time = time.time()
+>>> start_time
+1760354973.1996331
+>>> here = time.localtime()
+>>> here
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=14, tm_min=29, tm_sec=44, tm_wday=0, tm_yday=286, tm_isdst=0)
+>>> numbers_list = list(range(3, 3 + 40*6, 6)) #список с 40 элементами – числами от 3 с шагом 6
+>>> numbers_list
+[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99, 105, 111, 117, 123, 129, 135, 141, 147, 153, 159, 165, 171, 177, 183, 189, 195, 201, 207, 213, 219, 225, 231, 237]
+>>> random_tuple = tuple(random.sample(numbers_list, 12)) #кортеж с 12 элементами - случайным подмножеством из элементов списка 
+>>> random_tuple
+(189, 159, 153, 171, 219, 183, 201, 93, 237, 111, 165, 225)
+>>> r_tuple=tuple(sorted(random_tuple, reverse=True))  #сортировка в обратном порядке в кортеж
+>>> r_tuple
+(237, 225, 219, 201, 189, 183, 171, 165, 159, 153, 111, 93)
+>>> sum_elements = sum(r_tuple[3:8]) #суммa элементов второго кортежа
+>>> sum_elements
+909
+>>> end_time = time.time()
+>>> end_time
+1760355380.4714587
+```

TEMA4/26.md

@@ -0,0 +1,30 @@
+26.	Напишите инструкцию определения и запоминания в переменной текущего московского ка-лендарного времени. Создайте список с 40 элементами – числами от 3 с шагом 6. Создайте кортеж с 12 элементами - случайным подмножеством из элементов списка. Создайте новый кортеж с элементами из первого кортежа, упорядоченными по убыванию величина. Рассчитайте сумму элементов второго кортежа, начиная с 4-го от начала и до 8-го. Отобразите ре-зультат на экране в виде «Сумма элементов кортежа = ХХХ». Определите, сколько времени в секундах прошло с начала выполнения задания.
+импорт библиотек
+```py
+>>> import time
+>>> import random
+```
+```py
+>>> start_time = time.time() #начальное время
+>>> here = time.localtime() #начальное время для Москвы
+>>> here
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=14, tm_min=12, tm_sec=58, tm_wday=0, tm_yday=286, tm_isdst=0)
+>>> start_time  
+1760353951.7821183
+>>> numbers_list = list(range(3, 3 + 40*6, 6)) #список с 40 элементами – числами от 3 с шагом 6
+>>> numbers_list
+[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99, 105, 111, 117, 123, 129, 135, 141, 147, 153, 159, 165, 171, 177, 183, 189, 195, 201, 207, 213, 219, 225, 231, 237]
+>>> reverse_tuple = tuple(sorted(numbers_list, reverse=True)) #сортировка в обратном порядке в кортеж
+>>> reverse_tuple
+(237, 231, 225, 219, 213, 207, 201, 195, 189, 183, 177, 171, 165, 159, 153, 147, 141, 135, 129, 123, 117, 111, 105, 99, 93, 87, 81, 75, 69, 63, 57, 51, 45, 39, 33, 27, 21, 15, 9, 3)
+>>> sum_elements = sum(sorted_kortezh[3:8]) 
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name 'sorted_kortezh' is not defined
+ 
+>>> sum_elements = sum(reverse_tuple[3:8]) #рассчитайте сумму элементов второго кортежа
+>>> sum_elements
+1035
+>>> end_time = time.time() #финальное время
+>>> end_time
+1760354435.6719537

TEMA4/lab4.md

@@ -0,0 +1,748 @@
+### Отчет тема 4 
+## Пункт 2 Стандартные функции (модуль builtins, импортированный по умолчанию)
+## Пункт 2.1
+round() - округление с заданной точностью
+```py
+>>> help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+    
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+```
+```py
+>>> round(123.456,1)
+123.5
+>>> type(round(123.456,1))
+<class 'float'>
+```
+```py
+>>> round(123.456,0)
+123.0
+>>> type(round(123.456,0))
+<class 'float'>
+```
+```py
+>>> round(123.456)
+123
+>>> type(round(123.456))
+<class 'int'>
+```
+Если ndigits не указан, функция возвращает округленное целое число.
+Если указано, то число с плавающей точкой
+
+## Пункт 2.2
+Функция range создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+```py
+>>> gg=range(76,123,9)
+>>> gg
+range(76, 123, 9)
+>>> type(gg)
+<class 'range'>
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+```
+Можно и не задавать шаг
+```py
+>>> range(23)
+range(0, 23)
+>>> list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+## Пункт 2.3 zip – создание общего объекта, элементами которого являются кортежи, составленные из  эле-ментов двух или более объектов-последовательностей 
+```py
+>>> qq = ['Цветкова', 'Снегура','Зеленкина']
+>>> ff=zip(gg,qq)
+>>> ff
+<zip object at 0x000001903C06A5C0>
+>>> tuple(ff)
+((76, 'Цветкова'), (85, 'Снегура'), (94, 'Зеленкина'))
+>>> ff[0]
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'zip' object is not subscriptable
+```
+```py
+>>> ff[1]
+Traceback (most recent call last):
+  File "<pyshell#34>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+Объект класса zip неизменяемый.
+
+## Пункт 2.4. Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки.
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=5
+>>> dan
+-131.0
+>>> fff
+5.0
+```
+eval() — Это встроенная функция в Python, которая выполняет строку кода как программу. 
+Как работает:
+1)Компилирует строку в байт-код 
+2)Выполняет этот байт-код в заданном контексте 
+## Пункт 2.5. Похожая на eval функция exec – чтение и выполнение объекта-аргумента функции. Этот объ-ект должен представлять собой строку символов  с совокупностью инструкций на языке Python.
+```py
+>>> exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>> gg
+221.456
+Пояснение:
+    eval превращает текст в работающий код
+    exec может выполнять любой код, но не возвращает значение.
+## Пункт 2.6. Самостоятельно изучите и попробуйте применить функции abs, pow, max, min, sum, divmod, len, map. 
+```py
+Возведение модуля (abs)
+```py
+>>> abs(-5)
+5
+>>> abs(5+5j)
+7.0710678118654755
+>>> abs(4**(-10))
+9.5367431640625e-07
+>>> abs(-4**10)
+1048576
+>>> abs(-4**(-10))
+9.5367431640625e-07
+```
+Возведение степени
+```py
+>>> pow(5,2)
+25
+>>> pow(-5,-2)
+0.04
+>>> pow(5,4,2)
+1
+>>> pow(5+5j,2)
+50j
+```
+Максимальное значение
+
+```py
+>>> max(2,5.8,7)
+7
+>>> max([4,0,-7])
+4
+>>> max({'a': 1, 'b': 2, 'c': 3}) #выбор большего происходит из ключей
+'c'
+>>> max(["ee", "eee", "eeeeeee"], key = len)
+'eeeeeee'
+>>> max("b", "B") #сравнивает коды символов в unicode
+'b'
+>>> max([34,5,6, "e", 5+2j])
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: '>' not supported between instances of 'str' and 'int'
+```
+Видно что с разными типами данных не работает
+
+Минимальное значение
+```py
+>>> min(2,5.8,7)
+2
+>>> min(({'a': 1, 'b': 2, 'c': 3})) #по ключу
+'a'
+>>> min(-7,-6,abs(-8))
+-7
+```
+Сумма элементов 
+```py
+>>> sum([1,2,3,4])
+10
+>>> sum([1,2,3,4], -2)
+8
+```
+```py
+>>> sum("bbbb", "аааа")
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: sum() can't sum strings [use ''.join(seq) instead]
+>>> sum(5+5j,3)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'complex' object is not iterable
+>>> sum(5+5j,5+5j)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'complex' object is not iterable
+>>> sum(4.5,5)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'float' object is not iterable
+>>> sum(4.5,4.5)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'float' object is not iterable
+```
+Возвращение кортежа из целой части и остатка от деления
+```py
+>>> help(divmod)
+Help on built-in function divmod in module builtins:
+divmod(x, y, /)
+    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
+>>> divmod(20,3)  
+(6, 2)            #20 // 3 = 6 (целая часть)   20 % 3 = 2 (остаток)
+>>> divmod(20,-3)
+(-7, -1)          20 ÷ (-3) = -6.666... округляем вниз -7    20 % -3 = 1 
+```
+
+Длина объекта
+```py
+>>> len((1,2,2))
+3
+>>> len("aaaaaaaaaa")
+10
+>>> len(["aaaa","ddddddddddd"])
+2
+>>> len({'a': 1, 'b': 2, 'c': 3})
+3
+>>> len(12)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: object of type 'int' has no len()
+```
+Применение функции к каждому элементу коллекции
+```py
+>>> help(map)
+Help on class map in module builtins:
+class map(object)
+ |  map(func, *iterables) --> map object
+ |  
+ |  Make an iterator that computes the function using arguments from
+ |  each of the iterables.  Stops when the shortest iterable is exhausted.
+
+>>> map(int, ["1", "2"])
+<map object at 0x000001903C2BB5E0>
+>>> list(map(int, ["1", "2"]))
+[1, 2]
+```
+Останавливается когда самая короткая коллекция заканчивается
+"Лишние" элементы из более длинных коллекций игнорируются
+
+## Пункт 3 Стандартный модуль math
+```py
+>>> 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
+```
+Нахождение синуса
+```py
+>>> 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/2)
+1.0
+>>> math.sin(0.96)
+0.8191915683009983
+```
+Нахождение арккосинуса
+```py
+>>> math.acos(1)
+0.0
+>>> math.acos(-1)
+3.141592653589793
+>>> math.acos(-0.54)
+2.1412334361948187
+>>> math.acos(5)   #больше 1 нельзя
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ValueError: math domain error
+```
+Перевод из радиан в градусы
+```py
+>>> help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+>>> math.radians(math.pi)
+0.05483113556160755
+
+>>> math.radians(360)
+6.283185307179586
+
+>>> math.radians(90)
+1.5707963267948966
+```
+
+Число е в степени заданного
+```py
+>>> help(math.exp)
+Help on built-in function exp in module math:
+exp(x, /)
+    Return e raised to the power of x.
+>>> math.exp(0)
+1.0
+>>> math.exp(1)
+2.718281828459045
+>>> math.exp(-5)
+0.006737946999085467
+>>> math.exp(1/2)
+1.6487212707001282
+```
+Нахождение логарифма
+```py
+>>> 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(math.e)
+1.0
+>>> math.log(5)
+1.6094379124341003
+>>> math.log(25,5)
+2.0
+>>> math.log(-25,5)           #с отрицательными числами не работает
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ValueError: math domain error
+>>> math.log(25,-5)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ValueError: math domain error
+```
+Десятичный логарифм
+```py
+>>> math.log10(10)
+1.0
+>>> math.log10(0.01)
+-2.0
+```
+Извлечение квадратного корня
+```py
+>>> math.sqrt(25)
+5.0
+>>> math.sqrt(26)
+5.0990195135927845
+>>> math.sqrt(26.7)
+5.167204273105526
+>>> math.sqrt(-25)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ValueError: math domain error
+>>> math.sqrt(26.7+7j)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: must be real number, not complex
+```
+Округление числа до ближайшего целого вверх
+```py
+>>> 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(1.2)
+2
+>>> math.ceil(9.99)
+10
+>>> math.ceil(-6.2)
+-6
+>>> math.ceil(-6.9)
+-6
+```
+Округление вниз
+```py
+>>> math.floor(1.2)
+1
+>>> math.floor(9.99)
+9
+>>> math.floor(-6.2)
+-7
+>>> math.floor(-6.9)
+-7
+>>> math.floor(-6.9+5j)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: must be real number, not complex
+```
+Константа: число пи
+```py
+>>> math.pi
+3.141592653589793
+```
+комбинированное использование
+```py
+>>> math.sin(2 * math.pi / 7 + math.exp(0.23))
+0.8334902641414562
+```
+## Пункт 4 Модуль cmath для работы с комплексными числами
+```py
+>>> import cmath
+>>> dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+>>> cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+>>> cmath.phase(1-0.5j)
+-0.4636476090008061
+```
+## Пункт 5 Модуль random для генерации псевдослучайных чисел и работы с ними
+```py
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>> help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+    If *a* is an int, all bits are used.
+
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+>>> random.seed()
+```
+```py
+>>> help(random.random)
+Help on built-in function random:
+
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+```
+Случайное число от 0 до 1
+```py
+>>> random.random()
+0.23002075073724337
+>>> random.random()
+0.535712008113208
+>>> random.random()
+0.4738049347613569
+>>> 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.
+```
+Равномерно распределенное случайное число
+```py
+>>> random.uniform(20,30)
+22.41214721441803
+```
+Равномерное случайное целое
+```py
+>>> 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(20,30)
+21
+>>> random.randint(20,30)
+27
+```
+Случайное из коллекции
+```py
+>>> 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([ъъъ, "уууууууe", 80, 7, 5+5j])
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name 'ъъъ' is not defined
+>>> random.choice(["ffff", "уууууууe", 80, 7, 5+5j])
+80
+>>> random.choice(["ffff", "уууууууe", 80, 7, 5+5j])
+(5+5j)
+```
+
+Нормально распределенное случайное число
+```py
+>>> help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu=0.0, sigma=1.0) method of random.Random instance
+    Gaussian distribution.
+
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+
+    Not thread-safe without a lock around calls.
+
+>>> random.gauss(0,1)
+-0.43812614222540897
+>>> random.gauss(7,8)
+11.287669776968896
+```
+Случайное подмножество
+```py
+>>> 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.
+
+    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)
+
+>>> lst=('a','b','c')
+>>> random.sample(lst, 2)
+['a', 'c']
+>>> random.sample(lst, 0)
+[]
+>>> random.sample(list, 7)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.11_3.11.2544.0_x64__qbz5n2kfra8p0\Lib\random.py", line 439, in sample
+    raise TypeError("Population must be a sequence.  "
+TypeError: Population must be a sequence.  For dicts or sets, use sorted(d).
+```
+Случайное число, подчиняющееся бета-распределению
+```py
+>>> 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(3,4)
+0.4104754948305531
+>>> random.betavariate(3,4)
+0.4104754948305531
+```
+Случайное число, подчиняющееся гамма-распределению
+```py
+>>> 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(3,4)
+18.75253913135498
+```
+Список из четырех чисел с разными законами распределения:
+```py
+>>> rd=[random.uniform(3,4),random.gauss(3,4),random.betavariate(3,4),random.gammavariate(3,4)]
+>>> rd
+[3.9065412706472173, 5.093585831129117, 0.423027969366889, 7.115102862880251]
+```
+## Пункт 6 time - модуль для работы со временем
+```py
+>>> import time
+>>> dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+```
+UNIX-время
+```py
+>>> c1=time.time()
+>>> c1
+1760272978.995956
+>>> c2=time.time()-c1
+>>> c2
+12.162038326263428
+```
+Текущее время
+```py
+>>> time.gmtime
+<built-in function gmtime>
+>>> help(time.gmtime)
+Help on built-in function gmtime in module time:
+
+gmtime(...)
+    gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,
+                           tm_sec, tm_wday, tm_yday, tm_isdst)
+
+    Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.
+    GMT).  When 'seconds' is not passed in, convert the current time instead.
+
+    If the platform supports the tm_gmtoff and tm_zone, they are available as
+    attributes only.
+
+>>> dat=time.gmtime()
+>>> list(dat)
+[2025, 10, 12, 12, 44, 15, 6, 285, 0]
+>>> dat.tm_year
+2025
+>>> dat.tm_yday
+285
+>>> dat.tm_isdst #Показывает, действует ли летнее время (0 - нет, 1 - да, -1 - нет данных)
+0
+```
+Текущее время с учетом часового пояса
+```py
+>>> here = time.localtime()
+>>> here
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=15, tm_min=44, tm_sec=59, tm_wday=6, tm_yday=285, tm_isdst=0)
+```
+Время из кортежа в строку
+```py
+>>> time.asctime(here)
+'Sun Oct 12 15:44:59 2025'
+```
+Время из секунд в строку
+```py
+>>> time.ctime()
+'Sun Oct 12 15:46:30 2025'
+```
+Пауза
+```py
+>>> time.sleep(5)
+```
+Из кортежа в секунды с начала эпохи
+```py
+>>> time.mktime(here)
+1760273099.0
+```
+## Пункт 7 Графические функции модуля pylab пакета matplotlib
+```py
+>>> import matplotlib
+>>> import pylab
+
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+
+>>> pylab.plot(t,x)  #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x00000158D9921670>]
+
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+
+>>> pylab.show()
+```
+Два графика на одном окне
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1) #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x000001905007A090>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000019050064D90>]
+>>> pylab.show()
+```
+
+Круговая диаграмма:
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x00000158DBCC8820>, <matplotlib.patches.Wedge object at 0x00000158DBCC8760>, <matplotlib.patches.Wedge object at 0x00000158DBCC8FD0>, <matplotlib.patches.Wedge object at 0x00000158DBCDE490>], [Text(-0.1910130855889933, 1.083288512416601, 'Центр'), Text(-0.8613283319035216, -0.6841882085072037, 'Урал'), Text(0.04429273729355889, -1.0991078898011077, 'Сибирь'), Text(0.9873752043868569, -0.4848610169543564, 'Юг')])
+>>> pylab.show()
+```
+Гистограмма:
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>> naselen=[65,12,23,17]  # Значения для диаграммы
+>>> pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x000001904BFBD350>, <matplotlib.patches.Wedge object at 0x000001904F822550>, <matplotlib.patches.Wedge object at 0x000001904F83E5D0>, <matplotlib.patches.Wedge object at 0x000001904F83FC50>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()  #Отображение диаграммы
+```
+Столбиковая диаграмма:
+```py
+>>> a=['cat','dog','frog']
+>>> v=[10,55,100]
+>>> pylab.bar(a,v,color='purple')
+<BarContainer object of 3 artists>
+>>> pylab.show()
+```
+## Пункт 8
+
+Статистический модуль statistics
+```py
+>>> import statistics
+>>> dir(statistics)
+['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_mean_stdev', '_normal_dist_inv_cdf', '_sqrt_bit_width', '_ss', '_sum', 'bisect_left', 'bisect_right', 'correlation', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'mul', 'multimode', 'namedtuple', 'numbers', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sqrt', 'stdev', 'sys', 'tau', 'variance']
+```
+Математическое ожидание
+```py
+>>> data = [0,11,8,5]
+>>> statistics.mean(data)
+6
+```
+Медиана
+```py
+>>> statistics.median(data)
+6.5
+```
+Среднеквадратичное отклонение
+```py
+>>> statistics.stdev(data)
+4.69041575982343
+```
+Дисперсия
+```py
+>>> statistics.variance(data)
+22
+```
+Квантили
+```py
+>>> statistics.quantiles(data)
+[1.25, 6.5, 10.25]
+```

TEMA4/o.md

@@ -0,0 +1,59 @@
+
+
+ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ
+
+•   Напишите и исполните единое выражение, реализующее последовательное выполнение
+следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата
+до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из
+двух значений: округленное вниз значение от деления результата на 3 и остатка от этого
+деления
+
+>>> divmod((round(cmath.phase(0.2 + 0.8j), 2) * 20), 3)
+(8.0, 2.6000000000000014)
+
+•   Создайте объект класса struct_time с временными параметрами для текущего
+московского времени. Создайте строку с текущим часом и минутами.
+
+>>> nowtime = time.localtime()
+>>> nowtime
+time.struct_time(tm_year=2024, tm_mon=9,
+tm_mday=30, tm_hour=1, tm_min=44, tm_sec=10, tm_wday=0, tm_yday=274, tm_isdst=0)
+>>> nows = str(nowtime.tm_hour) + " " + str(nowtime.tm_min)
+>>> nows
+'1 44'
+
+•   Создайте список с элементами – названиями дней недели. Сделайте случайную выборку
+из этого списка с тремя днями недели.
+
+>>> week = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
+>>> random.sample(week, 3)
+['вторник', 'суббота', 'четверг']
+
+•   Напишите инструкцию случайного выбора числа из последовательности целых чисел от
+14 до 32 с шагом 3.
+
+>>> random.choice(range(14, 32, 3))
+26
+>>> random.choice(range(14, 32, 3))
+14
+
+•   Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и
+стандартным отклонением 4 и округлите его до целого значения. Создайте список с N
+элементами – случайно выбранными буквами латинского алфавита.
+
+>>> N = round(random.gauss(15,4))
+>>> N
+13
+>>> lst = list("abcdefghijgklmnopqrstuvwxyz")
+>>> random.sample(lst, N)
+['i', 'g', 'g', 'j', 't', 's', 'r', 'v', 'f', 'y', 'b', 'z', 'l']
+
+Или в одну строку:
+>>> random.sample(list("abcdefghijgklmnopqrstuvwxyz"), round(random.gauss(15,4)))
+['l', 'u', 'z', 'g', 't', 'd', 'f', 'e', 'm', 'k']
+
+•   Напишите инструкцию для определения временного интервала в минутах, прошедшего с
+момента предыдущего (из п.2) определения временных параметров.
+
+>>> (time.mktime(nowtime) - time.mktime(time.localtime())) / 60
+-27.216666666666665

TEMA5/17.md

@@ -0,0 +1,27 @@
+17.	Создайте список с 20 комплексными числами, у которых вещественная и мнимая части – слу-чайные, нормально распределенные числа с математическим ожиданием 15 и стандартным отклонением 8. Рассчитайте среднее значение фаз по элементам множества и отобразите ре-зультат с округлением до 2-х знаков после точки в виде строки вида: «Среднее фаз = ХХХ.ХХ».
+```py
+>>> import random
+>>> import math
+>>> import cmath
+# Создаем список с 20 комплексными числами
+>>> compl_n=[]
+>>> for _ in range(20):
+	# Генерируем вещественную и мнимую части с нормальным распределением
+...     p1=random.gauss(15,8)  # мат. ожидание = 15, стандартное отклонение = 8
+...     p2=random.gauss(15,8)  # мат. ожидание = 15, стандартное отклонение = 8
+...     c=complex(p1,p2)
+...     compl_n.append(c)
+...
+# Рассчитываем фазы для каждого комплексного числа
+>>> phases=[]
+>>> for n in compl_n:
+...     phase = cmath.phase(n)
+...     phases.append(phase)
+...
+# Вычисляем среднее значение фаз
+>>> average_phase = sum(phases) / len(phases)
+#Округляем до 2-х знаков после точки
+>>> result = f"Среднее фаз = {average_phase:.2f}"
+>>> result
+'Среднее фаз = 0.92'
+```

TEMA5/Lab5.md

@@ -0,0 +1,432 @@
+### Отчет тема 5
+## Пункт 2. Изучите ветвление по условию – управляющая инструкция if. 
+Общий вид выглядит так:
+
+```py
+if <условие>:
+<отступы> <Блок инструкций, выполняемый, если условие истинно>
+      [elif <условие2>:
+<отступы><Блок инструкций2, выполняемый, если условие2 истинно>
+]
+[else:
+< отступы><Блок инструкций3, выполняемый, если условие ложно>
+]
+```
+Причем elif и else вместе или по отдельности могут отсуствовать.
+
+Пример
+```py
+>>> prog=4
+>>> rashod1 = 8
+>>> rashod2 = 5
+>>> if rashod1 >= prog:
+...     dohod=12
+... elif rashod2==prog:
+...     dohod=0
+... else:
+...     dohod=8
+...
+>>> dohod
+12
+```
+Посмотрим другой цикл 
+```py
+>>> rashod2 = 4
+>>> porog = 4
+>>> if rashod1>=3 and rashod2==4:
+...     dohod=rashod1
+...     if rashod2==porog or rashod1<rashod2:
+...             dohod=porog
+...
+>>> dohod
+4
+```
+И ещё одна операция с множественным ветвлением линий потока:
+```py
+>>> if porog==3:
+...     dohod=1
+... elif porog==4:
+...     dohod=2
+... elif porog==5:
+...     dohod=3
+... else:
+...     dohod=0
+...
+>>> dohod
+2
+```
+Еще одна форма записи условных управляющих инструкций - тернарный оператор (от лат. "тройной"):
+<Объект> = <значение 1> if <условие>  else <значение 2>
+или ещё:
+```py
+if <условие>: <инструкция1>[;<инструкция2>….]
+```
+```py
+>>> dohod=2 if porog>=4 else 0
+>>> dohod
+2
+```
+Эквивалент
+```py
+if porog >= 4:
+    dohod = 2
+else:
+    dohod = 0
+```
+Если в блоке инструкций всего одна строка, можно записать всё в одну строку:
+```py
+>>> porog = 2
+>>> if porog >= 5 : rashod1 = 6; rashod2 = 0
+...
+>>> rashod1
+8
+>>> rashod2
+4
+```
+Тк условие не было выполнено рассмотрим другой пример 
+```py
+>>> porog = 7
+>>> if porog >= 5 : rashod1 = 6; rashod2 = 0
+...
+>>> rashod1
+6
+>>> rashod2
+0
+```
+## Пункт 3. Цикл по перечислению (for)
+
+Общее правило написания:
+```py
+for <Объект-переменная цикла> in <объект>:
+<отступы><Блок инструкций 1 – тело цикла>
+[else: 
+< отступы ><Блок инструкций 2 – если  в цикле не сработал break>]
+```
+Здесь <объект> - любой определенный до начала цикла объект из классов строка, список, кортеж, множество, словарь. <Объект-переменная цикла> - объект, в качестве значений которого пооче-редно будут задаваться элементы объекта, которые могут быть объектами любого типа. <Блок инструкций 1 – тело цикла> - совокупность инструкций, которая может содержать или не содер-жать инструкцию break, вызывающую досрочное завершение цикла при некоторых условиях.  Блок инструкций 1 обычно выполняется многократно по мере того, как объект-переменная цикла принимает значения из сложного объекта. Если в цикле имеется необязательная часть: else и Блок инструкций 2, то он будет выполняться перед завершением цикла только в том случае, если при выполнении цикла не было его прерывания по инструкции break.
+Если Блоке инструкций 1 или в Блоке инструкций 2 только одна инструкция, то её можно запи-сывать без отступов сразу за двоеточием.
+
+## 3.1. Простой цикл.
+```py
+>>> temperatura=5
+>>> for i in range(3,18,3):
+...     temperatura+=i
+...
+>>> temperatura
+50
+```
+## 3.2.	 Более сложный цикл
+```py
+>>> sps=[2,15,14,8]
+>>> for k in sps:
+...     if len(sps)<=10:sps.append(sps[0])
+...     else:break
+...
+>>> sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+```
+Как видно, в конец цикла добавляется двойка до тех пор, пока длина не превысит 10. Важно
+понимать, что sps - это и объект, по которому проходит k, и объект, изменяющийся
+внутри цикла. То есть k будет двигаться по циклу бесконечно, и выполнение останавливается
+именно из-за условия if - else.
+(При этом else в данном случае относится к if, а не к for (это можно понять не только по
+смыслу, но и по табуляции)
+
+Рассмотрим другой вариант:
+```py
+>>> sps=[2,15,14,8]
+>>> for k in sps[:]:
+...     if len(sps)<=10:sps.append(sps[0])
+...     else:break
+...
+>>> sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+
+```
+Как видно, итог другой, и вот почему. Операция взятия среза sps[:] создает полную копию
+исходного списка (грубо говоря, срез от начала до конца включительно).
+Теперь список, по которому пробегается k, и список, изменяющийся внутри цикла - это объекты,
+имеющие разные адреса. Это можно проверить:
+```py
+>>> id(sps)
+1684034116672
+>>> id(sps[:])
+1684069134400
+```
+
+## Пункт 3.3
+```py
+>>> sps5=[]
+>>> for i in range(10):
+...     sps5.append(rn.randint(1,100))
+...     ss=sum(sps5)
+...     if ss>500: break
+... else:
+...     print(ss)
+...
+```
+Программа ничего не вывела. Посмотрим, почему именно:
+```py
+>>> sps5
+[89, 38, 86, 57, 21, 44, 43, 32, 13, 88]
+>>> ss
+511
+>>> sps5 = []
+>>> for i in range(10):
+...     sps5.append(rn.randint(1,100))
+...     ss = sum(sps5)
+... else:
+...     print(ss)
+...
+517
+>>> sps5
+[11, 75, 48, 46, 3, 67, 78, 92, 63, 34]
+```
+В этот раз программа вывела ответ самостоятельно, потому что сработал else, потому что
+за все десять итераций цикла так и не успел выполниться break по условию if.
+
+## Пункт 3.4. Пример с символьной строкой
+```py
+>>> stroka='Это - автоматизированная система'
+>>> stroka1=""
+>>> for ss in stroka:
+...     stroka1+=" "+ss
+...
+>>> stroka
+'Это - автоматизированная система'
+>>> stroka1
+' Э т о   -   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+Переменная ss проходит по всему строковому объекту, на каждой итерации принимая значение
+одного знака. Этот знак с предшествующим пробелом дописывается в конец другой, изначально
+пустой строки. Цикл закончится, когда закончится исходная строка.
+
+## 3.5.	 Запись цикла в строке. Пример: создание списка с синусоидальным сигналом.
+```py
+>>> 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]
+```
+
+Эту синусоиду можно отобразить на графике:
+```py
+>>> import pylab
+>>> pylab.plot(sps2, label='Синусоидальный сигнал', color = 'green')
+[<matplotlib.lines.Line2D object at 0x000002B914A005D0>]
+>>> pylab.show()
+```
+График прикреплен отдельным файлом Figure_1.png
+
+![](Figure_1.png)
+
+## Пункт 4. Цикл "пока истинно условие" (while)
+
+Общий вид:
+```py
+while <Условие>:
+<отступы><Блок инструкций 1 – тело цикла>
+[else:
+<отступы><Блок инструкций 2 – если в цикле не сработал break>]
+```
+break и else работают аналогично предыдущему случаю.
+## 4.1. Цикл со счетчиком.
+```py
+>>> rashod=300
+>>> while rashod:
+...     print("Расход=",rashod)
+...     rashod-=50
+...
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Как именно произошло завершение цикла? Нужно вспомнить, что все числа, кроме нуля, при
+конвертации в логический тип данных имеют логическое значение True:
+```py
+>>> bool(50)
+True
+```
+
+И только нуль имеет значение False:
+```py
+>>> bool(0)
+False
+```
+Сравниваемая в управляющей инструкции переменная уменьшается в самом цикле, поэтому, когда
+строка со сравнением обнаружит 0, то воспримет это как False, и действия по выводу
+и уменьшению числа выполняться больше не будут.
+## Пункт 4.2. Пример с символьной строкой
+```py
+>>> import math
+>>> stroka='Расчет процесса в объекте регулирования'
+>>> i=0
+>>> sps2=[]
+>>> while i<len(stroka):
+...     r=1-2/(1+math.exp(0.1*i))
+...     sps2.append(r)
+...     print('Значение в момент',i,"=",r)
+...     i+=1
+...
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+```
+У цикла 38 повторений, по числу элементов в строке, но на 1 меньше. На каждой итерации
+значение i на единицу меньше, чем в предыдущей.
+```py
+>>> pylab.plot(sps2, label='Сигнал выхода', color='red')
+[<matplotlib.lines.Line2D object at 0x000002B9191077D0>]
+>>> pylab.title("Сигнал на выходе инерционного звена")
+Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
+>>> pylab.show()
+```
+![](Figure_2.png)
+График прикреплен файлом Figure_2.png
+## Пункт 4.3. Определение, является ли число простым (делится только на самого себя или 1).
+```py
+>>> chislo = 267
+>>> kandidat = chislo // 2
+>>> while kandidat > 1:
+	if chislo % kandidat == 0:
+		print(chislo, ' имеет множитель ', kandidat)
+		break
+	kandidat -= 1
+else:
+	print(chislo, ' является простым!')
+
+	
+267  имеет множитель  89
+```
+
+Программа работает так: переменная kandidat отвечает за потенциальный делитель заданного
+числа. Изначально мы задаем половину от заданного числа, потому что у числа не может быть
+делителя большего, чем половина от него. Далее мы последовательно уменьшаем потенциальный
+множитель, каждый раз проверяя, получилось ли поделить без остатка. Если получилось, то
+число непростое, и цикл можно прекращать досрочно. Если цикл отработал до конца, не
+прервавшись, то число простое.
+
+Дополниим программу так, чтобы она проверяла все числа от 250 до 300.
+```py
+>>> chislo = [x for x in range (250, 301)]
+>>> for now in chislo:
+	kandidat = now // 2
+	while kandidat > 1:
+		if now % kandidat == 0:
+			print(now, ' имеет множитель ', kandidat)
+			break
+		kandidat -= 1
+	else:               #ОБЯЗАТЕЛЬНО относится не к if и не к for, а к while
+		print(now, " является простым!")
+
+		
+250  имеет множитель  125
+251  является простым!
+252  имеет множитель  126
+253  имеет множитель  23
+254  имеет множитель  127
+255  имеет множитель  85
+256  имеет множитель  128
+257  является простым!
+258  имеет множитель  129
+259  имеет множитель  37
+260  имеет множитель  130
+261  имеет множитель  87
+262  имеет множитель  131
+263  является простым!
+264  имеет множитель  132
+265  имеет множитель  53
+266  имеет множитель  133
+267  имеет множитель  89
+268  имеет множитель  134
+269  является простым!
+270  имеет множитель  135
+271  является простым!
+272  имеет множитель  136
+273  имеет множитель  91
+274  имеет множитель  137
+275  имеет множитель  55
+276  имеет множитель  138
+277  является простым!
+278  имеет множитель  139
+279  имеет множитель  93
+280  имеет множитель  140
+281  является простым!
+282  имеет множитель  141
+283  является простым!
+284  имеет множитель  142
+285  имеет множитель  95
+286  имеет множитель  143
+287  имеет множитель  41
+288  имеет множитель  144
+289  имеет множитель  17
+290  имеет множитель  145
+291  имеет множитель  97
+292  имеет множитель  146
+293  является простым!
+294  имеет множитель  147
+295  имеет множитель  59
+296  имеет множитель  148
+297  имеет множитель  99
+298  имеет множитель  149
+299  имеет множитель  23
+300  имеет множитель  150
+```
+## Пункт 4.4. Инструкция continue.
+
+Она используется, когда надо при определенном условии не завершить весь цикл, а завершить
+только текущую итерацию.
+
+Пример (вывести только нечетные числа):
+```py
+>>> n=[1,2,3,4,5,6,7,8,9,10]
+>>> for k in n:
+...     if k%2==0:
+...             continue
+...     print(k)
+...
+1
+3
+5
+7
+9
+```
+

TEMA5/task.md

@@ -0,0 +1,102 @@
+
+ ### ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ
+
+•   Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи)
+определите порядковый номер каждой буквы в английском алфавите.
+```py
+>>> text = "There is a house in New Orleans, They call The Rising Sun"
+>>> for now in range(len(text)):
+	low = text.lower()
+	letter = low[now]
+	if not letter in alphabet:
+		continue
+	else:
+		print("Буква ", letter, " имеет ", alphabet.index(letter) + 1,
+                      "порядковый номер в алфавите")
+
+Буква  t  имеет  20 порядковый номер в алфавите
+Буква  h  имеет  8 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  r  имеет  18 порядковый номер в алфавите
+...
+Буква  g  имеет  7 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  u  имеет  21 порядковый номер в алфавите
+Буква  n  имеет  14 порядковый номер в алфавите
+```
+•   Создайте список со словами из задания данного пункта. Для этого списка – определите,
+ есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о
+ нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с
+ отсутствующим словом).
+```py
+>>> text = """Создайте список со словами из задания данного пункта Для этого
+списка определите есть ли в нем некоторое заданное значение и выведите соответствующее
+сообщение либо о нахождении элемента либо о его отсутствии в списке проверить как с
+имеющимся так и с отсутствующим словом"""
+>>> lst = text.split(" ")
+>>> lst
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого',
+ 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и',
+ 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо',
+ 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и',
+ 'с', 'отсутствующим', 'словом']
+ 
+>>> target = "либо"
+>>> for now in lst:
+	if now == target:
+		print ("Слово есть")
+		break
+else:
+	print("Слова нет")
+
+Слово есть
+
+
+>>> target = "дом"
+>>> for now in lst:
+	if now == target:
+		print ("Слово есть")
+		break
+else:
+	print("Слова нет")
+
+Слова нет
+```
+
+•   Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в
+летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных
+списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции,
+позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние
+баллы по двум сессиям.
+```py
+>>> studs = ["Snegura", "Turov", "Zelenkina1", "Zelenkina2"]
+>>> summer_marks = [4.75, 4.13, 4.24, 4.32]
+>>> studs2 = ["Zelenkina1", "Turov", "Zelenkina2", "Snegura"]
+>>> winter_marks = [4.3, 4.23, 4.16, 4.82]
+
+>>> student = input("Введите фамилию: ")
+Введите фамилию: Zelenkina2
+>>> while student != "q":
+	if (student in studs) and (student in studs2):
+		sum_answer = summer_marks[studs.index(student)]
+		win_answer = winter_marks[studs2.index(student)]
+		print("Балл летом: ", sum_answer, "\nЗимой: ", win_answer, "\nСредний :",
+                    (sum_answer + win_answer)/2)
+	else:
+		print("Такого студента нет")
+	student = input("Введите фамилию (q для выхода): ")
+
+	
+Балл летом:  4.32
+Зимой:  4.16
+Средний : 4.24
+Введите фамилию (q для выхода): Snegura
+Балл летом:  4.75
+Зимой:  4.82 
+Средний : 4.78
+Введите фамилию (q для выхода): Tsvetkova
+Такого студента нет
+Введите фамилию (q для выхода): q
+```
+
+

TEMA6/7.md

@@ -0,0 +1,90 @@
+1) С помощью текстового редактора создайте текстовый файл с некоторым именем, в котором будет 4 строки и на каждой строке будет по 3 числа, разделенных запятыми.
+```py
+>>> import os
+>>> os.getcwd()
+'C:\\WINDOWS\\System32'
+>>> os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6')
+>>> f = 'data.txt'
+>>> fp = open(f, 'w')
+>>> fp.write("1, 2, 3\n")
+8
+>>> fp.write("4, 5, 6\n")
+8
+>>> fp.write("7, 8, 9\n")
+8
+>>> fp.close()
+>>> fp = open(f, 'r')
+>>> sod = fp.read()
+>>> fp.close()
+>>> print('Содержание лабы:')
+Содержание лабы:
+>>> print(sod)
+1, 2, 3
+4, 5, 6
+7, 8, 9
+```
+
+2) Запросите у пользователя и введите имя файла с данными для обработки. Обеспечьте вывод сообщения при вводе пустой строки и повторный ввод.
+```py
+>>> while True:
+...     f = input("Введите имя файла с данными для обработки: ")
+...     f_cl = f.strip() # Убираем пробелы в начале и конце строки
+...     if f_c != "":
+...         f = f_c
+...         break
+...     print("Ошибка: введена пустая строка. Повторите ввод.")
+...
+Введите имя файла с данными для обработки: 
+Ошибка: введена пустая строка. Повторите ввод.
+Введите имя файла с данными для обработки: data.txt
+>>> print(f) 
+data.txt
+```
+3) Введите данные из указанного файла и представьте их в виде списка.
+```py
+>>> f='data.txt'
+>>> numbers = []
+>>> fp = open(f, 'r')
+SyntaxError: invalid syntax
+>>> for line in fp:
+...     for num_str in line.strip().split(','): #убираем пробелы, разбиваем по запятым
+...             numbers.append(float(num_str))
+...
+>>> fp.close()
+>>> print(numbers)
+[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
+```
+
+4)	Рассчитайте по введенным данным среднее значение синусов элементов списка.
+```py
+>>> import math
+>>> s=[]
+>>> for number in numbers:
+...     ss=math.sin(number)
+...     s.append(ss)
+...     print(number)
+...
+1.0
+2.0
+3.0
+4.0
+5.0
+6.0
+7.0
+8.0
+9.0
+>>> sum_s=sum(s)
+>>> sum_s
+1.9552094821073802
+>>> count_s=len(s)
+>>> count_s
+9
+>>> sr=sum_s/count_s
+>>> sr
+0.21724549801193113
+```
+5)	Выведите рассчитанное значение на экран по шаблону: " По <число элементов в списке> элементам среднее синусов = <рассчитанное среднее>". При этом значение среднего должно быть округлено до двух знаков после точки.
+```py
+>>> print("По", count_s, "элементам среднее синусов =", round(sr, 2))
+```
+По 9 элементам среднее синусов = 0.22

TEMA6/lab6.md

@@ -0,0 +1,135 @@
+# Пункт 2. Вывод данных на экран дисплея.
+##Пункт 2.1. Вывод данных в командной строке.
+
+Эхо-вывод в терминал (не работает в файлах!)
+>>> stroka='Автоматизированная система управления'
+>>> stroka
+'Автоматизированная система управления'
+##Пункт 2.2 Вывод с использованием функции print
+>>> fff=234.5;gg='Значение температуры = '
+>>> print(gg, fff)
+Значение температуры =  234.5
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разде-литель его можно указать в отдельном аргументе sep, например,
+>>> print(gg, fff, sep='/')
+Значение температуры = /234.5
+После вывода автоматически осуществляется переход на другую строку. Если курсор надо оста-вить в той же строке, то следует использовать еще один аргумент, например,
+
+>>> print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+
+После end= надо указать какими символами должна закончиться выводимая строка или ука-зать пустую строку. Наоборот, если в какой-то момент требуется просто перейти на новую стро-ку, можно использовать такое обращение к функции:
+
+>>> print()
+
+Если текст большой, можно расположить его в несколько строк с использованием тройных кавычек
+>>> print(""" Здесь может выводиться
+... большой текст,
+... занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+
+Или переносить отдельные объекты, разделенные запятой:
+
+>>> print("Здесь может выводиться",
+...       "большой текст,",
+...       "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+
+Разница в том, что в первом случае тройные кавычки воспроизводят текст ровно так, как он был
+введен. В тексте были введены переносы строки, но они были введены не как символ \n, а
+в обычном человекопонятном виде. Тем не менее, при желании на них можно посмотреть:
+
+>> print(repr(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк"""))
+' Здесь может выводиться\nбольшой текст,\nзанимающий несколько строк'
+
+(Функция repr() показывает то, как объект видит python, а не человек, отображая все символы
+табуляции)
+Во втором случае три выводимых объекта-строки перечисленны через запятую, и это работает как
+обычный print(), разделяющий объекты с помощью пробелов, если не указано иное.
+
+## Пункт 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.
+>>> import sys
+>>> sys.stdout.write('Функция write')
+Функция write13
+>>> sys.stdout.write('Функция write\n')
+Функция write
+14
+
+Важно отметить, что функция выводит текст, но возвращает число. Это число - количество
+введенных символов, причем \n считается за один символ, а не за два.
+
+>>> type(sys.stdout.write("Функция write"))
+Функция write<class 'int'>
+
+Если вызвать эту функцию без аргументов, вернется ошибка:
+
+>>> sys.stdout.write()
+Traceback (most recent call last):
+...
+TypeError: write() missing 1 required positional argument: 's'
+
+Если сообщить пустую строку, то, соответственно, 0.
+
+>>> sys.stdout.write("")
+0
+
+## Пункт 3. Ввод данных с клавиатуры.
+>>> psw=input('Введите пароль:')
+Введите пароль:sewfx
+>>> psw
+'sewfx'
+>>> type(psw)
+<class 'str'>
+
+input() не воспринимает символы табуляции, считывая их как обычные строки. Более того, возможно
+такое:
+
+>>> input()
+dpdpdp\n
+'dpdpdp\\n'
+
+Так происходит из-за того, что input() считал все символы как символы, то есть "p", "d", ... "\",
+"n". Но при выводе в консоль внутри самой функции input() используется вышеупомянутое
+"техническое" отображение repr(). Оно всегда дублирует ("экранирует") бэкслеш, чтобы не дать
+python'у воспринять его как символ табуляции.
+
+
+>>> while True:
+...     znach=float(input('Задайте коэф. усиления= '))
+...     if znach<17.5 or znach>23.8:
+...             print('Ошибка!')
+...     else:
+...             break
+...
+Задайте коэф. усиления= 16
+Ошибка!
+Задайте коэф. усиления= 26.7
+Ошибка!
+Задайте коэф. усиления= 20
+
+
+>>> import math
+>>> print(eval(input('введите выражение для расчета=')))
+введите выражение для расчета=math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+
+Введенная через input() строка преобразуется в исполнительные инструкции с помощью eval(),
+они потом выполняются и результат выводится на экран. Строка имеет тип, соответствующий
+результату вычислений и задаваемый автоматически:
+>>> type(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = 2+3
+<class 'int'>
+
+>>> type(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+<class 'float'>
+
+# Пункт 4.  Ввод-вывод при работе с файлами.
+## Пункт 4.1. Функции для работы с путём к файлу.
+
+>>> import os
+>>> os.getcwd()
+'C:\\WINDOWS\\System32'

TEMA6/laba5.md

@@ -0,0 +1,624 @@
+# Пункт 2. Вывод данных на экран дисплея.
+## Пункт 2.1. Вывод данных в командной строке.
+
+Эхо-вывод в терминал (не работает в файлах!)
+```py
+>>> stroka='Автоматизированная система управления'
+>>> stroka
+'Автоматизированная система управления'
+```
+# Пункт 2.2 Вывод с использованием функции print
+```py
+>>> fff=234.5;gg='Значение температуры = '
+>>> print(gg, fff)
+Значение температуры =  234.5
+```
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разде-литель его можно указать в отдельном аргументе sep, например,
+```py
+>>> print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+После вывода автоматически осуществляется переход на другую строку. Если курсор надо оста-вить в той же строке, то следует использовать еще один аргумент, например,
+```py
+>>> print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+```
+После end= надо указать какими символами должна закончиться выводимая строка или ука-зать пустую строку. Наоборот, если в какой-то момент требуется просто перейти на новую стро-ку, можно использовать такое обращение к функции:
+```py
+>>> print()
+```
+Если текст большой, можно расположить его в несколько строк с использованием тройных кавычек
+```py
+>>> print(""" Здесь может выводиться
+... большой текст,
+... занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+```
+Или переносить отдельные объекты, разделенные запятой:
+```py
+>>> print("Здесь может выводиться",
+...       "большой текст,",
+...       "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+Разница в том, что в первом случае тройные кавычки воспроизводят текст ровно так, как он был
+введен. В тексте были введены переносы строки, но они были введены не как символ \n, а
+в обычном человекопонятном виде. Тем не менее, при желании на них можно посмотреть:
+```py
+>> print(repr(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк"""))
+' Здесь может выводиться\nбольшой текст,\nзанимающий несколько строк'
+```
+(Функция repr() показывает то, как объект видит python, а не человек, отображая все символы
+табуляции)
+Во втором случае три выводимых объекта-строки перечисленны через запятую, и это работает как
+обычный print(), разделяющий объекты с помощью пробелов, если не указано иное.
+
+## Пункт 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.
+```py
+>>> import sys
+>>> sys.stdout.write('Функция write')
+Функция write13
+>>> sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+Важно отметить, что функция выводит текст, но возвращает число. Это число - количество
+введенных символов, причем \n считается за один символ, а не за два.
+```py
+>>> type(sys.stdout.write("Функция write"))
+Функция write<class 'int'>
+```
+Если вызвать эту функцию без аргументов, вернется ошибка:
+```py
+>>> sys.stdout.write()
+Traceback (most recent call last):
+...
+TypeError: write() missing 1 required positional argument: 's'
+```
+Если сообщить пустую строку, то, соответственно, 0.
+```py
+>>> sys.stdout.write("")
+0
+```
+## Пункт 3. Ввод данных с клавиатуры.
+```py
+>>> psw=input('Введите пароль:')
+Введите пароль:sewfx
+>>> psw
+'sewfx'
+>>> type(psw)
+<class 'str'>
+```
+input() не воспринимает символы табуляции, считывая их как обычные строки. Более того, возможно
+такое:
+```py
+>>> input()
+dpdpdp\n
+'dpdpdp\\n'
+```
+Так происходит из-за того, что input() считал все символы как символы, то есть "p", "d", ... "\",
+"n". Но при выводе в консоль внутри самой функции input() используется вышеупомянутое
+"техническое" отображение repr(). Оно всегда дублирует ("экранирует") бэкслеш, чтобы не дать
+python'у воспринять его как символ табуляции.
+
+```py
+>>> while True:
+...     znach=float(input('Задайте коэф. усиления= '))
+...     if znach<17.5 or znach>23.8:
+...             print('Ошибка!')
+...     else:
+...             break
+...
+Задайте коэф. усиления= 16
+Ошибка!
+Задайте коэф. усиления= 26.7
+Ошибка!
+Задайте коэф. усиления= 20
+```
+```py
+>>> import math
+>>> print(eval(input('введите выражение для расчета=')))
+введите выражение для расчета=math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+Введенная через input() строка преобразуется в исполнительные инструкции с помощью eval(),
+они потом выполняются и результат выводится на экран. Строка имеет тип, соответствующий
+результату вычислений и задаваемый автоматически:
+```py
+>>> type(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = 2+3
+<class 'int'>
+```
+```py
+>>> type(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+<class 'float'>
+```
+# Пункт 4.  Ввод-вывод при работе с файлами.
+## Пункт 4.1. Функции для работы с путём к файлу.
+```py
+>>> import os
+>>> os.getcwd()
+'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6'
+>>> tsvetkova=os.getcwd()
+>>> print(tsvetkova)
+C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA6
+>>> print(type(tsvetkova))
+<class 'str'>
+```
+По умолчанию:
+```py
+>>> import os
+>>> os.getcwd()
+'C:\\WINDOWS\\System32'
+```
+Сменим директорию и посмотрим, что смена произошла:
+```py
+>>> os.chdir(r'C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA1')
+>>> os.getcwd()
+'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1'
+```
+Сменим директорию на верную:
+```py
+os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6')
+```
+познкомимся с другими командами модуля os
+```py
+>>>help(os.mkdir)
+Help on built-in function mkdir in module nt:
+
+mkdir(path, mode=511, *, dir_fd=None)
+    Create a directory.
+
+    If dir_fd is not None, it should be a file descriptor open to a directory,
+      and path should be relative; path will then be relative to that directory.
+    dir_fd may not be implemented on your platform.
+      If it is unavailable, using it will raise a NotImplementedError.
+
+    The mode argument is ignored on Windows. Where it is used, the current umask
+    value is first masked out.
+```
+Создание каталога (mkdir)
+```py
+>>> os.mkdir('lalala')
+>>> os.getcwd()
+'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6'
+>>> os.listdir()
+['.gitkeep', 'lab5.txt', 'lalala']
+```
+удаление папки
+```py
+>>> help(os.rmdir)
+Help on built-in function rmdir in module nt:
+
+rmdir(path, *, dir_fd=None)
+    Remove a directory.
+
+    If dir_fd is not None, it should be a file descriptor open to a directory,
+      and path should be relative; path will then be relative to that directory.
+    dir_fd may not be implemented on your platform.
+      If it is unavailable, using it will raise a NotImplementedError.
+```
+```py
+>>> os.rmdir('lalala')
+>>> os.listdir()
+['.gitkeep', 'lab5.txt']
+```py
+Одако, если мы будем находиться в самой папке, которую хотим удалить, то у нас это не получится и питон выведет ошибку. Чтобы это исправить необходимо сменить путь и выйти из папки. Можно использовать команду
+```py
+os.chdir('../')   # Поднимает нас на одну папку выше. ../../ - для двух папок и т.д.
+```
+Просмотр списка директории
+```py
+>>> os.listdir()
+['.gitkeep', 'lab5.txt']
+```
+Проверка существования каталога
+```py
+>>> help(os.path.isdir)
+Help on function isdir in module genericpath:
+
+isdir(s)
+    Return true if the pathname refers to an existing directory.
+```
+Функция isdir() модуля os.path возвращает True если путь path существует и является каталогом,
+False в противном случае.
+```py
+>>> os.path.isdir('gagagaga')
+False
+>>> os.mkdir('lalala')
+>>> os.path.isdir('lalala')
+True
+```
+Функция os.path.abspath() в Python преобразует путь, переданный в качестве аргумента, в
+абсолютный путь
+```py
+>>> fil=os.path.abspath("oplata.dbf")
+>>> fil
+'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\oplata.dbf'
+>>> fil=os.path.abspath("lalala")
+>>> fil
+'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\lalala'
+```
+Абсолютный путь — это полный путь к файлу или каталогу, начиная от
+корневого каталога системы, а не относительный путь (который зависит от текущего рабочего
+каталога)
+
+Если передать в os.path.abspath() несуществующий файл или каталог, функция не проверяет
+наличие этого файла в файловой системе. Она просто преобразует путь в абсолютный, не
+проверяя его существование.
+
+Отделение из абсолютного пути только каталога/только имени файла
+Функция os.path.dirname() из абсолютного пути выделяется путь доступа (от диска до последней
+папки). Функция os.path.basename(), наоборот, убирает из абсолютного пути все, кроме имени
+файла.
+
+Выделите путь доступа к файлу из строки, содержащей и этот путь, и имя файла  с помощью функции os.path.dirname
+```py
+>>> drkt = os.path.dirname(fil)
+>>> print(drkt)
+C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA6
+```
+Bыделить имя файла из этой строки с отбрасыванием пути можно с помощью функции os.path.basename
+```py
+>>> bsnm=os.path.basename(fil)
+>>> print(bsnm)
+lalala
+```
+Разделение на кортеж из пути и из имени файла
+```py
+>>> help(os.path.split)
+Help on function split in module ntpath:
+
+split(p)
+    Split a pathname.
+
+    Return tuple (head, tail) where tail is everything after the final slash.
+    Either part may be empty.
+```
+```py
+>>> os.path.split(fil)
+('C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6', 'lalala')
+>>> type(os.path.split(fil))
+<class 'tuple'>
+```
+Проверка существования любого объекта (пути или файла)
+```py
+>>> os.path.exists("D:/GAMES") # Такой каталог есть на ПК
+True
+>>> os.path.exists("D:/Arts")
+False
+>>> os.path.exists("D:/Games/Heavy Rain/unins000.exe") # Такой файл есть
+True
+>>> os.path.exists("D:/Games/Heavy Rain/unins00000.exe")
+False
+>>> os.path.isfile("D:/Games/Sid Meiers Civilization VI/unins000.exe") # Это есть и это файл
+True
+>>> os.path.isfile("D:/Games/Sid Meiers Civilization VI/")  # Это есть, но это не файл!
+False
+>>> os.path.isfile("D:/Games/sss.jpg") # Это файл, но это не существует
+False
+```
+## Пункт 4.2 	Общая схема работы с файлом
+Для обмена данными с файлом необходимо выполнить следующие операции:
+•	Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+•	Выполнение одной или нескольких операций обмена данными с файлом;
+•	Закрытие файла.
+
+4.3.	Открытие файла для записи или чтения данных – функция open.
+При открытии файла необходимо указать имя файлы (с путем, если он не в рабочем каталоге) и цель работы с ним. Для открытия используется функция open. Запросите помощь по этой функ-ции, обратите внимание на возможные аргументы этой функции.
+```py
+>>> fp = open(file = drkt+'\\zapis1.txt', mode='w')
+>>> type(fp)
+<class '_io.TextIOWrapper'>
+```
+Объект класса _io.TextIOWrapper - файловый объект для текстовых данных, имеющий ряд атрибутов
+и методов.
+```py
+>>> fp
+<_io.TextIOWrapper name='C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
+```
+Здесь перечислены атрибуты объекта:
+    name - абсолютный путь
+    mode - режим:
+        r - чтение
+        w - запись (если такой файл уже есть, его содержимое будет удалено, если нет,
+                    создается. Содержимое удаляется в момент открытия, а не в момент первой
+                    записи)
+        a - дозапись (в конец)
+        x - открывает для записи, но только если файл есть, иначе FileExistsError.
+        + - чтение и запись:
+            r+ - чтение и запись, файл должен существовать.
+            w+ - запись и чтение, файл создаётся или перезаписывается.
+            a+ - добавление и чтение, файл создаётся, если не существует.
+
+        rb, wb, ab, xb - все то же, но в бинарном режиме (читаются байты)
+
+    encoding - кодировка:
+        В Windows в консоли по умолчанию cp1251 или cp1252 в зависимости от языка системы.
+        В файлах чаще UTF-8
+        Linux, MacOS - UTF-8.
+    Еще есть атрибут-флаг closed: True, если файл закрыт, False, если открыт.
+```py
+>>> fp.closed
+False
+```
+Если имя файла на первом месте, а режим на втором, то имена можно не указывать. (позиционные аргументы
+всегда должны идти первыми, а именованные — после них)
+
+Путь можно опустить, если он совпадает с текущей рабочей директории:
+```py
+>>> fp = open('zapis1.txt','w')
+>>> fp
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
+```
+Список атрибутов объекта fp:
+```py
+>>> 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']
+```
+Пример открытия бинарного файла:
+```py
+>>> fp1 = open(drkt + '\\zapis2.bin', mode = 'wb+')
+>>> fp1
+<_io.BufferedRandom name='C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\zapis2.bin'>
+```
+## Пункт 4.4. Закрытие файла.
+Когда файл успешно открывается / создается и открывается, ему задается целочисленный
+номер, называемый файловым дескриптором. Он создается только на один сеанс работы и указывает,
+с каким именно файлом нужно работать.
+
+После того, как программа отработала, надо очистить ресурсы, связанные с файлом (область
+в оперативной памяти, в буфере при буферизации), и удалить дескриптор. Если не закрыть
+файл, это может его повредить, данные могут быть утеряны или система может быть перегружена,
+т.к. исчерпается ресурс оперативной памяти. Для закрытия есть метод close().
+
+После закрытия на объект все еще можно посмотреть:
+```py
+>>> fp.close()
+>>> fp
+<_io.TextIOWrapper name='C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
+```
+Но значение атрибута closed сменится на True:
+```py
+>>> fp.closed
+True
+```
+
+## 4.5. Запись информации в файл с помощью метода write.
+Пример 1
+```py
+>>> 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()
+```
+открыли файл и увидели 
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+Пример 2
+```py
+>>> sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+>>> fp3=open('zapis4.txt','w')
+>>> for i in range(len(sps3)):
+...     stroka4=sps3[i][0]+' '+str(sps3[i][1])
+...     fp3.write(stroka4)
+...
+11
+11
+12
+>>> fp3.close()
+```
+Открыли файл и увидели 
+```py
+Иванов И. 1Петров П. 2Сидоров.
+```
+Легко заметить, что информация записана в файл не очень удачно.Тогда попробум сделать так:
+```py
+>>> gh=open('zapis5.txt','w')
+>>> for r in sps3:
+...     gh.write(r[0]+' '+str(r[1])+'\n')
+...
+12
+12
+13
+>>> gh.close()
+```
+Открыли файл и увидели
+```py
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+можно было записать цикл как 
+```py
+  for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+```
+4.6 Первый способ чтения информации из текстового файла.
+```py
+>>> 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()
+>>> sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+```
+Обратите внимание, что в функции открытия файла использован только один аргумент, остальные – со значениями «по умолчанию».
+Здесь, перед занесением строки в список с помощью метода rstrip, из неё удаляется сим-вол конца строки, а с помощью метода replace – скобки.
+Видно, что полученный список отличается от исходного sps, в первую очередь, типом данных.
+К тому же, в sps1 убрались не все пробелы.
+Преобразовать sps1 в sps можно, например, так:
+```py
+>>> sps2 = [int(i.strip()) for i in sps1]
+>>> sps2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+Это list comprehension, который у кажлого элемента sps1 убирает лишние пробелы с обеих
+сторон (в этом отличие rstrip от strip). Затем полученная строка конвертируется в число.
+## Пункт 4.7. Чтение информации из файла с помощью метода read.
+Метод read, как и write, относится к объекту – файловой переменной. В качестве аргумен-та этого метода может задаваться целое число – количество символов или, если открыт бинарный файл, - количество байт, которое должно быть прочитано, соответственно, из текстового или би-нарного файла, начиная с текущего положения маркера. Если указанное число превышает коли-чество оставшихся символов (байт) в файле, то считываются все оставшиеся символы (байты). Если это число не указано, то считываются вся информация от маркера до конца файла. Метод возвращает строку с символами или совокупность байт, прочитанных из файла. Например,
+```py
+>>> fp=open('zapis3.txt')
+>>> stroka1=fp.read(12) # Чтение первых 12 файлов, курсор остановится на 13-ом (/n)
+>>> stroka2=fp.read() # Чтение всех оставшихся файлов вплоть до EOF
+>>> fp.close()
+>>> stroka1
+'[1, 2, 3, 4]'
+>>> stroka2
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+## Пункт 4.8. Чтение информации с помощью readline и readlines.
+
+Метод readline() считывает одну строку из файла за один вызов. Он читает символы до тех пор,
+пока не встретит символ новой строки (\n; включается в строку) или конец файла (EOF).
+Если файл содержит только одну строку или указатель чтения находится в конце файла, то при
+вызове readline() будет возвращена пустая строка.
+
+Метод readlines() считывает все строки файла и возвращает их в виде списка, где каждая
+строка — это отдельный элемент списка. Каждая строка в списке будет содержать символ новой
+строки \n, если он есть в файле.
+```py
+>>> file = open("zapis5.txt")
+>>> file.readline()
+'Иванов И. 1\n'
+>>> file.seek(0)  # Вовзращение указателя обратно в начало, чтобы нагляднее выполнить
+                    readlines
+0
+>>> file.readlines()
+['Иванов И. 1\n', 'Петров П. 2\n', 'Сидоров С. 3\n']
+```
+## Пункт 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
+ В модуле pickle содержатся функции для работы с бинарными файлами, в которые могут после-довательно записываться или считываться целиком один или несколько объектов из оперативной памяти. Рассмотрите этот способ работы с файлами на следующем примере:
+```py
+>>> import pickle
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+>>> fp=open('zapis6.mnz','wb')  # Бинарный файл - на запись
+>>> pickle.dump(mnoz1,fp)  #dump - метод записи объекта в файл
+>>> fp.close()
+```
+Откроем получившийся файл в текстовом редакторе, увидим подобную строку.
+```py
+Ђ•#       Џ”(ЊiPhone”Њbook”Њtable”Њpen”ђ.
+```
+Так происходит, потому что байты в этом файле не предназначены для текстового представления.
+Они могут содержать символы, которые не могут быть корректно интерпретированы в рамках
+любой текстовой кодировки. Но в некоторых байтах содержатся символы, которые попадают в
+диапазон, поддерживаемый текстовым редактором и конкретной кодировкой (в моем случае ANSI),
+поэтому правильно дешифрованные буквы все же есть.
+
+
+Десериализуем множество обратно:
+```py
+>>> fp = open('zapis6.mnz','rb')
+>>> mnoz2 = pickle.load(fp)
+>>> fp.close()
+>>> mnoz2
+{'book', 'iPhone', 'table', 'pen'}
+>>> mnoz1
+{'book', 'iPhone', 'table', 'pen'}
+>>> mnoz1 == mnoz2
+True
+```
+mnoz1 не совпадает с тем, что было задано, потому что это множество. Оно исключает
+повторяющиеся элементы, оставляя только один, а еще не содержит конкретный порядок элементов.
+Но два множества равны, если у них равны все элементы и их одинаковое количество, вне
+зависимости от порядка, так что сравнение возвращает True.
+```py
+>>> fp = open('zapis7.2ob','wb')
+>>> pickle.dump(mnoz1,fp)
+>>> pickle.dump(sps3,fp)
+>>> fp.close()
+>>> fp = open('zapis7.2ob','rb')
+>>> obj1 = pickle.load(fp)
+>>> obj2 = pickle.load(fp)
+>>> fp.close()
+>>> obj1
+{'book', 'iPhone', 'table', 'pen'}
+>>> obj2
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>> mnoz1 == obj1
+True
+>>> obj2 == sps3
+True
+```
+# Пункт 5. Перенаправление потоков ввода и вывода данных.
+
+Поток в python и других ЯП - это абстракция, которая позволяет регулировать источники
+ввода информации и то, куда её выводить. Всего их по умолчанию три (еще можнно создать
+пользовательские):
+    sys.stdin — поток ввода (обычно клавиатура)
+    sys.stdout — поток вывода
+    sys.stderr — поток ошибок (оба обычно экран)
+
+Для работы с потоками импортируем модуль sys:
+```py
+>>> import sys
+```
+Сохраним адрес в памяти текущего потока вывода:
+```py
+>>> vr_out = sys.stdout
+>>> vr_out
+<idlelib.run.StdOutputFile object at 0x0000018C2F7961C0>
+```
+Откроем (созадем) файл на запись:
+```py
+>>> fc = open('Stroka.txt','w')
+```
+Теперь зададим в качестве потока вывода этот файл:
+```py
+>>> sys.stdout = fc
+>>> print('запись строки в файл')
+```
+Видно, что в консоли не появилось строки. Вернем поток по умолчанию обратно:
+```py
+>>> sys.stdout = vr_out
+>>> print('запись строки на экран')
+запись строки на экран
+>>> fc.close()
+```
+В файле Stroka.txt находится: запись строки в файл
+
+Можно перенаправить и поток ввода тоже. Например, на файл:
+```py
+>>> tmp_in = sys.stdin
+>>> fd = open("Stroka.txt", "r")
+>>> sys.stdin = fd
+>>> sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>	
+>>> while True:
+	try:                # Конструкция try-except предназначена для отладки исключений
+                            # То есть если возвращается ошибка, можно ее перехватить и
+                            # указать, что делать в таком случае
+		line = input()
+		print(line)
+	except EOFError:
+		break
+запись строки в файл
+>>> fd.close()
+>>> sys.stdin = tmp_in
+```

TEMA6/task.md

@@ -0,0 +1,62 @@
+•   Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56,
+представленными в виде символьных строк.
+```py
+>>> nums = tuple(str(random.randint(6, 56)) for _ in range(125))
+>>> nums
+('41', '37', '13', '26', '9', '33', '55', '50', '51', '44', '38', '17', '18', '18', '36',
+ '23', '43', '38', '41', '42', '53', '16', '41', '34', '38', '48', '37', '17', '36', '48',
+ '31', '34', '51', '18', '12', '37', '42', '50', '47', '26', '27', '30', '26', '11', '19',
+ '56', '15', '7', '6', '45', '22', '37', '36', '54', '31', '35', '46', '54', '31', '13',
+...'41', '9', '9', '22')
+```
+Примечание: если итератор не надо использовать в теле цикла, принято просто обозначать его _
+
+•   Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+```py
+>>> group = ["Tsvetkova", "Konovalova", "Kiselyov", "Kirsanov", "Romanov"]
+```
+•   Записывается кортеж в бинарный файл.
+```py
+>>> fl = open("okz.okz", "wb")
+>>> pickle.dump(nums, fl)
+```
+•   Записывается в этот же файл список и закрывается файл.
+```py
+>>> pickle.dump(group, fl)
+>>> fl.close()
+```
+•   Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+```py
+>>> fl = open("okz.okz", "rb")
+>>> nums1 = pickle.load(fl)
+>>> nums1
+('41', '37', ... '41', '9', '9', '22')
+>>> group1 = pickle.load(fl)
+>>> group1
+['Tsvetkova', 'Konovalova', 'Kiselyov', 'Kirsanov', 'Romanov']
+```
+Примечание: при чтении с помощью pickle.load() тоже есть указатель, который останавливается
+при достижении /n, так что можно просто вызвать ее два раза, чтобы записать эти два объекта.
+Если вызвать ее третий раз, будет EOFError.
+
+•   Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+```py
+>>> print("Файлы nums совпадают!") if nums == nums1 else print("Файлы nums не совпадают :(")
+Файлы nums совпадают!
+>>> print("Файлы group совпадают!") if group == group1 else print("Файлы group не совпадают :(")
+Файлы group совпадают!
+```
+•   Разделяется кортеж на  совокупности по 5 чисел в каждой и
+они записываются в виде отдельных списков со своими именами. (Динамические имена, согласно
+примечанию на git uit)
+```py
+>>> for i in range(125//5):
+	exec('list' + str(i) + '=' + str(list(nums1[i:i+5])))
+```
+Можно вызвать конкретные списки для проверки:
+```py
+>>> list1
+['37', '13', '26', '9', '33']
+>>> list6
+['55', '50', '51', '44', '38']
+```

TEMA7/1111.md

@@ -0,0 +1,23 @@
+16.	Разработайте функцию с 2 аргументами, которая для заданного словаря (аргумент функции) с любыми ключами и с числовыми значениями создаёт новый словарь с теми же ключами и со значениями, равными синусам от значений из входного словаря с заданным именами. Проверьте функцию на примере двух разных входных словарей.
+```py
+>>> import math
+>>> def f(a):
+...     result = {}
+...     for k, v in a.items(): # Перебираем все пары ключ-значение из входного словаря
+...             result[k] = math.sin(v)
+...     return result
+...
+>>> def test():
+...     print("Тест 1", f({'a': 0, 'b': 1.57, 'c': 3.14}))
+...
+>>> def test2():
+...     print("Тест 2", f({'x': 0.5, 'y': 1.0, 'z': 2.0}))
+...
+
+>>> test
+<function test at 0x0000016467AAAAC0>
+>>> test()
+Тест 1 {'a': 0.0, 'b': 0.9999996829318346, 'c': 0.0015926529164868282}
+>>> test2()
+Тест 2 {'x': 0.479425538604203, 'y': 0.8414709848078965, 'z': 0.9092974268256817}
+```

TEMA7/7.md

@@ -0,0 +1,739 @@
+# Пункт 2. Создание пользовательской функции.
+
+Общий вид:
+```py
+def  <Имя функции>([<Список аргументов >]):
+[<отступы> """<Комментарий по назначению функции>"""]
+<отступы> <Блок инструкций – тело функции>
+[<отступы> return <Значение или вычисляемое выражение>]
+```
+Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем
+в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то
+выполнение функции прекращается с возвратом значения, следующего за этой инструкцией.
+В Python, если функция не содержит оператора return, она автоматически возвращает значение
+None.
+
+## Пункт 2.1. Функция без аргументов.
+```py
+>>> def uspeh():
+	"""Подтверждение успеха операции"""
+	print('Выполнено успешно!')
+>>> uspeh()
+Выполнено успешно!
+```
+Функция - класс function:
+```py
+>>> type(uspeh)
+<class 'function'>
+```
+Видно, что такой объект появился в рабочем пространстве:
+```py
+>>> dir()
+['__annotations__', '__builtins__',
+ '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+```
+```py
+>>> help(uspeh)
+Help on function uspeh in module __main__:
+uspeh()
+    Подтверждение успеха операции
+```
+Видно, что help вернуло имя функции и то описание, которое было указано в тройных кавычках
+при её определении.
+
+## Пункт 2.2. Функция с аргументами.
+```py
+>>> def sravnenie(a, b):
+	"""Сравнение a и b"""
+	if a > b:
+		print(a, ' больше ', b)
+	elif a < b:
+		print(a, ' меньше ', b)
+	else:
+		print(a, ' равно ',b)
+
+```
+```py		
+>>> n, m = 16, 5; sravnenie(n,m)
+16  больше  5
+```
+Так как при описании функции мы не конкретизировали, какой тип данных хотим получить, то
+python сможет принять любые данные, которые можно сравнить. Если что-то нельзя сравнить,
+вернется TypeError
+```py
+>>> sravnenie(2+3j > 1+2j)
+  File "<stdin>", line 1, in <module>
+TypeError: '>' not supported between instances of 'complex' and 'complex'
+>>> sravnenie(2+3j == 2+3j)
+True
+>>>sravnenie("abbb", "baaaaa")  # abbb меньше baaaa (т.к. 'a' < 'b')
+>>>sravnenie("abbb", "abbbbb")  # abbb меньше abbbbb (короткая строка меньше)
+>>>sravnenie("10", "2")         # 10 меньше 2 (т.к. '1' < '2')
+>>>sravnenie([1, 2, 3], [1, 2, 4])  # [1, 2, 3] меньше [1, 2, 4] (т.к. 3 < 4)
+>>>sravnenie([1, 2], [1, 2, 0])     # [1, 2] меньше [1, 2, 0] (короткий список меньше)
+
+```
+## Пункт 2.3. Функция с return.
+```py
+>>> def logistfun(b, a):
+	"""Вычисление логистической функции"""
+	import math
+	return a / (1 + math.exp(-b))
+```
+```py
+>>> v=1
+>>> w = 0.7
+>>> z = logistfun(w, v)
+>>> z
+0.6681877721681662
+```
+## 2.4. Сложение для разных типов аргументов
+```py
+>>> def slozh(a1,a2,a3,a4):
+...     """ Сложение значений четырех аргументов"""
+...     return a1+a2+a3+a4
+...
+```
+```py
+>>> slozh(1, 2, 3, 4) #Для чисел
+10
+
+>>> slozh('1','2','3','4') #Для строк
+'1234'
+
+>>> b1 = [1, 2]; b2 = [-1, -2]; b3 = [0, 2]; b4 = [-1, -1] #Для списков
+>>> q = slozh(b1, b2, b3, b4)
+>>> q
+[1, 2, -1, -2, 0, 2, -1, -1]
+
+>>> slozh((1, 2), (3, 4), (-5, 0), (-7, -3)) #Для кортежей
+(1, 2, 3, 4, -5, 0, -7, -3)
+
+
+>>> slozh({1,1,1,1}, {2}, {"аааа", True, None}, {6, 6, "a"}) #Для множеств
+...
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+Как видно, операция сложения для множеств не применима. Если нужно объединить два множества,
+для этого есть специальная операция set union вида set1 | set2 | set3
+```py
+>>> dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4} #Для словарей
+...
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+```
+Словари тоже нельзя сложить плюсом. Для объединения словарей есть оператор распаковывания
+**dict1.
+
+```py
+>>> slozh(1, "а", 2, "б") #Число и строка
+...
+TypeError: unsupported operand type(s) for +: 'int' and 'str'
+```
+С коллекциями без явного преобразования тоже не сработает.
+```py
+>>> slozh(1, True, 2, False) #Число и логический тип
+4
+>>> slozh(1, 3.44, 2.0, 7) #Целое число и число с плавающей точкой
+13.44
+```
+## Пункт 2.5. Функция, реализующая модель некоторого устройства,
+на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
+```py
+>>> def inerz(x,T,ypred):
+	""" Модель устройства с памятью:
+	x - текущее значение вх.сигнала,
+	T - постоянная времени,
+	ypred - предыдущее значение выхода устройства"""
+	y = (x + T * ypred) / (T + 1)
+	return y
+```
+Создаем список с измерениями значений входного сигнала – в виде «ступеньки»:
+```py
+>>> sps = [0] + [1] * 100
+>>> spsy = []
+>>> TT = 20
+>>> yy = 0
+>>> for xx in sps:
+	yy = inerz(xx,TT,yy)
+	spsy.append(yy)
+```
+```py	
+>>> import pylab as plt
+>>> plt.plot(spsy, label = "Выходной сигнал")
+[<matplotlib.lines.Line2D object at 0x00000241DC815370>]
+>>> plt.show()
+```
+График сохранен в файле с именем Figure_1.
+
+
+# Пункт 3. Функции как объекты.
+
+## Пункт 3.1. Получение списка атрибутов объекта-функции.
+```py
+>>> dir(inerz)
+['__annotations__', '__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- текущее значение вх.сигнала,\n\tT -постоянная времени,\n\typred - предыдущее значение выхода устройства'
+>>> help(inerz)
+Help on function inerz in module __main__:
+```
+Если нет, то inerz.__doc__ будет иметь значение None.
+
+Примеры других атрибутов функций:
+```py
+>>> def f(a : int, b : int, c = 10):
+	return
+
+>>> f.__annotations__
+{'a': <class 'int'>, 'b': <class 'int'>}  # Возвращает типы аргументов, если они заданы
+
+>>> f.__defaults__ # Возвращает значения по умолчанию, если они заданы
+(10,)
+>>> f.__name__ # Возвращает имя функции (для функций, определенных внутри других, возвращает
+полный путь
+'f'
+```
+## Пункт 3.2. Сохранение ссылки на объект-функцию в другой переменной.
+```py
+>> fnkt = sravnenie
+>>> v = 16
+>>> fnkt(v, 23)
+16  меньше  23
+```
+Здесь происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в
+переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую
+функцию, что и sravnenie.
+
+## Пункт 3.3. Возможность альтернативного определения функции в программе.
+```py
+>>> typ_fun=8
+>>> if typ_fun==1:
+...     def func():
+...             print('Функция 1')
+... else:
+...     def func():
+...             print('Функция 2')
+...
+>>> func()
+Функция 2
+```
+
+Программа выводит сообщение "Функция 2", потому что переменная typ_fun не равна 1, и
+выполняется блок else, в котором функция func определена как выводящая, собственно,
+"Функция 2".
+
+# Пункт 4. Аргументы функции.
+
+## Пункт 4.1. Возможность использования функции в качестве аргумента другой функции
+```py
+>>> 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. Обязательные и необязательные аргументы.
+```py
+>>> 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. Возможность обращения к функции с произвольным расположением аргументов.
+```py
+>>> logistfun(b = 0.5, a = 0.8)
+0.34498724056380625
+```
+Но при этом нельзя сделать так:
+```py
+>>> logistfun(b = 2, 0.7)
+SyntaxError: positional argument follows keyword argument
+```
+Python ожидает, что все позиционные аргументы будут переданы первыми, а затем уже
+могут следовать именованные аргументы.
+
+## Пункт 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже.
+```py
+>>> b1234 = [b1, b2, b3, b4]
+>>> b1234
+[[1, 2], [-1, -2], [0, 2], [-1, -1]]
+>>> qq = slozh(*b1234)
+>>> qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+Со звёздочкой коллекции передаются как набор аргументов функции, Она также называется
+"оператор распаковки". Это было бы эквивалентно записи slozh(b1,b2,b3,b4)
+
+## Пункт 4.5. Пример со значениями аргументов функции, содержащимися в словаре
+```py
+>>> dic4 = {"a1": 1, "a2": 2, "a3": 3, "a4": 4}
+>>> qqq = slozh(**dic4)
+>>> qqq
+10
+```
+В данном случае распаковка произошла так, что ключи на входе функции восприниимаются как
+значения позиционных переменных, а значения, соответственно, как значения.
+
+Примечание: Если поставить только одну звездочку, python попытается интерпретировать
+ключи, а не значения словаря как позиционные аргументы. Получается так:
+```py
+>>> slozh(*dic4)
+'a1a2a3a4'
+```
+## Пункт 4.6. Смешанные ссылки
+```py
+>>> e1 = (-1, 6); dd2 = {'a3': 3, 'a4': 9}
+>>> qqqq = slozh(*e1,**dd2)
+>>> qqqq
+17
+```
+То есть (-1) + 6 + 3 + 9 = 17
+
+## Пункт 4.7. Переменное число аргументов у функции.
+```py
+>>> def func4(*kort7):
+	"""Произвольное число аргументов в составе кортежа"""
+	smm = 0
+	for elt in kort7:
+		smm += elt
+	return smm
+
+>>> func4(-1,2)
+1
+>>> func4(-1,2,0,3,6)
+10
+```
+Переменное число аргументов с использованием * упаковывается в кортеж.
+
+## Пункт 4.8. Комбинация аргументов
+```py
+>>> 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
+```
+То есть -1 * 9 + 2 = -7.
+
+Если захочется НЕ передавать b, придется переопределить функцию так, чтобы
+именованный параметр b был в конце, а позиционный кортеж - перед ним. Например,
+так:
+```py
+>>> def func4(a, *kort7, b = 7):
+	smm = 0
+	for elt in kort7:
+		smm += elt
+	return a * smm + b
+
+>>> func4(5, *[1, 2, 3])
+37
+```
+Примечание:
+
+В общем виде *args и **kwargs - способы передать не уточненное заранее число
+элементов, причем:
+
+    *args — переменное количество позиционных аргументов. Переданные с одной
+    звездочкой аргументы собираются в кортеж.
+
+    **kwargs — переменное количество именованных аргументов. Все переданные аргументы,
+    которые указываются по имени, собираются в словарь.
+
+    Как и всегда, *args всегда должно идти перед **kwargs.
+
+## Пункт 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
+```py
+>>> a = 90
+>>> def func3(b):
+	b = 5*b+67
+
+	
+>>> func3(a)
+>>> a
+90
+```
+Поскольку функция ничего не возвращает (то есть, формально, является процедурой), то вычисленное
+значение b = 5*b+67 существует только локально внутри нее и не выносится в глобальную область видимости
+Для наглядности:
+```py
+>>> def func3(b):
+	b = 5*b+67
+	print(b)
+
+	
+>>> func3(a)
+517
+>>> a
+90
+```
+```py
+
+>>> sps1=[1,2,3,4]
+>>> def func2(sps):
+	sps[1] = 99
+
+	
+>>> func2(sps1)
+>>> print(sps1)
+[1, 99, 3, 4]
+```
+В отличие от предыдущего примера с переменной численного типа, список передается по ссылке, а не по
+значению, поэтому изменяется именно тот объект, который был передан.
+Для наглядности:
+```py
+>>> def func3(b):
+	b = 5*b+67
+	print(id(b))
+	
+>>> func3(a)
+2763070067568
+>>> id(a)
+2763028911248  # Разные адреса
+
+>>> def func3(b):
+	b = 5*b+67
+	print(id(b))
+	
+>>> func3(a)
+2763070067568
+>>> id(a)
+2763028911248 # Одинаковые адреса
+```
+```py
+>>> kort = (1,2,3,4)
+>>> func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#41>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#40>", line 2, in func2
+    sps[1] = 99
+TypeError: 'tuple' object does not support item assignment
+```
+Кортеж - неизменяемая коллекция, так что переназначение значения в таком виде, как здесь, не работает.
+# Пункт 5. Специальные типы  пользовательских функций
+
+## Пункт 5.1. Анонимные функции (лямбда-функции).
+```py
+>>> anfun1 = lambda: 1.5 + math.log10(17.23)
+>>> type(anfun1)
+<class 'function'>
+
+>>> anfun1()
+2.7362852774480286
+
+>>> anfun2 = lambda a,b : a+math.log10(b)
+>>> anfun2(17, 234)
+19.369215857410143
+
+>>> anfun3 = lambda a, b=234: a+math.log10(b)
+>>> anfun3(100)
+102.36921585741014
+```
+Вызов лямбда-функции создает объект класса "функция", который потом можно положить в другую переменную
+и далее вызывать. Но это делать необязательно: если она используется один раз, можно вызвать ее сразу,
+например:
+```py
+>>> r = (lambda a, b: a**2 + b)(5, 2) # Это результат функции, а не объект класса "функция"
+>>> r
+27
+```
+Внутри лямбда-функции не могут использоваться многострочные выражения, например:
+```py
+>>> r1 = lambda: (for i in range(5): print(i))
+SyntaxError: invalid syntax
+```
+Но при этом:
+```py
+>>> r1 = lambda: (print(i) for i in range(5))
+
+```
+Аналогично нельзя использовать if-else, но можно использовать тернарный оператор.
+
+## Пункт 5.2. Функции-генераторы
+
+Иногда в циклах на каждой итерации нужно получать одно из значений. Для этого есть оператор yield.
+Это похоже на return, но в отличие от return не останавливает полностью выполнение программы.
+Когда выполнение генератора возобновляется после yield, оно продолжается с того места, где было
+приостановлено, до следующего оператора yield (или до конца функции).
+Вместе с yield, можно использовать next(). Например:
+```py
+>>> def test():
+	for i in range(3):
+		yield i
+
+		
+>>> l = test()
+>>> l
+<generator object test at 0x0000028353CCFF90>
+>>> next(l)
+0
+>>> next(l)
+1
+```
+Аналогично, можно использовать и метод __next__
+```py
+>>> print(l.__next__())
+2
+```
+Другой пример:
+```py
+>>> alp=func5(7,3)
+>>> print(alp.__next__())
+1
+>>> print(alp.__next__())
+5
+>>> print(alp.__next__())
+4
+...
+```
+__next__ помогает вывести значение, которое yield передает на каждй итерации цикла. Если функция
+отработала последнюю итерацию, но мы все попытаемся сделать вызов, вернется ошибка:
+```py
+>>> print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#96>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+# Пункт 6. Локализация объектов в функциях.
+
+Все объекты - переменные, коллекции, функции и т.д. - могут быть определены глобально или локально.
+Глобально - значит вне всяких функций.Локальные переменные определены внутри функции, и если хочется
+использовать такую переменную в другой функции, то нужно обрабатывать доступ к ним из других функций.
+
+## Пункт 6.1. Примеры
+```py
+>>> glb = 10
+>>> def func7(arg):
+	loc1 = 15
+	glb = 8
+	return loc1*arg
+
+>>> res = func7(glb)
+>>> res
+150
+```
+Проверим:
+```py
+>>> glb
+10
+```
+
+Посмотрим подробнее, что происходит внутри функции:
+```py
+>>> def func7(arg):
+	loc1=15
+	glb=8
+	print(glb, arg)
+	return loc1*arg
+
+>>> res=func7(glb)
+8 10
+```
+Видно, что внутри объект с именем glb принял значение 8, но глобальная переменная при этом после выполнения
+функции значения не поменяла. Это происходит потому, что технически, локальный glb и глобальный glb -
+это два разных объекта. В этом можно убедиться:
+```py
+>>> res=func7(glb)  #При определенении func7 добавлена строка print(id(glb))
+2763028720144
+8 10
+>>> id(glb)
+276302872020
+```
+
+Пример 2.
+```py
+>>> def func8(arg):
+	loc1=15
+	print(glb)  
+	glb=8
+	return loc1*arg
+
+>>> res=func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#119>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#118>", line 3, in func8
+    print(glb)
+UnboundLocalError: local variable 'glb' referenced before assignment
+```
+Ошибка возникает, потому что когда python видит внутри функции переменную, он по умолчанию считает ее
+локальной. И получается, что вызов локальной переменной glb происходит раньше объявления локальной
+переменной glb, на что нам и указывает ошибка. Можно исправить эту проблему, переопределив лоаклизацию
+glb внутри func8():
+```py
+>>> glb=11
+>>> def func7(arg):
+	loc1=15
+	global glb
+	print(glb)
+	glb=8
+	return loc1*arg
+
+>>> res=func7(glb)
+11
+>>> glb
+8
+```
+Здесь мы явно указали, что в функции имеем в виду глобальную переменную, так что она изменилась.
+
+## Пункт 6.2. locals() и globals()
+
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно,
+локальными или глобальными на уровне вызова этих функций. 
+```py
+>>> globals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
+           '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
+           'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3',
+           'func5', 'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8'])
+>>> locals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
+           '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
+           'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'r',
+           'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8'])
+```
+Сейчас различий нет, потому что эти методы возвращают объекты на уровне вызова этих функций, но мы
+вызвали обе самом внешнем уровне, не внутри какой-либо функции, а в самом рабочем пространстве, где
+локальная и глобальная области видимости совпадают.
+```py
+>>> glb = 10
+>>> def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals())  #Перечень локальных объектов «изнутри» функции (для наглядности отобразим
+                            и значения тоже)
+	return loc1*arg
+
+>>> hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
+           '__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
+           'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'r',
+           'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8', 'hh']) # Тут глобальное glb
+{'arg': 10, 'loc1': 15, 'glb': 8} # Это локальное glb
+>>> glb # Снова глобальное glb
+10
+```
+## Пункт 6.3. Локализация объектов при использовании вложенных функций.
+```py
+>>> def func9(arg2,arg3):
+	def func9_1(arg1):
+		loc1=15
+		glb1=8
+		print('glob_func9_1:',globals().keys())
+		print('locl_func9_1:',locals().keys())
+		return loc1*arg1
+	loc1=5
+	glb=func9_1(loc1)
+	print('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__', '__file__', 'math', 'random', 'pickle',
+                         'task', 't', 'number', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1',
+                         'anfun2', 'anfun3', 'func5', 'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb',
+                         'func7', 'res', 'func8', 'hh', 'func9', 'loc1'])
+
+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__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number',
+                       'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5',
+                       'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8', 'hh',
+                       'func9', 'loc1']) # Такой же, как glob_func9_1
+```
+## Пункт 6.4. Моделирование САУ
+```py
+>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=8,5,3,10,2,0.5,1000
+>>> k1=float(znach[0])
+>>> T=float(znach[1])
+>>> k2=float(znach[2])
+>>> Xm=float(znach[3])
+>>> A=float(znach[4])
+>>> F=float(znach[5])
+>>> N=int(znach[6])
+>>> vhod=[]
+>>> for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+>>> vhod
+[0.0, -9.797174393178826e-16, -1.959434878635765e-15, -2.9391523179536475e-15, -3.91886975727153e-15,
+ -4.898587196589413e-15, -5.878304635907295e-15, -6.858022075225178e-15,
+ ...
+ 1.1010469343064857e-13,
+ -8.856348540728095e-13, -1.8813744015762676e-12, 7.608648580119871e-13, -2.3487468949147107e-13, -1.
+ 2306142369949293e-12, -2.226353784498387e-12, 4.1588547508986746e-13, -5.798540724135906e-13,
+ -1.5755936199170489e-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 xtt<gran and xtt>(-gran):
+		ytt=0
+	elif xtt>=gran:
+		ytt=xtt-gran
+	elif xtt<=(-gran):
+		ytt=xtt+gran
+	return ytt
+
+>>> yi1 = 0; yin1 = 0; yi2 = 0
+>>> vyhod = []
+>>> for xt in vhod:
+	xt1 = xt - yi2   #отрицательная обратная связь
+	[yi1,yin1] = realdvig(xt1,k1,T,yi1,yin1)
+	yi2 = tahogen(yin1,k2,yi2)
+	yt = nechus(yin1,Xm)
+	vyhod.append(yt)
+>>> print('y=',vyhod)
+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,
+    ...
+    2.37392249152569e+226, -2.801972415904499e+226, -3.2288710633399875e+226,
+    1.321721142591339e+227, -9.144734174579399e+226]
+
+```

TEMA7/test.md

@@ -0,0 +1,89 @@
+
+Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для
+устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на
+заданное время Т.
+```py
+def delays (signal, T):
+	for i in range(len(signal)):
+		signal[i] += T
+	return signal
+```
+Входной сигнал:
+```py
+>>> y = [random.gauss(3, 1.5) for _ in range(40)]
+>>> y
+[0.9991072002742722, 1.5968849542569137, 2.3438553070732215, 3.5914160170650784, 4.037092622456526,
+ 2.918114740779675, 4.802139541704564, 3.2313443629034646, 2.329031244833026, 4.450860002446187,
+ 1.4135232524868848, 5.914364290743276, 3.7898798373923634, 2.364244259128151, 4.9786840892253235,
+ 1.4351490690602144, 2.351122955511408, 1.8798309616294469, 0.7931480954519166, 3.811575392065204,
+ 2.524732026173494, 2.8373060222940696, 4.497504412830464, 3.406940931674363, 3.876506913067825,
+ 1.7529616032820314, 2.6542411737897087, 1.948604542902865, 6.138099312505814, 1.4111492356181103,
+ 3.736820673744037, 4.509373750771566, 1.7486314440126465, 4.70122140759552,
+ -0.6513915222680815, 0.171219291885647, 2.2079783562880486, 4.390489704586708, 0.9670198540727273,
+ 1.6420724788248429]
+
+>>> yd = delays(y, 4)
+>>> yd
+[4.999107200274272, 5.596884954256914, 6.3438553070732215, 7.591416017065079, 8.037092622456527,
+ 6.918114740779675, 8.802139541704564, 7.231344362903465, 6.3290312448330255, 8.450860002446188,
+ 5.413523252486884, 9.914364290743276, 7.7898798373923634, 6.364244259128151, 8.978684089225323,
+ 5.435149069060214, 6.351122955511408, 5.879830961629446, 4.793148095451917, 7.811575392065204,
+ 6.524732026173494, 6.83730602229407, 8.497504412830464, 7.406940931674363, 7.876506913067825,
+ 5.752961603282031, 6.654241173789709, 5.948604542902865, 10.138099312505814, 5.41114923561811,
+ 7.736820673744036, 8.509373750771566, 5.748631444012647, 8.70122140759552,
+ 3.3486084777319185, 4.171219291885647, 6.207978356288049, 8.390489704586708, 4.967019854072728, 5.642072478824843]
+```
+Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то
+распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов
+выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения
+случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+```py
+import numpy as np
+import random
+import matplotlib.pyplot as plt
+
+def histo(data, num):
+    minval, maxval = min(data), max(data)
+    parts = np.linspace(minval, maxval, 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 == maxval:
+            rows[-1] += 1
+            
+    plt.hist(data, bins=parts)
+    plt.xlabel('Значения выборки')
+    plt.ylabel('Число элементов')
+    plt.title('Гистограмма выборки')
+    plt.show()
+
+    return rows
+
+sample = [random.gauss(random.random(), random.random()) for _ in range(random.randint(10,200))]
+intervals = int(input("Введите количество интервалов разбиения: "))
+output = histo(sample, intervals)
+
+======================= RESTART: D:/STUDY/POAS/Тема7/hist.py ======================
+Введите количество интервалов разбиения: 12
+[1, 0, 3, 4, 11, 21, 43, 57, 22, 6, 2, 3]
+
+```
+Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+```py
+linreg = lambda b1, b2, x: b1 + b2 * x
+b1 = float(input("Введите коэффициент b1 линейной регрессии: "))
+b2 = float(input("Введите коэффициент b2 линейной регрессии: "))
+x_val = float(input("Введите значение x: "))
+print(linreg(b1, b2, x_val))
+
+
+Введите коэффициент b1 линейной регрессии: 2
+Введите коэффициент b2 линейной регрессии: 3
+Введите значение x: 5
+17.0
+```

TEMA8/16.md

@@ -0,0 +1,42 @@
+Разработайте функцию с 2 аргументами, которая для заданного словаря (аргумент функции) с любыми ключами и с числовыми значениями создаёт новый словарь с теми же ключами и со значениями, равными синусам от значений из входного словаря с заданным именами. Проверьте функцию на примере двух разных входных словарей.
+Через модуль:
+Модуль1
+```py
+import math
+
+def f(a):
+    """Функция f."""
+    result = {}
+    for k, v in a.items():  # Перебираем все пары ключ-значение
+        result[k] = math.sin(v)
+    return result
+
+def test():
+    """Первая тестовая функция."""
+    print("Тест 1", f({'a': 0, 'b': 1.57, 'c': 3.14}))
+
+if __name__ == "__main__":
+    test()
+    print("mode1.py работает корректно")
+```
+Модуль2:
+```py
+from mode1 import f
+
+def test2():
+    """Вторая тестовая функция."""
+    print("Тест 2", f({'x': 0.5, 'y': 1.0, 'z': 2.0}))
+
+if __name__ == "__main__":
+    test2()
+    print("mode2.py работает корректно")
+```
+```py
+>>> os.chdir('C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA8')
+>>> import mode1
+>>> import mode2
+>>> mode1.test()
+Тест 1 {'a': 0.0, 'b': 0.9999996829318346, 'c': 0.0015926529164868282}
+>>> mode2.test2()
+Тест 2 {'x': 0.479425538604203, 'y': 0.8414709848078965, 'z': 0.9092974268256817}
+```

TEMA8/1819.md

@@ -0,0 +1,111 @@
+16.	Разработайте функцию с 2 аргументами, которая для заданного словаря (аргумент функции) с любыми ключами и с числовыми значениями создаёт новый словарь с теми же ключами и со значениями, равными синусам от значений из входного словаря, и записывает новый словарь в бинарный файл с заданным именем (аргумент функции). Проверьте функцию на примере двух разных входных словарей.
+
+Модуль 1 
+```py
+import math
+import pickle
+
+def slov_sin(input_dict, filename):
+    new_dict = {key: math.sin(value) for key, value in input_dict.items()}
+    with open(filename, 'wb') as f:
+        pickle.dump(new_dict, f)
+    print(f"Файл записан: {filename}")
+    return new_dict
+
+def read_slov(filename):
+    try:
+        with open(filename, 'rb') as f:
+            loaded_dict = pickle.load(f)
+        print(f"Файл прочитан: {filename}")
+        return loaded_dict
+   
+
+def test1():
+    dict1 = {'a': 0, 'b': math.pi / 2, 'c': math.pi, 'd': 3 * math.pi / 2}
+    file1 = 'sin_values_1.bin'
+    
+    saved = slov_sin(dict1, file1)
+    loaded = read_slov(file1)
+    
+    print(f"Исходный: {dict1}")
+    print(f"Загруженный: {loaded}")
+    
+    if saved == loaded:
+        print("OK")
+    else:
+        print("ERROR")
+    
+    return loaded
+
+def test2():
+    dict2 = {'x': 1.0, 'y': 2.0, 'z': -0.5}
+    file2 = 'sin_values_2.bin'
+    
+    saved = slov_sin(dict2, file2)
+    loaded = read_slov(file2)
+    
+    print(f"Исходный: {dict2}")
+    print(f"Загруженный: {loaded}")
+    
+    if saved == loaded:
+        print("OK")
+    else:
+        print("ERROR")
+    
+    return loaded
+
+if __name__ == "__main__":
+    print("Тесты запущены")
+    test1()
+    test2()
+    print("\n" + "="*60)
+    print("АВТОТЕСТЫ ЗАВЕРШЕНЫ")
+    print("="*60)
+```
+Модуль 2 
+ ```py
+import slov_module
+
+def run_tests():
+    """Запустить все тесты"""
+    print("Тест 1:")
+    slov_module.test1()
+    
+    print("\nТест 2:")
+    slov_module.test2()
+    
+    print("\nТест 3 (свой):")
+    d = {'x': 0.5, 'y': 1.0, 'z': 2.0}
+    f = 'my_test.bin'
+    
+    s = slov_module.slov_sin(d, f)
+    print(f"Исходный: {d}")
+    print(f"Синусы: {s}")
+    
+    l = slov_module.read_slov(f)
+    print(f"Из файла: {l}")
+
+if __name__ == "__main__":
+    run_tests()
+
+```
+
+```py
+
+>>> import slov_module
+>>> import test_module
+>>> slov_module.test1()
+Файл записан: sin_values_1.bin
+Файл прочитан: sin_values_1.bin
+Исходный: {'a': 0, 'b': 1.5707963267948966, 'c': 3.141592653589793, 'd': 4.71238898038469}
+Загруженный: {'a': 0.0, 'b': 1.0, 'c': 1.2246467991473532e-16, 'd': -1.0}
+OK
+{'a': 0.0, 'b': 1.0, 'c': 1.2246467991473532e-16, 'd': -1.0}
+>>> slov_module.test2()
+Файл записан: sin_values_2.bin
+Файл прочитан: sin_values_2.bin
+Исходный: {'x': 1.0, 'y': 2.0, 'z': -0.5}
+Загруженный: {'x': 0.8414709848078965, 'y': 0.9092974268256817, 'z': -0.479425538604203}
+OK
+{'x': 0.8414709848078965, 'y': 0.9092974268256817, 'z': -0.479425538604203}
+```

TEMA8/8.md

@@ -0,0 +1,362 @@
+
+
+# 1. Запуск интерактивной оболочки IDLE
+```py
+>>> import os,sys,importlib    #Импорт трёх важных вспомогательных модулей
+>>> os.chdir('C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA8')
+>>> os.getcwd()  #Контролируем корректность установки текущего каталога
+'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA8'
+```
+# 2. Создание и использование модулей в среде Python
+Большие программы делятся на части-модули, записываемые в отдельные файлы. Это делается для удобства отладки, обеспечения возможности коллективной разработки, создания возможности повторного использования программ. Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле.
+
+## 2.1 Запуск модуля на выполнение путём его импорта
+После импорта модуль становится объектом в пространстве имен той части программы, где осуществлен импорт. Модуль получает имя или псевдоним, заданные в инструкции импорта, а также набор атрибутов. При этом появляется возможность использования всех приемов, применяемых при работе с модулями. Создадим и откроем в текущем каталоге файл с именем Mod1.py, который будет содержать следующее:
+```py
+perm1=input('Mod1:Введите значение = ')
+print('Mod1:Значение perm1=',perm1)
+```
+Пока введённый или изменённый текст в окне редактора с текстом модуля не сохранён в файле, в заголовке перед именем файла будет стоять символ "*".
+```py
+>>> import Mod1 # Запуск модуля
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>> type(Mod1) # Модуль имеет класс объекта типа модуль
+<class 'module'>
+>>> dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+>>> Mod1.perm1 # Получим доступ к значению объекта, созданного в модуле
+'5'
+```
+При импорте модуля управление передаётся от модуля __main__ к модулю Mod1, который ищется в рабочем каталоге. Если бы данного модуля там не было, то при импорте пришлось бы ещё указать каталог, где он находится.
+
+При повторном импорте модуля, запуска программы не происходит. Чтобы это исправить, применим функцию reload из модуля importlib:
+```py
+>>> importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA8'>
+>>> Mod1.perm1
+'3'
+```
+## 2.2 Импортированные модули заносятся в словарь - значение атрибута sys.modules
+```py
+>>> print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```py
+Для повторного импорта модуля и выполнения программы, удалим модуль из этого словаря. Затем снова повторим импорт и убедимся в выполнении программы.
+```py
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA8'>
+>>> print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> import Mod1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA8'>
+```
+Отличие importlib.reload() от sys.modules.pop() заключается в том, что importlib.reload() перезагружает модуль, выполняя его код заново, но не удаляет модуль из словаря. Он имеет тот же адрес в памяти и все зависимости от него остаются в силе. sys.modules.pop() убирает модуль из словаря, при повторном импорте он уже будет иметь другой адрес.
+
+## 2.3 Запуск модуля на выполнение с помощью функции exec()
+Здесь модуль не требуется импортировать. Функция exec действует так, как будто на месте обращения к ней в программу вставлен код из объекта-аргумента функции. Но объект-модуль при этом не создается. Созданные при выполнении модуля объекты становятся объектами главной программы!
+```py
+>>> exec(open('Mod1.py').read()) 
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+# Здесь наблюдается проблема с кодировкой символов, файл был сохранён в одной кодировке, а Python хочет его прочитать в другой. Поэтому укажем явно кодировку
+>>> exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>> exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+>>> exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 9
+Mod1:Значение perm1= 9
+>>> perm1
+'9'
+```
+## 2.4 Использование инструкции from ... import ...
+В одном модуле может содержаться несколько функций или пользовательских объектов. Тогда можно осуществлять импорт модуля не целиком, а только часть содержащихся в нем объектов.
+
+Пример 1:
+```py
+>>> from Mod1 import perm1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>> print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> perm1
+'5'
+>>> from Mod1 import perm1
+>>> from Mod1 import perm1
+```
+Объект Mod1 появился в памяти, программа на выполнение вызвалась, аналогично использованию import. При последующем повторении команды ничего не происходит. Python хранит загруженные модули в sys.modules, при первом импорте выполняется весь код модуля, при повторном импорте Python просто берёт модуль из кэша.
+
+Пример2: С помощью текстового редактора создадим ещё один модуль Mod2, содержащий две функции:
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+Импортируем из этого модуля только функцию beta:
+```py
+>>> from Mod2 import beta
+>>> g=beta(2)
+****BETA****
+>>> g
+535.4916555247646
+>>> print(sorted(sys.modules.keys()))
+['Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> alpha()
+Traceback (most recent call last):
+  File "<pyshell#6>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+```
+Модуль Mod2 появился в списке. Функция alpha не была импортирована, поэтому и вышла ошибка. Теперь импортируем только функцию alpha, используя для неё псевдоним al:
+```py
+>>> from Mod2 import alpha as al
+>>> al()
+****ALPHA****
+Значение t=5
+'5'
+>>> del al,beta # Удаление импортированных объектов
+>>> from Mod2 import alpha as al, beta as bt # Импорт двух функций одной инструкцией
+>>> sys.modules.pop('Mod1') # Удаление импортированных объектов
+<module 'Mod1' from 'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA8'>
+>>> sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA8'>
+>>> from Mod2 import * # Импорт всего содержимого модуля
+>>> tt=alpha()  
+****ALPHA****
+Значение t=0.12
+>>> uu=beta(float(tt))
+****BETA****
+>>> uu
+1.4578913609506803
+```
+# 3. Создание многомодульных программ
+
+## 3.1 Пример простой многомодульной программы
+Создадим модуль Mod0 со следующим содержанием:
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+```
+Данный модуль содержит программу, вызывающую на выполнение ранее созданные модули Mod1, Mod2. Теперь программа будет состоять из 5 частей: главная программа, которой является командная строка IDLE и из которой будет вызываться модуль Mod0, и 3 модуля, вызываемых из модуля Mod0.
+```py
+>>> import Mod0
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+****ALPHA****
+Значение t=10
+tt= 10
+****BETA****
+qq= 44031505860631.98
+>>> Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+'10'
+44031505860631.98
+'3'
+```
+Переменная perm1 находится в пространстве имен модуля Mod1, а не модуля Mod0. Поэтому пришлось указывать не только имя модуля Mod0, но и имя модуля Mod1, в котором локализован объект.
+
+## 3.2 Пример
+Создадим модуль MM1, включив в него разработанные при выполнении предыдущей темы функции, реализующие усилитель, реальный двигатель, тахогенератор и нелинейное звено типа «зона нечувствительности». Затем создадим модуль ММ2, включив в него инструкции, обеспечивающие ввод параметров задачи, формирование входного сигнала, импорт модуля ММ1 и реализацию модели при расчете выходного сигнала. Модуль MM1:
+```py
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+    #Модель реального двигателя
+    yp = kk1 * xtt  #усилитель
+    yti1 = yp + yti1  #Интегратор
+    ytin1 = (yti1+TT*ytin1)/(TT+1)
+    return [yti1, ytin1]
+
+def tahogen(xtt,kk2,yti2):
+    #Модель тахогенератора
+    yp = kk2 * xtt   #усилитель
+    yti2 = yp + yti2 #интегратор
+    return yti2
+
+def nechus(xtt,gran):
+    if (xtt < gran) and (xtt > (-gran)):
+        ytt = 0
+    elif xtt >= gran:
+        ytt = xtt - gran
+    elif xtt <= (-gran):
+        ytt = xtt + gran
+    return ytt
+```
+Модуль MM2:
+```py
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1=float(znach[0])
+T=float(znach[1])
+k2=float(znach[2])
+Xm=float(znach[3])
+A=float(znach[4])
+F=float(znach[5])
+N=int(znach[6])
+
+import math
+vhod=[]
+for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+import MM1 as mod
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+	xt1=xt-yi2   #отрицательная обратная связь
+	[yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
+	yi2=mod.tahogen(yin1,k2,yi2)
+	yt=mod.nechus(yin1,Xm)
+	vyhod.append(yt)
+```
+Теперь создадим главную программу - модуль MM0, которая запускает на выполнение модуль MM2 и выводит полученный выходной сигнал:
+```py
+import MM2
+print('y=',MM2.vyhod)
+```
+Запустим модуль MM0:
+```py
+>>> import MM0
+k1,T,k2,Xm,A,F,N=8,5,3,10,2,0.5,1000
+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, ...]
+```
+## 3.3 Области действия объектов в модулях
+В ранее созданных модулях вводятся и используются следующие объекты: Mod1: perm1 Mod2: функции alpha, beta; переменные t, expi Mod0: переменные tt,qq
+
+Исходя из примеров, приведенных ниже, можно сказать, что объекты входящие в один модуль будут локализованы в этом модуле и доступны в нем. К переменным из другого модуля, даже импортированного в главный (выполняемый) модуль, прямого доступа не будет.
+
+## 3.3.1 Добавление в функцию alpha обращение к функции beta и, наоборот, из beta – к alpha. Изменим содержание файла Mod2.py:
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    beta(int(t))
+    return t
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+Запустим программу:
+```py
+>>> from Mod2 import *
+>>> alpha()
+****ALPHA****
+Значение t=5
+153552935.39544657
+'5'
+```
+Теперь добавим в функцию beta вызов функции alpha():
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    alpha()
+    return math.exp(expi)
+```
+Протестируем выполнение:
+```py
+>>> beta(6)
+****ALPHA****
+Значение t=5
+153552935.39544657
+```
+## 3.3.2 Отобразим на экране в модуле Mod0 значения объектов t и expi
+Изменим содержание Mod0:
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+print(t, expi)
+```
+Запустим на выполнение:
+```py
+>>> import Mod0
+perm1= 5
+****ALPHA****
+Значение t=10
+tt= 10
+qq= 44031505860631.98
+Traceback (most recent call last):
+  File "<pyshell#16>", line 1, in <module>
+    import Mod0
+  File 'C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA8'\Mod0.py", line 10, in <module>
+    print(t, expi)
+NameError: name 't' is not defined. Did you mean: 'tt'?
+```
+Выходит ошибка, потому что переменные t и expi определены в разных областях видимости и не доступны в модуле Mod0. В модуле Mod2: t - это локальная переменная функции alpha(), expi - это локальная переменная функции beta(). В модуле Mod0: мы пытаемся обратиться к переменным t и expi, которые никогда не были объявлены в этом модуле.
+
+## 3.3.3 Увеличение в модуле Mod0 в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+Изменим содержание Mod0:
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+Mod1.perm1 = str(int(Mod1.perm1)*3)
+print('Увеличение perm1 в 3 раза:', Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+```
+Тестирование программы:
+```py
+>>> import Mod0
+perm1= 30
+Увеличение perm1 в 3 раза: 90
+****ALPHA****
+Значение t=10
+tt= 10
+qq= 44031505860631.98
+```
+## 3.3.4 В командной строке необходимо увеличить в 2 раза значения объектов perm1, tt, qq
+```py
+>>> import Mod0
+perm1= 5
+****ALPHA****
+Значение t=10
+tt= 10
+qq= 44031505860631.98
+>>> Mod0.Mod1.perm1=str(int(Mod0.Mod1.perm1)*2)
+>>> Mod0.Mod1.perm1
+'10'
+>>> Mod0.tt=str(int(Mod0.tt)*2)
+>>> Mod0.tt
+'20'
+>>> Mod0.qq=Mod0.qq*2
+>>> Mod0.qq
+88063011721263.95
+```
+# 4. Завершение сеанса работы с IDLE

TEMA8/MM0.py

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

TEMA8/MM1.py

@@ -0,0 +1,22 @@
+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/Mod2.py

@@ -4,8 +4,7 @@ def alpha():
     return t
 
 def beta(q):
-    print('****BETA****')
     import math
     expi=q*math.pi
-    return math.exp(expi)
-    
+    alpha()
+    return math.exp(expi)

TEMA8/Modul1.py

@@ -0,0 +1,7 @@
+def read (file):
+    """"Чтение данных из файла"""
+    nums = []
+    with open(file, 'r') as file: # Открытие файла для чтения
+        for line in file:
+            nums.extend(map(float, line.split())) # Добавление всех элементов в список
+    return nums

TEMA8/Modul2.py

@@ -0,0 +1,16 @@
+def correlation(list1, list2):
+    """Расчёт коэффициента корреляции"""
+    n = min(len(list1), len(list2)) # Общая длина
+    list1 = list1[:n]
+    list2 = list2[:n]
+    mean1 = sum(list1) / n
+    mean2 = sum(list2) / n
+    chislitel = sum((list1[i] - mean1) * (list2[i] - mean2) for i in range(n))
+    #Числитель формулы корреляции
+    znamenatel1 = sum((x - mean1) ** 2 for x in list1)
+    znamenatel2 = sum((y - mean2) ** 2 for y in list2)
+
+    if znamenatel1 == 0 or znamenatel2 == 0:
+        return 0
+    
+    return chislitel/(znamenatel1 * znamenatel2) ** 0.5

TEMA8/Modul3.py

@@ -0,0 +1,8 @@
+import Modul1
+import Modul2
+file1 = input("Введите имя первого файла: ")
+file2 = input("Введите имя второго файла: ")
+list1 = Modul1.read(file1)
+list2 = Modul1.read(file2)
+corr = Modul2.correlation(list1, list2)
+print("Коэффициент корреляции:", corr)

TEMA8/data1.txt

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

TEMA8/data2.txt

@@ -0,0 +1,3 @@
+2 4 6
+8
+10 11

TEMA8/task.md

@@ -0,0 +1,71 @@
+ # Общее контрольное задание по теме 8
+
+
+ # Задание:
+1. Разработать программу, состоящую из трех модулей:
+Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+
+Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовить два текстовых  файла с числовыми данными и проверить по ним работу программы.
+
+
+ # Решение
+
+ ## 1. Модуль 1 - Чтение данных из файла
+```py
+def read (file):
+    """"Чтение данных из файла"""
+    nums = []
+    with open(file, 'r') as file: # Открытие файла для чтения
+        for line in file:
+            nums.extend(map(float, line.split())) # Добавление всех элементов в список
+    return nums
+```
+
+ ## 2. Модуль 2 - Расчёт коэффициента корреляции
+```py
+def correlation(list1, list2):
+    """Расчёт коэффициента корреляции"""
+    n = min(len(list1), len(list2)) # Общая длина
+    list1 = list1[:n]
+    list2 = list2[:n]
+    mean1 = sum(list1) / n
+    mean2 = sum(list2) / n
+    chislitel = sum((list1[i] - mean1) * (list2[i] - mean2) for i in range(n))
+    #Числитель формулы корреляции
+    znamenatel1 = sum((x - mean1) ** 2 for x in list1) # Знаменатель формулы корреляции
+    znamenatel2 = sum((y - mean2) ** 2 for y in list2)
+
+    if znamenatel1 == 0 or znamenatel2 == 0: # Проверка деления на 0
+        return 0
+    
+    return chislitel/(znamenatel1 * znamenatel2) ** 0.5
+```
+
+ ## 3. Модуль 3 - Запрос у пользователя и ввод имён файлов с исходными данными
+```py
+import Modul1
+import Modul2
+file1 = input("Введите имя первого файла: ")
+file2 = input("Введите имя второго файла: ")
+list1 = Modul1.read(file1)
+list2 = Modul1.read(file2)
+corr = Modul2.correlation(list1, list2)
+print("Коэффициент корреляции:", corr)
+```
+
+Были подготовлены два файла с данными data1.txt и data2.txt
+
+ ## 4. Тестирование
+```py
+>>> import Modul3
+Введите имя первого файла: data1.txt
+Введите имя второго файла: data2.txt
+Коэффициент корреляции: 0.9960784162656539
+```
+
+
+

TEMA9/9.md

@@ -0,0 +1,323 @@
+
+
+# 2 Создание классов и их наследников
+## 2.1 Создание автономного класса
+```py
+>>> class Class1:               #Объявление класса
+... 	def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
+... 		self.data=znach # self - ссылка на экземпляр класса
+... 	def otobrazh(self):     # Метод 2 класса1
+... 		print(self.data)#Отображение данных экземпляра класса
+... 
+```py
+Создали 2 экземпляра этого класса
+```py
+>>> z1=Class1()
+>>> z2=Class1()
+```
+С помощью первого метода задали разные значения атрибута у двух экземпляров
+```py
+>>> z1.zad_zn('экз.класса 1')
+>>> z2.zad_zn(-632.453)
+```
+Для контроля отобразили его значения с помощью второго метода
+```py
+>>> z1.otobrazh()
+экз.класса 1
+>>> z2.otobrazh()
+-632.453
+```
+Изменили значение атрибута у первого экземпляра и отобразили его
+```py
+>>> z1.data='Новое значение атрибута у экз.1'
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+## 2.2 Создание класса-наследника
+В объявлении класса после его имени в скобках перечисляются его «родительские классы»
+```py
+>>> class Class2(Class1):  #Class2 - наследник класса Class1
+... 	def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+... 		print('значение=',self.data)#Отображение данных экземпляра
+... 
+```
+Создали экземпляр второго класса
+```py
+>>> z3=Class2()
+>>> dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+```
+Задали у него значение данного data (унаследовано от Class1)
+```py
+>>> z3.zad_zn('Совсем новое')
+>>> z3.otobrazh()
+значение= Совсем новое
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+>>> del  z1,z2,z3
+```
+3 Использование классов, содержащихся в модулях
+
+Содержимое Mod3
+```py
+class Class1:               #Объявление класса Class1 в модуле
+	def zad_zn(self,znach): # 1 Метод класса
+		self.data=znach # self - ссылка на экземпляр класса Class1
+	def otobrazh(self):     # 2 Метод класса
+		print(self.data)#Отображение данных экземпляра
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2
+		print('значение=',self.data)#Отображение данных экземпляра
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)
+```
+Импортировали первый класс из модуля 
+```py
+>>> from Mod3 import Class1 #Частичный импорт содержимого модуля
+>>> z4=Class1()
+>>> z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\uprkt\Desktop\ПО\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+    print(self.data)#Отображение данных экземпляра
+AttributeError: 'Class1' object has no attribute 'data'
+```
+Ошибка возникает потому, что атрибут data еще не был создан для объекта z4.
+```py
+>>> from Mod3 import Class1
+>>> z4=Class1()
+>>> z4.data='значение данного data у экз.4'
+>>> z4.otobrazh()
+значение данного data у экз.4
+```
+Удалим экземпляр z4 и импортируем модуль
+```py
+>>> del z4
+>>> import Mod3
+```
+Создали экземпляр класса теперь инструкцией
+```py
+>>> z4=Mod3.Class2()
+>>> z4.zad_zn('Класс из модуля')
+>>> z4.otobrazh()
+значение= Класс из модуля
+>>> Mod3.otobrazh('Объект')
+значение объекта= Объект
+```
+Вызывается самостоятельная функция из модуля, а не метод класса
+
+## 4 Использование специальных методов
+Имена специальных методов предваряются одним или двумя подчерками и имеют вид: __<имя специального метода>__
+Для примера создали класс, содержащий два специальных метода
+```py
+>>> class Class3(Class2):  #Наследник класса Class2, а через него – и класса Class1
+...     def __init__(self,znach): #Конструктор-вызывается при создании нового экземпляра класса
+...         self.data=znach
+...     def __add__(self,drug_zn):  #Вызывается, когда экземпляр участвует в операции «+»
+...         return Class3(self.data+drug_zn)
+...     def zad_dr_zn(self,povtor):  #А это - обычный метод
+... 	    self.data*=povtor
+... 
+```
+Метод __add__ - это один из методов, осуществляющих так называемую «перегрузку» операторов.
+Для иллюстрации работы этих методов создали экземпляр класса Class3 и отобразили его
+```py
+>>> z5=Class3('abc')
+>>> z5.otobrazh()
+значение= abc
+```
+А теперь выполнили операцию «+» (должен сработать специальный метод __add__)
+```py
+>>> z6=z5+'def'
+>>> z6.otobrazh()
+значение= abcdef
+```
+Обратились к обычному методу класса:
+```py
+>>> z6.zad_dr_zn(3)
+>>> z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+5 Присоединение атрибутов к классу
+```py
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+Создали новый атрибут 
+```py
+>>> Class3.fio='Иванов И.И.'
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+Создали экземпляр
+```py
+>>> z7=Class3(123)
+>>> dir(z7)==dir(Class3)
+False
+>>> z7.fio
+'Иванов И.И.'
+```
+Обновили новый атрибут у созданного экземпляра 
+```py
+>>> z7.rozden='1987'
+>>> dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+## 6 Выявление родительских классов
+Такое выявление делается с помощью специального атрибута __bases__, например, вывели родительский класс для созданного класса Class3
+```py
+>>> Class3.__bases__
+(<class '__main__.Class2'>,)
+>>> Class2.__bases__
+(<class '__main__.Class1'>,)
+>>> Class1.__bases__
+(<class 'object'>,)
+```
+Для получения всей цепочки наследования использовали атрибут __mro__:
+```py
+>>> Class3.__mro__
+(<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
+```
+Получили всю цепочку наследования для встроенного класса ошибок «деление на ноль»:
+```py
+>>> ZeroDivisionError.__mro__
+(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+## 7 Создание свойства класса
+Свойство (property) класса – это особый атрибут класса, с которым можно производить операции чтения или задания его значения, а также удаление значения этого атрибута.
+Создали новый класс с определенным в нем свойством
+```py
+>>> class Class4:
+... 	def __init__(sam,znach):
+... 		sam.__prm=znach
+... 	def chten(sam):
+... 		return sam.__prm
+... 	def zapis(sam,znch):
+... 		sam.__prm=znch
+... 	def stiran(sam):
+... 		del sam.__prm
+... 	svojstvo=property(chten,zapis,stiran)
+... 
+```
+Обратили внимание на то, что здесь имеется 3 метода: chten, zapis, stiran, которые обслуживают созданное свойство, реализуя операции, соответственно, чтения, записи или удаления значений свойства. Теперь попробобавали некоторые операции с этим свойством
+```py
+>>> exempl=Class4(12)
+>>> exempl.svojstvo
+12
+>>> exempl.svojstvo=45
+>>> print(exempl.svojstvo)
+45
+>>> del exempl.svojstvo
+```
+После этого попробовали еще раз отобразить значение свойства
+```py
+>>> exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#61>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#55>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+Свойство было удалено. exempl.svojstvo → вызывает chten(). chten() пытается вернуть sam.__prm. Python ищет _Class4__prm (после преобразования). Атрибут удален → AttributeError
+## 8 Пример представления в виде класса модели системы автоматического регулирования (САР)
+```py
+class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+    
+    def model(self):
+        def inerz(x,T,yy):
+            return (x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 2
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
+        y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])
+```
+Проверка работы:
+```py
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+from 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])
+... 
+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
+>>> import pylab
+>>> pylab.plot(yt)
+[<matplotlib.lines.Line2D object at 0x0000028C363DA710>]
+>>> pylab.show()
+>>> prm=[5.5,2,6.3,0.9]
+>>> SAUe=SAU(prm)
+>>> yt=[]
+>>> for xt in xx:   # Прохождение входного сигнала
+...     SAUe.zdn_zn(xt)
+...     SAUe.model()
+...     SAUe.otobraz()
+...     yt.append(SAUe.ypr[1])
+... 
+y= 0.0
+y= 0.2511415525114155
+y= 0.5785429828402243
+y= 0.8608684291527201
+y= 1.0405548889736682
+y= 1.1123698572088563
+y= 1.1026104028422206
+y= 1.0485692602883017
+y= 0.9837333929415083
+y= 0.9303020862487426
+y= 0.8979490324812144
+y= 0.8865131776531742
+y= 0.8902188772938274
+y= 0.9016293565437798
+y= 0.9143726153161045
+y= 0.9244204691700071
+y= 0.9301876457452414
+y= 0.931925085592902
+y= 0.9308720026158589
+y= 0.9284995249411967
+y= 0.9260125207356777
+>>> pylab.plot(yt)
+[<matplotlib.lines.Line2D object at 0x0000028C385FB110>]
+>>> pylab.show()
+lin1
+```
+![](Ris1.png)

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/task.md

@@ -0,0 +1,65 @@
+
+Создать и записать в модуль класс, содержащий следующие компоненты:
+конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов, некоторые начальные значения;
+метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+метод для обеспечения перевода сотрудника из одного отдела в другой;
+метод для изменения должности сотрудника;
+свойство, содержащее перечень (список) поощрений сотрудника.
+Создать 2 экземпляра класса, задать им некоторые значения атрибутов и свойства. Отобразить эти значения. Попробовать с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+Решение
+```py
+>>> class Employee:
+...     def __init__(self, fio="", otdel="", dolzhnost="", oklad=0):
+...         self.fio = fio
+...         self.otdel = otdel
+...         self.dolzhnost = dolzhnost
+...         self.oklad = oklad
+...         self._pooshchreniya = []  # исправлено на единое имя
+...     
+...     def povyshenie_oklad(self, summa):
+...         if summa > 0:
+...             self.oklad += summa
+...             return self.oklad
+...         else:
+...             print("Сумма для повышения оклада должна быть больше нуля.")
+...     
+...     def perevod(self, new_otdel):
+...         self.otdel = new_otdel
+...         return self.otdel
+...    
+...    def cmena_dolzhnosty(self, new_dolzhnost):
+...        self.dolzhnost = new_dolzhnost
+...        return self.dolzhnost
+...    
+...    @property
+...    def pooshchrenia(self):
+...        return self._pooshchreniya  # исправлено на единое имя
+...    
+...    def add_pooshchrenie(self, pooshchrenie):
+...        self._pooshchreniya.append(pooshchrenie)  # исправлено на единое имя
+...        print(f"Сотрудник {self.fio} теперь имеет поощрение: {pooshchrenie}")
+...
+...        
+>>> emp_1=Employee ("Толчеев В.О.", "Кафедра Управления и информационных технологий", "Профессор", 150000)
+>>> emp_2=Employee ("Бобряков А.В.", "Кафедра Управления и информационных технологий", "Заведующий кафедрой", 1000000)
+>>> print(f"{emp_1.fio}, {emp_1.otdel}, {emp_1.dolzhnost}, оклад: {emp_1.oklad}")
+Толчеев В.О., Кафедра Управления и информационных технологий, Профессор, оклад: 150000
+>>> print(f"{emp_2.fio}, {emp_2.otdel}, {emp_2.dolzhnost}, оклад: {emp_2.oklad}")
+Бобряков А.В., Кафедра Управления и информационных технологий, Заведующий кафедрой, оклад: 1000000
+>>> emp_2.perevod("МТУСИ")
+'МТУСИ'
+>>> emp_2.povyshenie_oklad(10000)
+1010000
+>>> emp_1.cmena_dolzhnosty("Заведующий кафедрой")
+'Заведующий кафедрой'
+>>> emp_2.add_pooshchrenie("Выслуга лет")
+Сотрудник Бобряков А.В. теперь имеет поощрение: Выслуга лет
+>>> emp_1.add_pooshchrenie("Лучший проект")
+Сотрудник Толчеев В.О. теперь имеет поощрение: Лучший проект
+>>> print(f"Поощрения {emp_1.fio}: {emp_1.pooshchrenia}")
+Поощрения Толчеев В.О.: ['Лучший проект']
+>>> print(f"Поощрения {emp_2.fio}: {emp_2.pooshchrenia}")
+Поощрения Бобряков А.В.: ['Выслуга лет']
+
+```

TEMA9/zadanie1.md

@@ -0,0 +1,151 @@
+M3_1
+1)Создайте модуль М1, содержащий две функции:
+
+функция 1: аргумент - список или кортеж с выборкой; функция должна произвести расчет по выборке оценки её дисперсии DX, а также наименьшего и наибольшего значений и вернуть эти значения в вызывающую программу в виде списка;
+
+функция 2: аргументы - два списка или кортежа с выборками X и Y; функция должна произвести с помощью функции 1 расчет статистик по выборкам и  рассчитать статистику Фишера:
+
+		F=DX/DY
+
+2)Создайте еще один модуль М2, в котором должны выполняться следующие операции:
+
+запрашивается имя бинарного файла с выборками X и Y, проверяется его наличие и при отсутствии - повторяется запрос;
+
+выборки считываются из файлов;
+
+с помощью функции 1 по выборкам рассчитываются их статистики, 
+
+с помощью функции 2 рассчитывается значение статистики Фишера,
+
+если числа элементов в выборках одинаково, графически отображается поле рассеивания для Х и Y;
+
+результаты расчета с соответствующими заголовками выводятся в текстовый файл.
+
+3)Создайте модуль М0 - главную программу, которая вызывает М2 и отображает результаты расчета на экране.
+
+4)Создайте 2 бинарных файла: с выборками одинакового размера и с выборками разного размера. Проверьте программу с использованием этих файлов.
+
+Модуль 1
+```py
+import math
+def disp(s): # функция рассчета дисперсии
+    if len(s) == 0:
+        return [0, 0, 0]
+    sr = sum(s) / len(s)
+    v = sum((x - sr) ** 2 for x in s) / len(s)   # среднее квадратов отклонений от среднего
+    m_n = min(s)
+    m_x = max(s)
+    
+    return [v, m_n, m_x]
+
+def fisher_stat(sample_x, sample_y):  # статистика фишера
+    stats_x = disp(sample_x)
+    stats_y = disp(sample_y)
+    
+    dx = stats_x[0]  #  дисп х
+    dy = stats_y[0]  #  дисп у
+    
+    if dy == 0:
+        return 0, stats_x, stats_y
+    else:
+        f = dx / dy
+        return f, stats_x, stats_y
+```
+Модуль 2
+```py
+import pickle
+import matplotlib.pyplot as plt
+import M1  
+
+def load_samples(filename): #Загружаем выборки х и у
+
+    while True:
+        try:
+            with open(filename, 'rb') as f:
+                data = pickle.load(f)
+                x = data['X']
+                y = data['Y']
+                print(f"Файл {filename} успешно загружен!")
+                return x, y
+        except FileNotFoundError:
+            print(f"Файл {filename} не найден!")
+            filename = input("Введите имя файла снова: ")
+        except Exception as e:
+            print(f"Ошибка чтения файла: {e}")
+            filename = input("Введите имя файла снова: ")
+
+def analysis():
+    x, y = load_samples(input("Введите имя бинарного файла: "))
+    f, stats_x, stats_y = M1.fisher_stat(x, y) 
+    
+    print("\nРЕЗУЛЬТАТЫ РАСЧЕТА:")
+    print(f"Размер выборки X: {len(x)}, Y: {len(y)}")
+    print(f"X: Дисперсия={stats_x[0]:.4f}, мин={stats_x[1]:.4f}, макс={stats_x[2]:.4f}")
+    print(f"Y: Дисперсия={stats_y[0]:.4f}, мин={stats_y[1]:.4f}, макс={stats_y[2]:.4f}")
+    print(f"Статистика Фишера F = {f:.4f}")
+    
+    
+    if len(x) == len(y): # График размеры одинаковые
+        plt.figure(figsize=(8, 6))
+        plt.scatter(x, y, alpha=0.7, color='blue')
+        plt.xlabel('X')
+        plt.ylabel('Y')
+        plt.title('Поле рассеивания X-Y')
+        plt.grid(True)
+        plt.show()
+    
+    # Сохраняем в текстовый файл
+    with open('results.txt', 'w') as f:  # Сохраняем в файл
+        f.write("РЕЗУЛЬТАТЫ СТАТИСТИЧЕСКОГО АНАЛИЗА\n")
+        f.write(f"Размер выборки X: {len(x)}\n")
+        f.write(f"Размер выборки Y: {len(y)}\n\n")
+        f.write(f"СТАТИСТИКИ ПО X:\n")
+        f.write(f"  Дисперсия DX = {stats_x[0]:.6f}\n")
+        f.write(f"  Минимум      = {stats_x[1]:.6f}\n")
+        f.write(f"  Максимум     = {stats_x[2]:.6f}\n")
+        f.write(f"СТАТИСТИКИ ПО Y:\n")
+        f.write(f"  Дисперсия DY = {stats_y[0]:.6f}\n")
+        f.write(f"  Минимум      = {stats_y[1]:.6f}\n")
+        f.write(f"  Максимум     = {stats_y[2]:.6f}\n")
+        f.write(f"СТАТИСТИКА ФИШЕРА:\n")
+        f.write(f"  F = DX/DY = {f:.6f}\n")
+    
+    print("Результаты сохранены в файл results.txt")
+    return f, stats_x, stats_y
+
+if __name__ == "__main__":
+    analysis()
+```
+Модуль 0
+```py
+import M2
+
+def main():
+    
+    print("СТАТИСТИЧЕСКИЙ АНАЛИЗ")
+    results = M2.analysis() # Запускаем анализ
+    print("АНАЛИЗ ЗАВЕРШЕН!")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA9')
+>>> import M1
+>>> import M2
+>>> import M0
+>>> M0.main()
+СТАТИСТИЧЕСКИЙ АНАЛИЗ
+Введите имя бинарного файла: same_size.bin
+Файл same_size.bin успешно загружен!
+
+РЕЗУЛЬТАТЫ РАСЧЕТА:
+Размер выборки X: 20, Y: 20
+X: Дисперсия=4.7969, мин=1.4282, макс=9.9043
+Y: Дисперсия=3.2402, мин=2.1279, макс=7.5406
+Статистика Фишера F = 1.4804
+```
+![](Figure_1.png)