testt

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 <Сарайкина Вера Кирилловна>
+print('Hello')
+h=input('Vera')
+import os
+os.chdir('C:\\Users\\u207-09\\python-labs\\TEMA1\\')

TEMA1/report.md

@@ -0,0 +1,112 @@
+# Отчет по теме 1
+
+Сарайкина Вера, А-02-23.
+## Пункт 1
+ Создание рабочей папки
+на рабочем столе создала рабочую папку
+
+## Пункт 2 
+Запуск программы-интерпретатора
+
+ запустила программу "Python 3.4"
+
+## Пункт 3 
+Проверка работы интерпретатора
+
+```py
+print("Hello")
+```
+Hello
+
+## Пункт 4 
+Ввод еще 1 инструкции
+
+```py
+h = input("Your name = ")
+```
+Your name = Vera
+
+## Пункт 5
+Завершение работы с интерпретатором
+
+Ввела инструкцию:
+```py
+exit()
+```
+И таким образом вышла из интерпретатора
+
+## Пункт 6
+Запустила графическую оболочку IDLE 
+
+## Пункт 7
+Изучила окно среды
+
+## Пункт 8 
+Настройка рабочего каталога среды
+
+```py
+import os
+os.chdir('C:\\Users\\u207-09\\python-labs\\TEMA1')
+```
+Таким образом я настроила свой рабочий каталог в папе Тема1
+
+## Пункт 9 
+Изучила главное меню и сделала шрифт типа Arial CYR, размер 11, размер начального окна - высота 50 символов, ширина 100 символов, подкраска комментариев - коричневая
+
+## Пункт 10 
+Создание файла с интсрукциями
+
+```py
+# Протокол по Теме 1 <Сарайкина Вера Кирилловна>
+print('Hello')
+h = input('Your name = ')
+import os
+os.chdir('C:\\Users\\u207-09\\python-labs\\TEMA1')
+```
+Запустила эту программу 3 разными способами:
+Через run module,через f5 и через ввод инструкции:
+```py
+import Pr0
+```
+
+## Пункт 11
+Из консол вызван файл prb1.py 
+```py
+import prb1
+Как Вас зовут? Вера
+Привет, Вера
+```
+## Пункт 12
+Открыла файл в текстовом редакторе Pr0.cpython-34.pyc – результат работы компилятора среды.
+
+Результат компиляции тяжел для восприятия человеком з-за нессоответствия кодировок. 
+Компиляция необходима для того, чтобы переести команды в машинный код. при выполнении скрипта питон сначата преобразовывает его в байт- код, а затем компилруется с помощоью виртуальной машины. это ускорит полвторную загрузку программы.
+## Пункт 13
+Изучила программу help
+```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.
+```
+## Пункт 13
+Запустила другую программу из данного файла
+
+```py
+import tdemo_chaos
+```
+Рассмотрели файл в текстовом редакторе а затем с помощью меню запустили демонстрацию и выбрали несколько вариантов изображений
+![Скриншот диалога открытия файла](pic0.PNG)
+![Скриншот диалога открытия файла](pic1.PNG)
+## Пункт 14
+Завершен сеанс работы сосредой

TEMA2/report.md

@@ -0,0 +1,494 @@
+# Отчет по теме 2
+
+**Сарайкина Вера, А-02-23**
+
+### 1. Настройка текущего каталога
+```py
+import os
+os.chdir('C:\\Users\\Yarik\\Desktop\\labi\\python-labs\\TEMA2//')
+```
+
+### 2.Изучение простых объектов
+```py
+f1=16;f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+- Получение атрибутов и определение классовой принадлежности объекта f1
+```py
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+type(f2)
+<class 'int'>
+```
+- Удаление созданных переменных
+```py
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+### 3. Изучение правил именования объектов в Python. 
+Примеры правильных и неправильных имён:
+
+```py
+gg = 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']
+keywords = keyword.kwlist
+```
+
+### 5.Встроенные функции
+
+- Cписок встроенных идентификаторов
+```py
+import builtins
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+- Получение помощи по функциям и их применение
+```py
+help(abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+```
+В дальнейшем получение помощи не будет вставлено в отчёт.
+
+- Функции abs и len
+```py
+abs(-12)
+12
+len("Hello, World!")
+13
+list1=(12,14,63,24,32,52)
+len(list1)
+6
+```
+- Функции min и max
+```py
+max(12,14,63,24,32,52)
+63
+min(12,14,63,24,32,52)
+12
+max("Москва", "Санкт-Петербург", "Владивосток")
+'Санкт-Петербург'
+min("Москва", "Санкт-Петербург", "Владивосток")
+'Владивосток'
+```
+- Функции pow и round
+```py
+pow(12, 2)
+144
+pow(25, -2)
+0.0016
+pow(5, 2, 7)
+4
+round(3.14)
+3
+round(3.14135413, 1)
+3.1
+round(123.45, -1)
+120.0
+```
+- Функция сортировки и суммы 
+```py
+sorted({12,-32,42,11,-2,7,-42,63})
+[-42, -32, -2, 7, 11, 12, 42, 63]
+sorted({12,-32,42,11,-2,7,-42,63}, reverse=True)
+[63, 42, 12, 11, 7, -2, -32, -42]
+sorted(["Москва","Санкт-Петербург","Сочи","Владивосток","Архангельск"],key=len)
+['Сочи', 'Москва', 'Владивосток', 'Архангельск', 'Санкт-Петербург']
+sorted(["Москва","Санкт-Петербург","Сочи","Владивосток","Архангельск"])
+['Архангельск', 'Владивосток', 'Москва', 'Санкт-Петербург', 'Сочи']
+sum([10,41,11,3,8])
+73
+sum([10,41,11,3,8],12)
+85
+sum(x for x in range(3, 12))
+63
+```
+- Функция zip
+```py
+names = ["Анна", "Иван", "Мария"]
+ages = [25, 30, 28]
+cities = ["Москва", "Сочи", "Казань"]
+zip1 = list(zip(names, ages, cities))
+zip1
+[('Анна', 25, 'Москва'), ('Иван', 30, 'Сочи'), ('Мария', 28, 'Казань')]
+names.pop(1)
+'Иван'
+zip1
+[('Анна', 25, 'Москва'), ('Мария', 30, 'Сочи')]
+
+```
+
+### 6.Влияние регистра
+```py
+Gg1=45
+Gg1
+45
+gg1
+1.6
+```
+
+### 7.Простые базовые типы объектов
+#### 7.1 Логический тип
+```py
+bb1=True; bb2=False
+bb1;bb2
+True
+False
+type(bb1)
+<class 'bool'>
+```
+
+#### 7.2 Другие простые типы
+```py
+ii1=-1234567890
+ff1=-8.9876e-12
+dv1=0b1101010
+type(dv1)
+<class 'int'>
+vsm1=0o52765
+shest1=0x7109af6
+cc1=2-3j
+a=3.67; b=-0.45
+cc2=complex(a,b)
+cc2
+(3.67-0.45j
+```
+#### 7.3 Изучение строк 
+```py
+ss1='Это - строка символов'
+ss1="Это - строка символов"
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+ss1b= 'Меня зовут: \n <Сарайкина В. К.>'
+print(ss1b)
+Меня зовут: 
+ <Сарайкина В. К.>
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+- Способы обращений к частям строк и операция «разрезания» или «создания среза»
+```py
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+ss1[6:9]
+'стр'
+ss1[13:]
+'символов'
+ss1[:13]
+'Это - строка '
+ss1[5:-8]
+' строка '
+ss1[3:17:2]
+'  тоасм'
+ss1[17:3:-2]
+'омсаот '
+ss1[-4:3:-2]
+'омсаот '
+ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#86>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+ss1=ss1[:4]+'='+ss1[5:]
+print(ss1)
+Это = строка символов
+```
+-Создание объектов с разными срезами 
+```py
+ss1b[0]
+'М'
+ss1b[2]
+'н'
+ss1b[-5]
+'.'
+ss1b[3:7]
+'я зо'
+ss1b[:7]
+'Меня зо'
+ss1b[7:]
+'вут: \n <Сарайкина В. К.>'
+ss1b[11:2:-3]
+' уз'
+```
+#### 7.4 Создание объектов и проверка их типов 
+```py
+a = 11
+type(a)
+<class 'int'>
+b=11.11
+type(b)
+<class 'float'>
+c=3+7j
+type(c)
+<class 'complex'>
+d='vera'
+type(d)
+<class 'str'>
+e=True
+type(e)
+<class 'bool'>
+f=None
+type(f)
+<class 'NoneType'>
+```
+
+### 8. Сложные типы объектов
+
+#### 8.1 Списки
+```py
+spis1=[111,'Spisok',5-9j]
+stup=[0,0,1,1,1,1,1,1,1]
+spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+
+spis1[-1]
+(5-9j)
+stup[-8::2]
+[0, 1, 1, 1]
+spis1[1]='Список'
+print(spis1)
+[111, 'Список', (5-9j)]
+len(spis1)
+3
+```
+- Методы объекта находятся в списке его атрибутов
+```py
+dir()
+['Gg1', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'bb1', 'bb2', 'builtins', 'c', 'cc1', 'cc2', 'd', 'dv1', 'e', 'ff1', 'gg1', 'hh1', 'i', 'ii1', 'j', 'keyword', 'keywords', 'list1', 'mnogo', 'os', 'shest1', 'spis', 'spis1', 'ss1', 'ss1a', 'ss1b', 'stup', 'vsm1']
+help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+```
+- Методы добавления и удаления элемента в списке
+```py
+spis1.append(ss1b)
+print(spis1)
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n <Сарайкина В. К.>']
+spis1.pop(1)
+'Список'
+print(spis1)
+[111, (5-9j), 'New item', 'Меня зовут: \n <Сарайкина В. К.>']
+```
+- Изучение методов insert и remove
+```py
+spis1.insert(1,"осень")
+spis1.remove(111)
+print(spis1)
+['осень', (5-9j), 'New item', 'Меня зовут: \n <Сарайкина В. К.>']
+```
+- extend и clear
+```py
+spis1.extend([3, 5])
+spis2 =['11', 'a', 'b']
+spis1.extend(spis2)
+print(spis1)
+['осень', (5-9j), 'New item', 'Меня зовут: \n <Сарайкина В. К.>', 3, 5, '11', 'a', 'b']
+spis2.clear()
+print(spis2)   
+[]
+```
+- Метод sort 
+```py
+spis2 = [5, 4, 2, 3, 1]
+spis2.sort()
+print(spis2)
+[1, 2, 3, 4, 5]
+spis2.sort(reverse=True)
+print(spis2)
+[5, 4, 3, 2, 1]
+spis2.clear()
+spis2 = ['a', 'b', 'C', 'd']
+spis2.sort()
+print(spis2)
+['C', 'a', 'b', 'd']
+```
+- Методы reverse, count и copy
+```py
+spis2.reverse()
+print(spis2)
+['d', 'b', 'a', 'C']
+spis1.reverse()
+                 
+print(spis1)
+                 
+['b', 'a', '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень']
+copy1 = spis1.copy()
+copy2 = spis2.copy()
+print(copy1, copy2)
+['b', 'a', '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень'] ['d', 'b', 'a', 'C']
+spis1.count('a')
+1
+spis2.count('a')
+1
+spis1.count(11)
+1
+spis2.count(100)
+0
+spis1.index('New item')
+6
+spis2.index('b')
+1
+spis1.index(3)
+4
+```
+- Вложенные списки и обращение к элементам в них
+```py
+spis2=[spis1,[4,5,6,7]]
+print(spis2)
+[['b', 'a', '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень'], [4, 5, 6, 7]]
+spis2[0][1]
+'a'
+spis2[0][1]=78
+print(spis2)
+[['b', 78, '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень'], [4, 5, 6, 7]]
+print(spis1)
+['b', 78, '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень']
+#Когда мы изменяем spis2[0][1], то мы изменяем второй элемент списка spis1, так как spis2[0] и spis1 - это один и тот же объект в памяти.
+spisok = [768, "Hello", True, [1, 2, 3], spis1.copy()]
+                 
+print(spisok)
+                 
+[768, 'Hello', True, [1, 2, 3], ['b', 78, '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень']]
+
+#### 8.2 Объект-кортеж 
+- Создание кортежа, переопределение и методы
+```py
+kort1=(222,'Kortezh',77+8j)
+print(kort1)
+(222, 'Kortezh', (77+8j))
+kort1= kort1+(1,2)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1= kort1+(ss1b,)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n <Сарайкина В. К.>')
+kort2=kort1[:2]+kort1[3:]
+print(kort2)
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n <Сарайкина В. К.>')
+kort1.index(2)
+4
+kort1.count(222)
+1
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#201>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+- Создание своего кортежа
+```py
+print(my_tuple)
+                 
+(87, 'proga', [1, 2, 3], (4, 5, 6))
+```
+
+#### 8.3 Объект-словарь
+
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+dic1['Orel']
+56
+dic1['Pskov']=78   
+dic1        
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+
+- Сортировка словарей 
+```py
+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'
+```
+- Создание словарей с помощью функций dict и zip
+```py
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут-\n <Похил А.А>'}
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут-\n <Похил А.А>'}
+```
+- Создание своего словаря
+```py
+kortezh = (4, 'h', 6, True, 11, (1,6), 'cucumber')
+                 
+spisok = [11, 'b', 5.71, False, 'tomato']
+                 
+slovar = dict(zip(kortezh, spisok))
+                 
+slovar
+                 
+{4: 11, 'h': 'b', 6: 5.71, True: False, 11: 'tomato'}
+
+```
+Длина словаря равна 5, потому что функция zip() создает пары только до длины более короткой коллекции (списка из 5 элементов)
+
+
+#### 8.4 Объект-множество
+
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'датчик', 'двигатель', 'микропроцессор', 'линия связи'}
+```
+- Некоторые операции с множеством 
+```py
+len(mnoz1)
+4
+'датчик' in mnoz1
+True
+mnoz1.add('реле')
+mnoz1.remove('линия связи')
+mnoz1
+{'реле', 'датчик', 'двигатель', 'микропроцессор'}
+```
+- Создание своего объекта
+```py
+s1={True,2,4.2,'mpei', True}
+len(s1)
+4
+s1
+{'mpei', True, 2, 4.2}
+'mpei' in s1
+True
+```

TEMA2/task.md

@@ -0,0 +1,63 @@
+# Общее контрольное задание по теме 2
+
+**Сарайкина Вера, А-02-23**
+
+## Задание 
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия
+1. Создать переменную с именем familia и со значением - символьной строкой – своей фамили-ей в латинской транскрипции.
+2. Создать переменную со значением, совпадающим с первой буквой из familia.
+3. Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+4. Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+5. Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+6. Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
+7. Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+8. Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные перемен-ные, соответствующие этим типам. 
+## Решение
+#### 1. Создание переменной familia.  
+```py
+familia = 'Saraikina'
+```
+
+#### 2. Создание переменной, которая равна первой букве familia.
+```py
+firstL = familia[0]
+```
+#### 3. Создание переменной с именем sp_kw.
+```py
+import keyword
+dir(keyword)
+['__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'iskeyword', 'issoftkeyword', 'kwlist', 'softkwlist']
+sp_kw = keyword.kwlist
+```
+
+#### 4. Удаление из списка sp_kw значения 'nonlocal'.
+```py
+sp_kw.remove('nonlocal')
+print(sp_kw)
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+#### 5. Создание кортежа names.
+```py
+names = ('Вера', 'Елизавета', 'Татьяна', 'Стас')
+type(names)
+<class 'tuple'>
+```
+#### 6. Добавление в names имена двух студентов. 
+```py
+names = names + ('Анастасия', 'Дана')
+names
+('Вера', 'Елизавета', 'Татьяна', 'Стас', 'Анастасия', 'Дана')
+```
+
+#### 7. Определяю, сколько раз в кортеже присутствуют студенты с именем «Дима».
+```py
+names.count('Дима')
+0
+```
+#### 8. Создание словаря dict_bas.
+```py
+dict_bas = {'строка': [familia,firstL],'список': sp_kw,'кортеж': names}
+                 
+print(dict_bas)
+{'строка': ['Saraikina', 'S'], 'список': ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'], 'кортеж': ('Вера', 'Елизавета', 'Татьяна', 'Стас', 'Анастасия', 'Дана')}
+```

TEMA2/tesst1.md

@@ -0,0 +1,39 @@
+# Тест по модулю 1. Вариант 16
+Сарайкина Вера, А-02-23
+
+## 1)
+	Какие способы могут использоваться для получения помощи при работе со средой Python?
+
+## для плучения помощи можно воспользоваться командой help(), где в скобочкках необходимо указать коману,по которой требуется помощь, так же в интерактивном меню IDLE есть раздел "help", где так же можно посмотреть помощь, еще помощь можно получить через официальную документацию python
+
+## 2)	Создайте объект-строку с текстом: "Среда Python - эффективное средство разработки ПО". Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+```py
+s = "Среда Python - эффективное средство разработки ПО"
+type(s)
+<class 'str'>
+dir(s)
+['__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']
+```
+## 3)	Напишите инструкцию, создающую новую строку добавлением перед словом "эффективное" слова "очень". Отобразите получившийся объект.
+```py
+a = s.replace("эффективное", "очень эффективное")
+print(a)
+Среда Python - очень эффективное средство разработки ПО
+```
+## 4)	Преобразуйте строку в список. Отобразите полученный объект. Подсчитайте, сколько раз в этот список входит символ "е". Проверьте, есть ли в этом списке символ "Q".
+```py
+spis=list(a)
+print(spis)
+['С', 'р', 'е', 'д', 'а', ' ', 'P', 'y', 't', 'h', 'o', 'n', ' ', '-', ' ', 'о', 'ч', 'е', 'н', 'ь', ' ', 'э', 'ф', 'ф', 'е', 'к', 'т', 'и', 'в', 'н', 'о', 'е', ' ', 'с', 'р', 'е', 'д', 'с', 'т', 'в', 'о', ' ', 'р', 'а', 'з', 'р', 'а', 'б', 'о', 'т', 'к', 'и', ' ', 'П', 'О']
+spis.count("е")
+5
+"Q" in spis
+False
+```
+## 5)	Создайте на основе строки кортеж с подстроками, разделенными в исходной строке символами "пробел".
+```py
+kort=tuple(a.split( ))
+print(kort)
+('Среда', 'Python', '-', 'очень', 'эффективное', 'средство', 'разработки', 'ПО')
+
+```

TEMA3/report.md

@@ -0,0 +1,696 @@
+# Отчет по теме 3
+
+Сарайкина Вера, А-02-23
+
+### 1. Настройка текущего каталога.
+```py
+import os
+os.chdir('C:\\Users\\Yarik\\Desktop\\labi\\python-labs\\TEMA2//')
+
+```
+### 2. Преобразование простых базовых типов объектов.
+
+#### 2.1. Преобразование в логический тип с помощью функции bool(<Объект>)
+
+```py
+logiz1 = bool(56)
+logiz2 = bool(0)
+logiz3 = bool("Beta")
+logiz4 = bool("")
+logiz1
+True
+logiz2
+False
+logiz3
+True
+logiz4
+False
+type(logiz1)
+<class 'bool'>
+```
+
+#### 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления
+- Примеры использования функции int:
+
+```py
+tt1 = int(198.6)
+tt1
+198
+tt2 = int("-76")
+tt2
+-76
+tt3 = int("B",16)
+tt3
+11
+tt4 = int("71",8)
+tt4
+57
+tt5 = int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#19>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+- Преобразование целых чисел или строк символов в вещественное число 
+
+```py
+flt1 = float(789)
+flt1
+789.0
+flt2 = float(-6.78e2)
+flt2
+-678.0
+flt3 = float("Infinity")
+flt3
+inf
+flt4 = float("-inf")
+flt4
+-inf
+```
+
+#### 2.3. Преобразование десятичных чисел в другие системы счисления:
+
+```py
+hh = 567
+dv1 = bin(hh)  #Преобразование в строку с двоичным представлением
+vos1 = oct(hh)  # Преобразование в строку с восьмеричным представлением
+shs1 = hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+dv1
+'0b1000110111'
+vos1
+'0o1067'
+shs1
+'0x237'
+int(dv1,2)
+567
+int(vos1, 8)
+567
+int(shs1, 16)
+567
+```
+
+### 3. Преобразования более сложных базовых типов объектов.
+
+#### 3.1. Преобразование в строку символов
+
+
+```py
+strk1 = str(23.6)
+strk1
+'23.6'
+strk2 = str(logiz3)
+strk2
+'True'
+strk3 = str(["A","B","C"])  #Преобразуем список
+strk3
+"['A', 'B', 'C']"
+strk4 = str(("A","B","C"))  #Преобразуем кортеж
+strk4
+"('A', 'B', 'C')"
+strk5 = str({"A":1,"B":2,"C":9})  #Преобразуем словарь
+strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+
+#### 3.2. Преобразование элементов объекта в список
+
+```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']
+```
+- Методы .values(), .items()
+
+```py
+spis3 = list({"A":1,"B":2,"C":9}.values())
+spis3
+[1, 2, 9]
+spis3 = list({"A":1,"B":2,"C":9}.items())
+spis3
+[('A', 1), ('B', 2), ('C', 9)]
+```
+#### 3.3. Преобразование элементов объектов в кортеж
+
+```py
+kort7 = tuple('Строка символов')  #Преобразование строки символов в кортеж
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8 = tuple(spis2)  #Преобразование списка в кортеж
+kort8
+(124, 236, -15, 908)
+kort9 = tuple({"A":1,"B":2,"C":9})  #Преобразование словаря в кортеж
+kort9
+('A', 'B', 'C')
+```
+
+#### 3.4. Удаление обьектов
+
+```py
+del strk5, kort8
+strk5
+Traceback (most recent call last):
+  File "<pyshell#62>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+kort8
+Traceback (most recent call last):
+  File "<pyshell#63>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+str_A = "Сарайкина В.К"
+spis_A = list(str_A)
+spis_A
+['С', 'а', 'р', 'а', 'й','к','и','н','а', ' ', 'В', '.', 'К']
+kort_A = tuple(spis_A)
+kort_A
+('С', 'а', 'р', 'а', 'й','к','и','н','а', ' ', 'В', '.', 'К')
+str_AA = str(kort_A)
+str_AA
+"('С', 'а', 'р', 'а', 'й','к','и','н','а', ' ', 'В', '.', 'К')"
+```
+
+### 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'>
+d = 33.3//11
+d
+3.0
+type(d)
+<class 'float'>
+d = 9//3
+d
+3.0
+type(d)
+<class 'float'>
+d = 11//55
+d
+0
+type(d)
+<class 'int'>
+
+```
+
+#### 4.5. Получение остатка от деление
+
+```py
+148%33  #Остаток от деления двух целых чисел
+16
+12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+43.2%12
+7.200000000000003
+323%23.2
+21.40000000000001
+```
+
+#### 4.6. Возведение в степень
+
+```py
+14**3  #Целое число возводится в целую степень
+2744
+e = 2.7**3.6  #Вещественное число возводится в вещественную степень
+e
+35.719843790663525
+23**1.9
+386.6187287073183
+1.7**13
+990.4578032905933
+```
+
+#### 4.7. Операции с комплексными числами
+
+```py
+z1 = 2 + 5j
+z2 = 4 - 3j
+z1 + z2
+(6+2j)
+z1 * z2
+(23+14j)
+z1 / z2
+(-0.28+1.04j)
+z1 // z2
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    z1//z2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+z1 % z2
+Traceback (most recent call last):
+  File "<pyshell#11>", line 1, in <module>
+    z1%z2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+z1**z2
+(28648.976313547988-8542.480374144212j)
+```
+
+### 5. Операции с двоичными представлениями целых чисел.
+
+#### 5.1. Двоичная инверсия
+
+```py
+dv1 = 9
+dv2 = ~dv1
+dv2
+-10
+```
+
+#### 5.2. Двоичное "И"
+
+```py
+7 & 9  # 111 и 1001 = 0001
+1
+7 & 8  # 111 и 1000 = 0000
+0
+```
+
+#### 5.3. Двоичное "ИЛИ"
+
+```py
+7 | 9     # 111 или 1001 = 1111
+15
+7 | 8     # 111 или 1000 = 1111
+15
+14 | 5   # 1110 или 0101 = 1111
+15
+```
+
+#### 5.4. Двоичное «исключающее ИЛИ»
+
+```py
+14 ^ 5  # 1110 исключающее или 0101 = 1011
+11
+```
+
+Число 11 получилось при переводе 1011 из двоичной системы в десятичную.
+
+#### 5.5. Сдвиг двоичного представления на заданное число разрядов влево или вправо с дополнением нулями
+
+```py
+h = 14   #Двоичное представление = 1110
+g = h<<2  # Новое двоичное представление = 111000
+g
+56
+g1 = h>>1  # Новое двоичное представление = 0111
+g1
+7
+g2 = h>>2  # Новое двоичное представление = 0011
+g2
+3
+h0 = 134
+bin(h0)
+'0b10000110'
+g0 = h0<<1
+g0
+268
+bin(g0)
+'0b100001100'
+g0 = h0>>3
+g0
+16
+bin(g0)
+'0b10000'
+```
+Создание двух двоичных чисел с 7-ю знаками и выполнение операций над ними:
+
+
+```py
+b1 = int("1110011",2)
+b2 = int("1000101",2)
+b_2 = ~b2
+b_2
+-70
+b1 & b2
+65
+b1 | b2
+119
+b1^b2
+54
+b1 >> 1
+57
+b2 << 3
+552
+b1
+115
+b2
+121
+```
+
+### 6. Операции при работе с последовательностями (строками, списками, кортежами).
+
+#### 6.1. Объединение последовательностей (конкатенация)(+)
+
+```py
+'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+#### 6.2. Повторение(*)
+
+```py
+'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1 = [0]*3 + [1]*99
+signal2 = (0,)*3 + (1,)*5 + (0,)*7
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+
+#### 6.3. Проверка наличия заданного элемента в последовательности (in)
+
+```py
+stroka = 'Система автоматического управления'
+'автомат' in stroka  #Наличие подстроки в строке
+True
+'ку' in ['ку','-']*3  #Наличие контекста в списке
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+False
+```
+
+#### 6.4.Подстановка значений в строку с помощью оператора «%»
+
+```py
+stroka = 'Температура = %g %s  %g'
+stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+stroka = 'Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+### 7. Оператор присваивания
+
+#### 7.1. Обычное присваивание значения переменной (=)
+
+
+```py
+zz = -12
+zz
+-12
+```
+
+#### 7.2. Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+
+```py
+zz += 5   # Значение zz увеличивается на 5
+zz -= 3  # Значение уменьшается на 3
+zz
+-10
+stroka='Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+```
+
+#### 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+
+```py
+zz /= 2
+zz
+-5.0
+zz *= 5
+zz
+-25.0
+stroka='Система регулирования'
+stroka *= 2
+stroka
+'Система регулированияСистема регулирования'
+```
+
+#### 7.4.Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
+
+```py
+zz //= 7
+zz
+-4.0
+zz %= 3
+zz
+2.0
+zz **= 4
+zz
+16.0
+```
+
+##### 7.5. Множественное присваивание
+
+```py
+w = v = 10  # Переменным присваивается одно и то же значение
+w
+10
+v
+10
+n1,n2,n3 = (11,-3,'all')  #Значения переменных берутся из кортежа
+n1;n2;n3
+11
+-3
+'all'
+n1,n2,n3 = "11", "-3", "all"
+n1;n2;n3
+'11'
+'-3'
+'all'
+n1,n2,n3 = [11,-3,'all']
+n1;n2;n3
+11
+-3
+'all'
+n1,n2,n3 = {11: 1,-3:2,'all':3}
+n1;n2;n3
+11
+-3
+'all'
+```
+
+### 8. Логические операции.
+
+#### 8.1. Операции сравнения
+
+```py
+w = v = 10
+w != v
+False
+w == v
+True
+w > v
+False
+w < v
+False
+w >= v
+True
+w <= v
+True
+```
+
+#### 8.2. Проверка наличия заданного элемента в последовательности или в множестве
+
+```py
+mnoz1 = {'pen','book','pen','iPhone','table','book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+dic1 = {'Saratov':145, 'Orel':56, 'Vologda':45}
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+dct1 = {'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'MM'
+False
+```
+
+#### 8.3. Логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not)
+
+```py
+a = 17
+b = -6
+(a >= b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(12 < 13) and ('Vologda' in dic1) and not ('azbuka' in mnoz1)
+True
+(81 > 14) and (12 < 5) or ("Orel" in dic1)
+True
+```
+
+#### 8.4. Проверка ссылок переменных на один и тот же объект (is)
+
+```py
+w = v = 10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+w is v
+True
+w1 = ['A','B']
+v1 = ['A','B']
+w1 is v1 #Оператор is в Python проверяет, ссылаются ли две переменные на один и тот же объект в памяти, а не на одинаковые значения.
+False
+```
+
+### 9. Операции с объектами, выполняемые с помощью методов.
+
+```py
+stroka = 'Микропроцессорная система управления'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+#### 9.1. Методы для работы со строками
+
+```py
+stroka.find('пр')  #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+4
+stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+spis22 = stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит заданный разделитель
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()  #Возвращает строку со всеми заглавными буквами
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3 = " ".join(spis22)  #Возвращает строку, собранную из элементов списка
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+strk1 = 'Момент времени {}, значение = {}'
+strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+strk2 = 'Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+strk3 = 'Момент времени {num}, значение = {znch}'
+strk3.format(znch = 89.7,num = 2)
+'Момент времени 2, значение = 89.7'
+```
+
+#### 9.2. Методы для работы со списками
+
+```py
+spsk = [2, 4, 1, 7, 'a']
+dir(spsk)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+spsk.pop(2)
+1
+spsk
+[2, 4, 7, 'a']
+spsk.append('c')
+spsk
+[2, 4, 7, 'a', 'c']
+spsk.insert(2, 'a')
+spsk
+[2, 4, 'a', 7, 'a', 'c']
+spsk.count('a')
+2
+```
+
+#### 9.3. Методы для работы с кортежами
+
+```py
+t = (3, 3, 5, 6, 7)
+dir(t)
+['__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']
+t.count(3)
+2
+t.index(7)
+4
+len(t)
+5
+t[1]
+3
+```
+
+#### 9.4. Методы для работы со словарями и множествами
+
+```py
+#словарь
+d = {'a': 1, 'b': 2, 'c': 3, 'd':4}
+dir(d)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+d.keys()
+dict_keys(['a', 'b', 'c', 'd'])
+d.values()
+dict_values([1, 2, 3, 4])
+d.get('b')
+2
+d.update({'t': 4})
+e
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
+#множество
+s = {2, 4, 7, 1, 3}
+dir(s)
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+s.add(5)
+s
+{1, 2, 3, 4, 5, 7}
+s.remove(4)
+s
+{1, 2, 3, 5, 7}
+s.intersection({1, 7}) #пересечение множеств
+{1, 7}
+```
+
+### 10. Закончен сеанс работы с IDLE.

TEMA3/task.md

@@ -0,0 +1,39 @@
+# Тест по модулю 1. Вариант 16
+Сарайкина Вера, А-02-23
+
+## 1)
+	Какие способы могут использоваться для получения помощи при работе со средой Python?
+
+## для плучения помощи можно воспользоваться командой help(), где в скобочкках необходимо указать коману,по которой требуется помощь, так же в интерактивном меню IDLE есть раздел "help", где так же можно посмотреть помощь, еще помощь можно получить через официальную документацию python
+
+## 2)	Создайте объект-строку с текстом: "Среда Python - эффективное средство разработки ПО". Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+```py
+s = "Среда Python - эффективное средство разработки ПО"
+type(s)
+<class 'str'>
+dir(s)
+['__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']
+```
+## 3)	Напишите инструкцию, создающую новую строку добавлением перед словом "эффективное" слова "очень". Отобразите получившийся объект.
+```py
+a = s.replace("эффективное", "очень эффективное")
+print(a)
+Среда Python - очень эффективное средство разработки ПО
+```
+## 4)	Преобразуйте строку в список. Отобразите полученный объект. Подсчитайте, сколько раз в этот список входит символ "е". Проверьте, есть ли в этом списке символ "Q".
+```py
+spis=list(a)
+print(spis)
+['С', 'р', 'е', 'д', 'а', ' ', 'P', 'y', 't', 'h', 'o', 'n', ' ', '-', ' ', 'о', 'ч', 'е', 'н', 'ь', ' ', 'э', 'ф', 'ф', 'е', 'к', 'т', 'и', 'в', 'н', 'о', 'е', ' ', 'с', 'р', 'е', 'д', 'с', 'т', 'в', 'о', ' ', 'р', 'а', 'з', 'р', 'а', 'б', 'о', 'т', 'к', 'и', ' ', 'П', 'О']
+spis.count("е")
+5
+"Q" in spis
+False
+```
+## 5)	Создайте на основе строки кортеж с подстроками, разделенными в исходной строке символами "пробел".
+```py
+kort=tuple(a.split( ))
+print(kort)
+('Среда', 'Python', '-', 'очень', 'эффективное', 'средство', 'разработки', 'ПО')
+
+```

TEMA3/tesst1.md

@@ -0,0 +1,39 @@
+int('45', 8)
+37
+D = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+listK = list(D.keys())
+listV = list(D.values())
+listK
+['усиление', 'запаздывание', 'постоянная времени']
+listV
+[23, 12, 78]
+result1 = (keys_list, values_list)
+result1
+(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
+(1768 // 24.8 % 3) ** 2.4
+5.278031643091577
+((~(13 & 27) ^ 14) << 2)
+-32
+list1 = ['колебат'] * 4
+list1
+['колебат', 'колебат', 'колебат', 'колебат']
+'аткол' in (list1[1] + list1[2])
+True
+dir(D)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+list(D.keys())
+['усиление', 'запаздывание', 'постоянная времени']
+list(D.values())
+[23, 12, 78]
+object = "Создать объект - символьную строку с текстом данного предложения."
+object
+'Создать объект - символьную строку с текстом данного предложения.'
+newsp = object.split()
+newsp
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+newsp[newsp.index('-')] = ','
+newsp
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+newsp.remove('данного')
+newsp
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']

TEMA4/report.md

@@ -0,0 +1,313 @@
+# Отчет по теме 4
+
+Сарайкина Вера, А-02-23
+
+### 1. Настройка текущего каталога.
+```py
+import os
+os.chdir('C:\Users\Yarik\Desktop\labi\python-labs\TEMA4')
+```
+### 2. Стандартные функции.
+
+#### 2.1. Функция округления числа с заданной точностью
+
+```py
+help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+type(round(123.456,0))
+<class 'float'>
+type(round(123.456,1))
+<class 'float'>
+round(123.456)
+123
+type(round(123.456))
+<class 'int'>
+
+```
+
+#### 2.2. Функция range 
+
+```py
+gg=range(76,123,9)
+gg
+range(76, 123, 9)
+type(gg)
+<class 'range'>
+list(gg)
+[76, 85, 94, 103, 112, 121]
+range(23)
+range(0, 23)
+#range(23) создает последовательность целых чисел от 0 до 22 с шагом 1
+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 0x00000293529A1180>
+tuple(ff)
+((76, 'Похил'), (85, 'Сарайкина'), (94, 'Снегура'), (103, 'Шинкаренко'))
+ff[0]
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    ff[0]
+TypeError: 'zip' object is not subscriptable
+```
+
+
+## 2.4. Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки. 
+```py
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=5
+fff
+5.0
+dan
+-131.0
+```
+
+## 2.5. Функция exec – чтение и выполнение объекта-аргумента функции (Этот объект должен представлять собой строку символов  с совокупностью инструкций на языке Python)
+```py
+exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+```
+## 2.6.  Самостоятельное изучение функций abs, pow, max, min, sum, divmod, len, map. 
+```py
+gg
+221.456
+abs(-5)
+5
+pow(2, 3)
+8
+max([1, 5, 2])
+5
+min([1, 5, 2])
+1
+sum([1, 2, 3])
+6
+divmod(10, 3) # частное и остаток
+(3, 1)
+len("abc")
+3
+list(map(str, [1, 2, 3])) # применяет функцию к каждому элементу
+['1', '2', '3']
+```
+## 3.	Функции из стандартного модуля math – совокупность разнообразных математических функций.
+```py
+math.sin(3.14)
+0.0015926529164868282
+math.acos(0.5)
+1.0471975511965979
+math.degrees(1)
+57.29577951308232
+math.radians(57.29577951308232)
+1.0
+math.exp(1)
+2.718281828459045
+math.log(2.302585092994046) # натуральный логарифм
+0.834032445247956
+math.log10(100)
+2.0
+math.sqrt(16)
+4.0
+math.ceil(1.2) # округление вверх
+2
+math.floor(0.9) # округление вниз
+0
+math.pi
+3.141592653589793
+math.sin(2 * math.pi / 7 + math.exp(0.23))
+0.8334902641414562
+```
+## 4.	 Функции из модуля cmath – совокупность функций для работы с комплексными числами.
+```py
+import cmath
+dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+cmath.phase(1-0.5j) # угол в радианах
+-0.4636476090008061
+```
+## 5.	 Стандартный модуль random – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+```py
+import random
+dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+    If *a* is an int, all bits are used.
+
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+random.seed() #эта функция не имеет возвращаемых значений
+```
+Далее самостоятельно изучу и попробую применить следующие функции: random (равно-мерно распределенное случайное число), uniform (равномерно распределенное случайное число), randint (случайные целые числа), gauss (нормально распределенное случайное число), randint (случайное целое число), choice (случайный выбор из совокупности), shuffle (случайная переста-новка элементов списка), sample (случайный выбор подмножества элементов), betavariate(случайное число с бета-распределением), gammavariate(случайное число с гамма-распределением).
+```py
+random.random()
+0.6199792494543297
+random.uniform(1, 10)
+7.745269197841402
+random.randint(1, 6)
+3
+random.gauss(0, 1)
+1.0442172814729307
+random.choice(['a','b','c'])
+'b'
+lst = [1,2,3]; random.shuffle(lst)
+lst
+[3, 2, 1]
+random.sample([1,2,3,4], 2)
+[4, 2]
+random.betavariate(2, 5)
+0.27219690103691246
+random.gammavariate(2, 1)
+2.5239555636492557
+```
+Создам список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям и с любыми допустимыми значениями параметров этих распределений.
+```py
+spisok = [random.uniform(1, 10), random.gauss(0, 1), random.betavariate(2, 5), random.gammavariate(2, 1)]
+spisok
+[4.813064235823525, -0.2439125318449509, 0.12581423894318752, 1.940336067871031]
+```
+## 6.	 Функции из модуля time – работа с календарем и со временем.
+```py
+import time
+dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+c1=time.time()
+c2=time.time()-c1
+c2
+18.061716318130493
+c1
+1760287587.2442193
+dat=time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=16, tm_min=51, tm_sec=23, tm_wday=6, tm_yday=285, tm_isdst=0)
+dat.tm_mon
+10
+local_time = time.localtime()
+local_time
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=19, tm_min=54, tm_sec=1, tm_wday=6, tm_yday=285, tm_isdst=0)
+print(f"Год: {local_time.tm_year}")
+Год: 2025
+```
+Изучу и попробую применить функции: asctime (преобразование представления времени из кортежа в строку) , ctime (преобразование времени в секундах, прошедшего с начала эпохи, в строку), sleep (прерывание работы программы на заданное время), mktime (преобразова-ние времени из типа кортежа или struct_time в число секунд с начала эпохи). Обратное преобразование из секунд в местное время осуществляется той же функцией localtime()
+time.localtime(c1)
+```py
+c1 = time.time()
+local_struct = time.localtime(c1)
+local_struct
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=19, tm_min=59, tm_sec=42, tm_wday=6, tm_yday=285, tm_isdst=0)
+time_str = time.asctime(local_struct)
+time_str
+'Sun Oct 12 19:59:42 2025'
+time_str2 = time.ctime(c1)
+time.sleep(2)
+seconds = time.mktime(local_struct)
+seconds
+1760288382.0
+new_struct = time.localtime(seconds)
+new_struct
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=19, tm_min=59, tm_sec=42, tm_wday=6, tm_yday=285, tm_isdst=0)
+```
+## 7.	 Графические функции.
+```py
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+x
+[-3, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53]
+t
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x00000130A1F4E990>]
+pylab.title
+<function title at 0x00000130A1BD8F40>
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+```
+![](Ris1.png)
+
+Рассмотрим способ построения нескольких графиков на одном рисунке.
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000026ABB1756D0>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000026ABB175810>]
+>>> pylab.show()
+```
+![](Ris2.png)
+Изучение возможности построения круговой диаграммы
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>> naselen=[65,12,23,17]  # Значения для диаграммы
+>>> pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000026ABA668050>, <matplotlib.patches.Wedge object at 0x0000026ABD80B110>, <matplotlib.patches.Wedge object at 0x0000026ABD80B4D0>, <matplotlib.patches.Wedge object at 0x0000026ABD80B750>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()  #Отображение диаграммы
+```
+![](Ris3.png)
+попробую применить функции hist и bar для построения гистограмм и столбиковых диаграмм. 
+```py
+data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
+pylab.hist(data,5)
+(array([1., 2., 3., 2., 1.]), array([1. , 1.8, 2.6, 3.4, 4.2, 5. ]), <BarContainer object of 5 artists>)
+pylab.show()
+c = ['A', 'B', 'C']
+v = [10, 25, 15]
+pylab.bar(c, v)
+<BarContainer object of 3 artists>
+pylab.show()
+```
+получились следующие графики
+![](hist.png)
+![](bar.png)
+
+## 8.	Самостоятельное изучение состава статистического модуля statistics.
+```py
+data = [1, 2, 2, 3, 3, 3, 4, 4, 5] 
+import statistics 
+sred = statistics.mean(data) # среднее значение
+moda = statistics.mode(data) # Мода (наиболее частое значение)
+often
+3
+mediana = statistics.median(data) # медиана
+mediana
+3
+```

TEMA4/test.md

@@ -0,0 +1,26 @@
+Индивидуальное контрольное задание
+Сарайкина Вера, А-02-23
+Задание:
+10.Создайте кортеж с 5 значениями – случайными числами с равномерным законом распределения в интервале от 7.6 до 8.3. Создайте список со значениями, равными натуральным логарифмам от значений соответствующих элементов кортежа. Зафиксируйте текущее Московское время и отобразите его в виде строки «В Москве сейчас <значение> часов и <значение> минут».
+```py
+import random
+import math
+import time
+tuple1 = tuple(random.uniform(7.6, 8.3) for i in range(5))
+
+
+logarifm = [math.log(x) for x in tuple1]
+
+a = time.localtime()
+a
+
+print("Кортеж:", tuple1)
+print("Натуральные логарифмы:", logarifm)
+print("В Москве сейчас" ,time.localtime().tm_hour, "часов и", time.localtime().tm_min, "минут")
+```
+Вывод:
+```py
+Кортеж: (8.275202376847693, 8.108903471913068, 7.705466784938912, 7.724839785452687, 8.235811729418307)
+Натуральные логарифмы: [2.113263377380713, 2.092962652070268, 2.0419300490186827, 2.0444410828215127, 2.1084919294358673]
+В Москве сейчас 14 часов и 35 минут
+```

TEMA5/report.md

@@ -0,0 +1,277 @@
+# Отчет по теме 5
+
+**Сарайкина Вера, А-02-23**
+
+### Начало работы, изучение циклов и ветвлений
+### 1. Изучение ветвления if else
+- Множественное ветвление с помощью elif
+```py
+porog = 5
+rashod1 = 10
+rashod2 = 15
+if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+		dohod=-8	
+dohod
+12
+```
+#### 1.1 Проверка сложного условия 
+```py
+if rashod1>=3 and rashod2==4:
+		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+			dohod=porog
+dohod
+12
+```
+#### 1.2 Пример нескольких ветвей elif
+```py
+if porog==3:
+		dohod=1
+elif porog==4:
+		dohod=2
+elif porog==5:
+		dohod=3
+else:
+		dohod=0		
+dohod
+3
+```
+#### 1.3 Присваивание значения переменной с использованием условий if else
+```py
+dohod=2 if porog>=4 else 0
+dohod
+2
+```
+- Блок действий можно записать в строку 
+```py
+if porog>=5: rashod1=6; rashod2=0
+rashod1
+6
+```
+### 2. Изучения цикла for
+```py
+temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+temperatura
+50
+```
+#### 2.1 Комбинированние цикла for и if 
+```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]
+```
+- В цикле ниже создается копия списка 
+```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]
+
+import random as rn;sps5=[]
+
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+for i in range(10):
+	sps5.append(rn.randint(1,10))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+992
+
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)	
+453
+
+stroka='Это – автоматизированная система';stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss	
+stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+### 3. Запись цикла в строке
+```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 matplotlib.pyplot as plt
+pylab.plot(sps2,color='green',label = 'синусоидальный сигнал')
+[<matplotlib.lines.Line2D object at 0x0000023A2BB96900>]
+pylab.title('График синусоидального сигнала')
+Text(0.5, 1.0, 'График синусоидального сигнала')
+plt.show()
+```
+![](Figure_1.png)
+
+### 4. Изучение цикла while 
+```py
+rashod=300
+while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+
+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
+```
+- Построение графика
+```py
+import pylab
+pylab.plot(sps2,color='yellow')
+[<matplotlib.lines.Line2D object at 0x000001DE04A45550>]
+pylab.title('сигнал на выходе инерционного звена из списка sps2')
+Text(0.5, 1.0, 'сигнал на выходе инерционного звена из списка sps2')
+pylab.show()
+```
+![](Figure_2.png)
+### 5. Проврека, является ли число простым с помощью циклов
+```py
+chislo=267   #Проверяемое число
+kandidat =chislo // 2
+kandidat
+133
+while kandidat > 1:
+	if chislo%kandidat == 0: 	# Остаток от деления
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+else: 			# При завершении цикла без break
+	print(chislo, ' является простым!')
+267  имеет множитель  89
+
+for current in range(250,301,1):
+    kandidat = current // 2 
+    while kandidat > 1:
+        if current%kandidat == 0: 	# Остаток от деления
+            print(current, ' имеет делитель ', kandidat)
+            break 		# else выполняться не будет
+        kandidat -= 1
+    else: 			# При завершении цикла без break
+        print(current, ' является простым!')
+
+250  имеет множитель  125
+251  является простым!
+252  имеет множитель  126
+253  имеет множитель  23
+254  имеет множитель  127
+255  имеет множитель  85
+256  имеет множитель  128
+257  является простым!
+258  имеет множитель  129
+259  имеет множитель  37
+260  имеет множитель  130
+261  имеет множитель  87
+262  имеет множитель  131
+263  является простым!
+264  имеет множитель  132
+265  имеет множитель  53
+266  имеет множитель  133
+267  имеет множитель  89
+268  имеет множитель  134
+269  является простым!
+270  имеет множитель  135
+271  является простым!
+272  имеет множитель  136
+273  имеет множитель  91
+274  имеет множитель  137
+275  имеет множитель  55
+276  имеет множитель  138
+277  является простым!
+278  имеет множитель  139
+279  имеет множитель  93
+280  имеет множитель  140
+281  является простым!
+282  имеет множитель  141
+283  является простым!
+284  имеет множитель  142
+285  имеет множитель  95
+286  имеет множитель  143
+287  имеет множитель  41
+288  имеет множитель  144
+289  имеет множитель  17
+290  имеет множитель  145
+291  имеет множитель  97
+292  имеет множитель  146
+293  является простым!
+294  имеет множитель  147
+295  имеет множитель  59
+296  имеет множитель  148
+297  имеет множитель  99
+298  имеет множитель  149
+299  имеет множитель  23
+300  имеет множитель  150
+```

TEMA5/task .md

@@ -0,0 +1,89 @@
+## Общее контрольное задание по Теме 5
+
+Сарайкина Вера, А-02-23
+
+## Задание
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+•Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+•Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+•Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его сред-ние баллы по двум сессиям.
+
+## Решение
+
+### 1)Определение порядкового номера каждой буквы.
+```py
+str1 = "hello mpei"
+alfavit = "abcdefghijklmnopqrstuvwxyz"
+for i in str1:
+	if i in alfavit:
+		num = alfavit.index(i) + 1
+		print('В алфавите буква ',i,' под номером ',num)
+	else: continue
+
+	
+В алфавите буква  h  под номером  8
+В алфавите буква  e  под номером  5
+В алфавите буква  l  под номером  12
+В алфавите буква  l  под номером  12
+В алфавите буква  o  под номером  15
+В алфавите буква  m  под номером  13
+В алфавите буква  p  под номером  16
+В алфавите буква  e  под номером  5
+В алфавите буква  i  под номером  9
+
+```
+
+### 2)Наличие и отсутствие элемента в списке.
+
+```py
+str2 = """Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом)."""
+spis2 = str2.split()
+print(spis2)
+words = ["список","слово"]
+i = 0
+while i < len(words): #i - слово 1 и 2
+	word = words[i]
+	j = 0
+	while j < len(spis2):
+		if spis2[j] == word:
+			print('В списке нашелся элемент \"',word,'\"')
+			break
+		j += 1
+	else:
+		print('В списке элемент \"',word,'\" отсутствует')
+	i += 1 #переход ко второму слову в  words
+	
+В списке нашелся элемент " словами "
+В списке элемент " значения " отсутствует
+```
+
+### 3)Инструкция вывода среднего балла по заданной фамилии.
+
+```py
+studs = ['Похил','Криви','Сарайкина','Беженарь']
+ball = [4.8, 4.5, 4.7, 4.9]
+studs1 = ['Похил','Беженарь','Криви','Сарайкина']
+ball1 = [4.8, 5.0, 4.7, 4.7]
+ch = input('Фамилия студента: ')
+ball0 = 0
+for i in range(len(studs)):
+    if studs[i] == ch:
+        ball0 = ball[i]
+        break
+
+print('Средний балл летней сессии: ',ball0)
+
+ch1 = input('Фамилия студента: ')
+ball3 = 0
+for j in range(len(studs1)):
+    if studs1[i] == ch1:
+        ball3 = ball1[i]
+        break
+
+print('Средний балл зимней сессии: ',ball3)
+
+Фамилия студента: Похил
+Средний балл летней сессии:  4.8
+Фамилия студента: Сарайкина
+Средний балл зимней сессии:  4.7
+```

TEMA5/test.md

@@ -0,0 +1,26 @@
+Индивидуальное контрольное задание
+Сарайкина Вера, А-02-23
+Задание:
+19.Создайте строку с некоторым текстом на русском языке. Напишите инструкции разбора текста и формирования списка с элементами: номер символа в русском алфавите, если этот символ – согласная буква, тот же номер, взятый со знаком минус, если символ – гласная буква, и число 777, если это – любой другой символ.
+```py
+text='Пример текста для задания 19!'
+alphabet='абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+glasni='аеёиоуыэюя'
+soglasni='бвгджзйклмнпрстфхцчшщ'
+res=[]
+for i in text:
+    i=i.lower()
+    if i in alphabet:
+        index= alphabet.index(i)+1
+        if i in glasni:
+            res.append(-index)
+        elif i in soglasni:
+            res.append(index)
+    else:
+        res.append(777)
+print(res)
+```
+Вывод:
+```py
+[17, 18, -10, 14, -6, 18, 777, 20, -6, 12, 19, 20, -1, 777, 5, 13, -33, 777, 9, -1, 5, -1, 15, -10, -33, 777, 777, 777, 777]
+```

TEMA6/report .md

@@ -0,0 +1,268 @@
+# Отчет по теме 6
+
+**Сарайкина Вера, А-02-23**
+
+### 1.Начало работы, настройка текущего каталога
+```py
+import os
+os.chdir('C:\Users\Yarik\Desktop\labi\python-labs\TEMA6')
+```
+
+### 2.Вывод данных на экран дисплея
+#### 2.1 Эхо-вывод
+```py
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+#### 2.2 print  вывод
+```py
+fff=234.5;gg='Значение температуры = '
+print(gg, fff)   #Можно вывести несколько объектов за одно обращение к функции
+Значение температуры =  234.5
+print(gg, fff, sep='/')
+Значение температуры = /234.5
+print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+print()
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+#### 2.3 Стандартный поток вывода, модуль sys
+```py
+import sys
+sys.stdout.write('Функция write')
+Функция write13
+sys.stdout.write('Функция write\n')
+Функция write
+14
+help(sys.stdout.write)
+Help on method write in module idlelib.run:
+
+write(s) method of idlelib.run.StdOutputFile instance
+    Write string s to stream.
+
+    Return the number of characters written
+    (which is always equal to the length of the string).
+```
+### 3. Ввод c клавиатуры
+```py
+psw=input('Введите пароль:')
+Введите пароль:555550
+psw
+'555550'
+type(psw)
+<class 'str'>
+while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach<17.5 or znach>23.8:
+		print('Ошибка!')
+	else:
+		break
+
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+### 4.Ввод-вывод при работе с файлами
+#### 4.1 Функции для работы с путем к файлу
+- Настройка текущей директории
+```py
+import os
+os.getcwd()
+'C:\Users\Yarik\Desktop\labi\python-labs\TEMA6'
+Vera = os.getcwd()
+print(Vera)
+'C:\Users\Yarik\Desktop\labi\python-labs\TEMA6'
+os.getcwd()
+'C:\Users\Yarik\Desktop\labi\python-labs\TEMA6'
+```
+- Пробую методы вложенного модуля path
+```py
+os.listdir()
+['.DS_Store', 'hm', 'report.md', '.gitkeep']
+os.path.isdir('C:\Users\Yarik\Desktop\labi\python-labs\TEMA6')
+True
+os.path.isdir('python-labs/TEMA6')
+False
+os.path.abspath('report.md')
+'C:\Users\Yarik\Desktop\labi\python-labs\TEMA6/report.md'
+file = os.path.abspath('report.md')
+drkt=os.path.dirname(file)
+drkt
+'C:\Users\Yarik\Desktop\labi\python-labs\TEMA6'
+os.path.basename(file)
+'report.md'
+os.path.split(file)
+('C:\Users\Yarik\Desktop\labi\python-labs\TEMA6', 'report.md')
+os.path.exists(file)
+True
+os.path.exists(file+'eee')
+False
+```
+#### 4.3 Открытие/закрытие файла, функция open/close
+```py             
+help(open)
+fp=open(file=drkt+'//zapis1.txt',mode='w')
+drkt            
+'C:\Users\Yarik\Desktop\labi\python-labs\TEMA6'
+dir(fp)           
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+fp.close()     
+```
+#### 4.4 Запись в файл функция write
+```py  
+sps=list(range(1,13))  
+fp2=open('zapis3.txt','w')             
+fp2.write(str(sps[:4])+'\n');fp2.write(str(sps[4:8])+'\n');fp2.write(str(sps[8:])+'\n');fp2.close()             
+13
+13
+16
+```
+[!Данные записанные в файл](fig1.png)
+- Запись списка списков
+```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()
+
+gh=open('zapis5.txt','w')              
+for r in sps3:
+    gh.write(r[0]+' '+str(r[1])+'\n')               
+12
+12
+13
+gh.close()
+```
+#### 4.5  Чтение информации из текстового файла.
+```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()            
+print(sps1)             
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+```
+- Теперь элементы списков совпадают
+```py
+for i in range(len(sps1)):
+               sps1[i] = int(sps1[i])
+sps1==sps           
+True
+```
+#### 4.6 Чтение информации из файла с помощью метода read
+```py
+fp=open('zapis3.txt');stroka1=fp.read(12);stroka2=fp.read();fp.close()
+stroka1       
+'[1, 2, 3, 4]'
+stroka2            
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+- Изучение функции readline и readlines
+```py
+fp=open('zapis3.txt');stroka1=fp.readline()
+stroka1              
+'[1, 2, 3, 4]\n'
+
+stroka2=fp.readline(3)       
+stroka2           
+'[5,'
+fp.close()
+               
+fp=open('zapis3.txt');stroka1=fp.readlines()        
+stroka1         
+['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+fp.close()
+```
+#### 4.9 Ввод-вывод объектов с использованием функций из модуля pickle
+```py
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}
+fp=open('zapis6.mnz','wb')
+pickle.dump(mnoz1,fp)
+fp.close()
+
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)
+fp.close()
+```
+- Проверка объектов на совпадение
+```py
+mnoz2 == mnoz1
+True
+```
+- Отличие от исходного в том, что сохранились только уникальные элементы
+```py
+mnoz2
+{'table', 'book', 'iPhone', 'pen'}
+mnoz1
+{'table', 'book', 'iPhone', 'pen'}
+```
+- Запись/чтение нескольких объектов
+```py
+sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+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,obj2
+({'table', 'book', 'iPhone', 'pen'}, [['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]])
+obj1==mnoz1; obj2==sps3
+True
+True
+```
+### 5. Перенаправление потоков ввода и вывода данных
+- Перенаправление вывода в файл
+```py
+import sys
+vr_out=sys.stdout
+fc=open('Stroka.txt','w')
+sys.stdout=fc
+print('запись строки в файл')
+sys.stdout=vr_out
+print('запись строки на экран') 
+запись строки на экран
+fc.close()
+```
+- Перенаправление вввода из файла
+```py
+tmp_in = sys.stdin
+fd = open("Stroka.txt", "r")
+sys.stdin = fd
+while True:
+	try:
+		line = input () 
+		print(line)  
+	except EOFError:
+		break
+запись строки в файл
+fd.close()
+sys.stdin=tmp_in
+```

TEMA6/task.md

@@ -0,0 +1,63 @@
+# Общее контрольное задание по теме 6
+
+Сарайкина Вера, А-02-23
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+3. Записывается кортеж в бинарный файл.
+4. Записывается в этот же файл список и закрывается файл.
+5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+7. Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Выполнение
+
+1. Создание кортежа
+```py
+import random
+tup1=[]           
+for i in range(125): tup1.append(str(random.randint(6, 56)))
+tup1=tuple(tup1); tup1
+('46', '21', '28', '45', '35', '15', '42', '20', '20', '31', '32', '23', '25', '56', '16', '42', '11', '44', '15', '7', '41', '27', '27', '54', '51', '15', '20', '48', '52', '15', '38', '17', '19', '56', '22', '33', '16', '53', '19', '11', '31', '10', '7', '6', '15', '16', '20', '28', '44', '26', '24', '51', '16', '17', '38', '31', '28', '26', '25', '43', '16', '23', '34', '48', '33', '53', '26', '33', '38', '29', '8', '36', '49', '53', '49', '13', '51', '13', '49', '46', '35', '13', '12', '48', '25', '56', '50', '30', '6', '56', '9', '11', '16', '38', '33', '7', '16', '10', '47', '32', '43', '38', '10', '7', '12', '35', '22', '35', '12', '39', '15', '32', '27', '42', '52', '20', '51', '10', '22', '49', '26', '6', '12', '49', '22')        
+```
+
+2-4. Создание списка, запись кортежа и списка в бинарный файл, чтение обоих объектов из файла
+
+```py
+sps1=['Похил', 'Сарайкина', 'Цветкова', 'Шинкаренко', 'Снегура']
+import pickle
+fp=open('fil.mnz', 'wb')
+pickle.dump(tup1, fp)
+pickle.dump(sps1, fp)
+fp.close()
+fp=open('fil.mnz', 'rb')
+tup2=pickle.load(fp)
+sps2=pickle.load(fp)
+fp.close()
+```
+
+5. Проверка на совпадение объектов 
+
+```py
+print('Кортежи совпадают') if tup1 == tup2 else print('Кортежи не совпадают')
+Кортежи совпадают
+print('Списки совпадают') if sps1 == sps2 else print('Списки не совпадают')
+Списки совпадают
+```
+
+6. Разделение кортежа на списки по 5 чисел, представленных в строковом виде.
+
+```py
+for i in range(0, len(tup1), 5):
+    exec('spisk' + str(i//5+1) + '=' + str(list(tup1[i:i+5])))
+
+spisk1
+['46', '21', '28', '45', '35']
+spisk2
+['15', '42', '20', '20', '31']
+spisk3
+['32', '23', '25', '56', '16']
+```

TEMA6/test.md

@@ -0,0 +1,62 @@
+# Тест по модулю 2
+
+Сарайкина Вера, А-02-23
+
+## Задание
+
+M2_10
+1)	Создайте словарь с 3 элементами: ключи -  OTDEL, SOTRUD, DOLZHN, значения - списки, соответственно отделов предприятия (3-4 отдела с наименованиями вида "Отдел1":), список сотрудников (3-4 фамилии), список должностей сотрудников.
+
+2)	Запросите у пользователя и введите 3 целых числа: номер отдела по списку, порядковый номер сотрудника по списку, порядковый номер должности. Проверьте соответствие введенных чисел числу соответствующих элементов списков. При отсутствии соответствия повторить ввод.
+
+3)	Выведите на экран сообщение по шаблону: " Отдел: <название отдела из списка>, сотрудник: <ФИО сотрудника из списка>, должность: <название должности из списка> в соответствии с выбором пользователя и со значениями из словаря.
+
+4)	Запишите это же сообщение в текстовый файл с некоторым именем в режиме добавления строки.
+
+5)	Удалите из памяти все созданные объекты-переменные.
+
+
+## Выполнение
+```py
+# 1) Создание словаря
+data = {
+    'OTDEL': ['Отдел разработки', 'Отдел маркетинга', 'Отдел продаж'],
+    'SOTRUD': ['Иванов И.И.', 'Петров П.П.', 'Сидоров С.С.'],
+    'DOLZHN': ['Инженер', 'Менеджер', 'Аналитик']
+}
+
+# 2) Ввод данных с проверкой
+while True:
+    try:
+        # Ввод с проверкой преобразования в целое число
+        n_otdel = int(input("Введите номер отдела (1-3): "))
+        n_sotrud = int(input("Введите номер сотрудника (1-3): ")) 
+        n_dolzhn = int(input("Введите номер должности (1-3): "))
+        
+        # Проверка диапазона 
+        if n_otdel >= 1 and n_otdel <= 3 and n_sotrud >= 1 and n_sotrud <= 3 and n_dolzhn >= 1 and n_dolzhn <= 3:
+            break
+        else:
+            print("Ошибка: числа должны быть в диапазоне 1-3")
+    except:
+        print("Ошибка: введите целые числа")
+
+# 3) Формирование и вывод сообщения
+message = "Отдел: " + data['OTDEL'][n_otdel-1] + ", сотрудник: " + data['SOTRUD'][n_sotrud-1] + ", должность: " + data['DOLZHN'][n_dolzhn-1]
+print(message)
+
+# 4) Запись в файл 
+fp = open('report.txt', 'a')
+fp.write(message + '\n')
+fp.close()
+
+# 5) Очистка памяти
+del data, n_otdel, n_sotrud, n_dolzhn, message, fp
+```
+## Вывод
+```py
+Введите номер отдела (1-3): 2
+Введите номер сотрудника (1-3): 3
+Введите номер должности (1-3): 1
+Отдел: Отдел маркетинга, сотрудник: Сидоров С.С., должность: Инженер
+```

TEMA7/report.md

@@ -0,0 +1,599 @@
+# Отчёт по Теме 7
+
+Сарайкина Вера, А-02-23
+
+# 1. Запуск интерактивной оболочки IDLE
+
+# 2. Создание пользовательской функции
+
+Создание функции предполагает выполнение трех операций: формирование функции, ее сохра-нение и использование. 
+В общем виде функция в языке Python представляется так:
+def  <Имя функции>([<Список аргументов >]):
+[<отступы>"""<Комментарий по назначению функции>"""]
+<отступы><Блок инструкций – тело функции>
+[<отступы>return <Значение или вычисляемое выражение>]
+
+# 2.1 Функция без аргументов
+```py
+ef uspeh():
+	"""Подтверждение успеха операции"""
+	print('Выполнено успешно!')
+
+uspeh()
+Выполнено успешно!
+dir(uspeh)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+type(uspeh)
+<class 'function'>
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+
+## 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)
+
+n,m=16,5;sravnenie(n,m)
+16  больше  5
+sravnenie("abc", "abcd")
+abc  меньше  abcd
+```
+Функция универсальна и будет работать с любыми типами данных, для которых определены операторы сравнения >, <, == (числа, строки, списки, кортежи и др.)Сравнение строк происходит по алфавиту, так же значение имеет регистр букв (заглавные меньше строчных), более короткая строка считается меньшей.
+
+
+## 2.3 Пример функции, содержащей return.
+
+```py
+def logistfun(b,a):
+	"""Вычисление логистической функции"""
+	import math
+	return a/(1+math.exp(-b))
+
+    
+v,w=1,0.7;z=logistfun(w,v)
+z
+0.6681877721681662
+```
+
+## 2.4 Сложение для разных типов аргументов
+
+```py
+def slozh(a1,a2,a3,a4):
+	""" Сложение значений четырех аргументов"""
+	return a1+a2+a3+a4
+slozh(1,2,3,4)
+10
+slozh('1','2','3','4')
+'1234'
+b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+q=slozh(b1,b2,b3,b4)
+q
+[1, 2, -1, -2, 0, 2, -1, -1]
+t1 = (1, 2); t2 = (3, 4); t3 = (5,); t4 = (6, 7, 8)
+slozh(t1, t2, t3, t4)
+(1, 2, 3, 4, 5, 6, 7, 8)
+d1 = {'a': 1}; d2 = {'b': 2}
+slozh(d1, d2, {}, {})
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+s1 = {1, 2}; s2 = {2, 3}
+slozh(s1, s2, set(), set())
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+Как видно сложение для множеств и словарей не применимо. ункция slozh работает только для тех типов данных, которые поддерживают оператор +.
+
+## 2.5 Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
+
+```py
+def inerz(x,T,ypred):
+	""" Модель устройства с памятью:
+x- текущее значение вх.сигнала,
+	T -постоянная времени,
+	ypred - предыдущее значение выхода устройства"""
+	y=(x+T*ypred)/(T+1)
+	return y
+
+sps=[0]+[1]*100
+spsy=[] #Заготовили список для значений выхода
+TT=20 #Постоянная времени
+yy=0  #Нулевое начальное условие
+for xx in sps:
+	yy=inerz(xx,TT,yy)
+	spsy.append(yy)
+
+import matplotlib.pyplot as plt
+plt.plot(sps, 'r-', label='Вход')
+[<matplotlib.lines.Line2D object at 0x000001B544DC4E10>]
+plt.plot(spsy, 'b-', label='Выход')
+[<matplotlib.lines.Line2D object at 0x000001B544DF5090>]
+plt.grid(True)
+plt.legend()
+<matplotlib.legend.Legend object at 0x000001B544DD1E80>
+plt.show()
+```
+
+![График](Figure_1.png)
+
+
+# 3. Функции как объекты
+
+## 3.1 Получение списка атрибутов объекта-функции
+
+```py
+dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+inerz.__doc__
+'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\n        T -постоянная времени,\n        ypred - предыдущее значение выхода устройства'
+help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+    x- текущее значение вх.сигнала,
+            T -постоянная времени,
+            ypred - предыдущее значение выхода устройства
+```
+Атрибут __doc__ содержит значение docstring, если при инициализации функции он был задан. Если не был, то inerz.__doc__ будет иметь значение None.
+
+## 3.2 Сохранение ссылки на объект-функции в другой переменной
+
+```py
+fnkt=sravnenie
+v=16
+fnkt(v,23)
+16  меньше  23
+```
+
+Функции можно передавать в переменные, как и любые другие объекты. После этого переменная 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)
+zz
+-2.3318122278318336
+```
+
+Python передаёт ссылку на объект функции logistfun в переменную fff.
+
+## 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
+```
+
+## 4.4 Пример со значениями аргументов функции, содержащимися в списке или кортеже
+
+```py
+b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+Количество элементов в списке должно совпадать с количеством параметров функции. Оператор * выполняет распаковку списка в аргументы функции.
+
+## 4.5 Пример со значениями аргументов функции, содержащимися в словаре
+
+```py
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+qqq
+10
+slozh(*dic4)
+'a1a2a3a4'
+``` 
+Для ** распаковки имена ключей должны точно совпадать с именами параметров функции
+
+## 4.6 Смешанные ссылки
+
+```py
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+qqqq
+17
+```
+
+## 4.7 Переменное число аргументов у функции
+
+```py
+def func4(*kort7):
+	"""Произвольное число аргументов в составе кортежа"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return smm
+
+func4(-1,2)  #Обращение к функции с 2 аргументами
+1
+func4(-1,2,0,3,6)  #Обращение к функции с 5 аргументами
+10
+```
+Функция принимает любое количество аргументов
+
+## 4.8 Комбинация аргументов
+
+```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
+```
+a = -1 (первый позиционный)
+b = 2 (второй позиционный, переопределил значение по умолчанию 7)
+*kort7 = (0, 3, 6) (все остальные аргументы в кортеж)
+Если мы не хотим передавать b, придется переопределить функцию так, чтобы именованный параметр b был в конце, а позиционный кортеж - перед ним.
+
+Подобным же образом в списке аргументов функции также можно использовать словарь.
+
+```py
+def func5(a, b=7, *args, **kwargs):
+    """a-позиционный, b-по умолчанию, *args-кортеж, **kwargs-словарь"""
+    print("a=" + str(a) + ", b=" + str(b))
+    print("args=" + str(args))
+    print("kwargs=" + str(kwargs))
+    
+    total = a + b + sum(args)
+    for value in kwargs.values():
+        total += value
+    return total
+
+result = func5(1, 2, 3, 4, x=5, y=6)
+a=1, b=2
+args=(3, 4)
+kwargs={'x': 5, 'y': 6}
+result
+21
+```
+*args и **kwargs - способы передать не уточненное заранее число элементов:
+*args — переменное количество позиционных аргументов. Переданные с одной звездочкой аргументы собираются в кортеж.
+**kwargs — переменное количество именованных аргументов. Все переданные аргументы, которые указываются по имени, собираются в словарь.
+*args всегда должно идти перед **kwargs.
+
+## 4.9 Изменение значений объектов, используемых в качестве аргументов функции.
+Такое изменение возможно только у объектов изменяемого типа
+
+```py
+a=90    # Числовой объект – не изменяемый тип
+def func3(b):
+	b=5*b+67
+
+func3(a)
+a
+90
+```
+Локальная b меняется, но внешняя a нет
+
+Пример со списком:
+
+```py
+sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+def func2(sps):
+	sps[1]=99
+
+func2(sps1)
+sps1
+[1, 99, 3, 4]
+```
+Изменяемые типы (списки, словари, множества) передаются по ссылке
+
+Пример с кортежем:
+
+```py
+kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#78>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#74>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+
+Кортеж - неизменяемый тип данных, так что переназначение в таком виде не работает.
+
+# 5. Специальные типы  пользовательских функций
+
+## 5.1 Анонимные функции
+
+Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени, определяемые по следующей схеме:
+lambda [<Аргумент1>[,<Аргумент2>,…]]:<Возвращаемое значение или выражение>
+Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
+
+```py
+mport math
+anfun1=lambda: 1.5+math.log10(17.23)  #Анонимная функция без аргументов
+anfun1()   # Обращение к объекту-функции
+2.7362852774480286
+anfun2=lambda a,b : a+math.log10(b)  #Анонимная функция с 2 аргументами
+anfun2(17,234)
+19.369215857410143
+anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
+anfun3(100)
+102.36921585741014
+```
+Вызов лямбда-функции создает объект класса "функция". Внутри лямбда-функции не могут использоваться многострочные выражения, нельзя использовать if-else.
+
+## 5.2 Функции-генераторы
+
+Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. Для этого в функцию включают инструкцию yield приостанавливающую её выполнение и возвращающую очередное значение.
+Данный оператор в отличие от return не останавливает полностью выполнение программы. Когда выполнение функции возобновляется после yield, оно продолжается с того места, где было
+приостановлено, до следующего оператора yield (или до конца функции).
+
+```py
+def func5(diap,shag):
+	""" Итератор, возвращающий значения
+	из диапазона от 1 до diap с шагом shag"""
+	for j in range(1,diap+1,shag):
+		yield j
+
+for mm in func5(7,3):
+	print(mm)
+
+1
+4
+7
+alp=func5(7,3)
+print(alp.__next__())
+1
+print(alp.__next__())
+4
+print(alp.__next__())
+7
+print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#92>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+Здесь при каждом обращении к функции будет генерироваться только одно очередное значение.
+При программировании задач у таких функций часто используют метод __next__, активирующий очередную итерацию выполнения функции.
+__next__ помогает вывести значение, которое yield передает на каждой итерации цикла. Если функция отработала последнюю итерацию, но мы попытаемся сделать вызов, вернется ошибка.
+В отличии от функций, которые возвращают список со значениями итераций, функции - генераторы генерируют значения по одному, не храня всё в памяти; а функция, возвращающая список создаёт весь список в памяти. Также генератор можно использовать только один раз - после прохождения всех значений он "опустошается" и больше не производит элементов.
+
+# 6. Локализация объектов в функциях
+
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Глобальные – это те объекты, значения которых заданы вне функции.
+Локализация может быть переопределена путем прямого объявления объектов как глобальных с помощью дескриптора global.
+
+## 6.1 Примеры на локализацию объектов
+
+Пример 1. Одноименные локальный и глобальный объекты:
+
+```py
+glb=10
+def func7(arg):
+	loc1=15
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+res
+150
+glb
+10
+```
+Если внутри функции есть присваивание glb = ..., то создается локальная переменная, даже если есть глобальная с таким же именем.
+Для изменения глобальной переменной нужно использовать global glb
+
+Пример 2. Ошибка в использовании локального объекта.
+
+```py
+def func8(arg):
+	loc1=15
+	print(glb)  
+	glb=8
+	return loc1*arg
+
+res=func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#100>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#99>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+Нельзя обращаться к переменной до ее присваивания, если она считается локальной в функции.
+
+Пример 3. Переопределение локализации объекта.
+
+```py
+glb=11
+def func7(arg):
+	loc1=15
+	global glb
+	print(glb)
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+11
+```
+
+Здесь мы явно указали, что в функции используем глобальную переменную, поэтому она изменилась.
+
+## 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins
+
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
+
+```py
+globals().keys()  #Перечень глобальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+locals().keys()  #Перечень локальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+```
+Различий нет, потому что команды выполнены в глобальной области видимости, где globals() и locals() ссылаются на один и тот же словарь. Различия появляются только при вызове locals() внутри функций или методов.
+
+```py
+def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+	return loc1*arg
+
+hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+'glb' in globals().keys()
+True
+```
+locals() внутри функции показывает только её внутренние переменные, а globals() показывает все объекты модуля.
+
+## 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__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+аждая функция имеет свою локальную область видимости, причем вложенные функции не видят локальные переменные внешних функций
+## 6.4 Моделирование системы
+
+Моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа «зона нечувствительности», при подаче на неё синусоидального входного сигнала.
+Реальный двигатель: последовательное соединение усилителя с коэффициентом усиления k1,интегратора: y(t)=x(t)+y(t-1), и инерционного звена: y(t)=(x(t)+T*y(t-1)) / (T+1) с постоянной времени Т.
+Тахогенератор: последовательное соединение усилителя с коэффициентом усиления k2 и интегратора: y(t)=x(t)+y(t-1).
+Нелинейное звено типа «зона нечувствительности»: y=0 при -xm≤ x ≤xm, y=x-xm при x>xm, y=x+xm при x<-xm.
+Таким образом, система характеризуется параметрами: k1, T, k2, xm. Входной сигнал характеризуется параметрами: A (амплитуда синусоиды) и F (период синусоиды).
+Еще один параметр задачи : N – время (число тактов) подачи сигнала.
+
+```py
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=2,5,0.5,0.3,1,10,50
+k1=float(znach[0])
+k1
+2.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 matplotlib.pyplot as plt
+plt.figure(figsize=(10, 4))
+<Figure size 1000x400 with 0 Axes>
+plt.plot(vhod, 'b-', marker='o', markersize=3, label='Входной сигнал')
+[<matplotlib.lines.Line2D object at 0x000001B544E58E10>]
+plt.grid(True)
+plt.legend()
+<matplotlib.legend.Legend object at 0x000001B544E58CD0>
+plt.show()
+```
+![График2](Figure_2.png)
+
+Создание функций реализующие компоненты системы
+
+```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
+```
+Реализуем соединение компонент в соответствии с заданием
+
+```py
+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.3435662011497584, 0.8937007565838242, 1.2092087410156356, 0.8817313753454714, 0, -1.9132355035817665, -4.418649831257506, -6.322056754188363, -6.424186296702933, -3.708625221989286, 1.5442059920803182, 9.704061323599833, 17.99800277772674, 23.15808712030786, 21.60101426578536, 10.675050948044715, -9.28749624705183, -36.1615235441021, -62.02226858466596, -76.45563856328266, -68.45249914172874, -30.293518696411148, 37.373158630110446, 124.2547951685195, 205.6938367713173, 248.14398604455204, 216.69606070239215, 87.62148681833895, -136.666280236251, -418.37473314281556, -677.5335449808889, -804.9287317650713, -688.4371994648337, -254.1131297675378, 486.67764763779877, 1402.6733164388684, 2230.344175329904, 2612.7580871622617, 2188.8107903361088, 728.2399496559426, -1716.8860787572244, -4697.377083821688, -7340.680479213284, -8479.693381759376, -6951.99457172508, -2043.4413296742846, 6022.5141606693105, 15717.056921566687]
+```
+ # 7. Завершение сеанса работы с IDLE

TEMA7/task.md

@@ -0,0 +1,83 @@
+# Общее контрольное задание по теме 7
+
+Сарайкина Вера, А-02-23
+
+# Задание:
+
+1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+
+2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+
+3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X.
+
+# Решение
+
+## 1.
+
+```py
+>>> def delay_signal (signal, T):
+...           """"Расчёт выхода y(t) для устройства задержки"""
+...           output=[]
+...           for i in range(len(signal)): 
+                  if i < T:
+ 	            output.append(0)
+	          else:
+	            output.append(signal[i-T]) 
+	      return output
+	        
+>>> x=[1,0.5,3.6,4.5,1,2,0.5] # Входной сигнал
+>>> y= delay_signal (x, 2)
+>>> y
+[0, 0, 1, 0.5, 3.6, 4.5, 1]
+```
+
+## 2.
+```py
+>>> import random
+>>> import matplotlib.pyplot as plt
+>>> def histogram (sample, number):
+...     min_1=min(sample)
+...     max_1=max(sample)
+...     bins=(max_1-min_1)/number # Ширина одного интервала
+...     rows = [0]*number # Создание списка для подсчёта элементов в каждом интервале
+...     intervals = [] # Список для хранения границ интервалов
+...     for i in range(number):
+...         lower = min_1 + i * bins
+...         upper = min_1 + (i+1) * bins
+...         intervals.append((lower, upper))
+... 
+...     for x in sample:
+...         i = int((x-min_1)/bins) # Вычисление номера интервала для текущего элемента
+...         if i == number:
+...          i=number-1
+...         rows [i] +=1
+...    print("Границы интервала | Число элементов")
+...    for i in range(number):
+...        lower, upper = intervals[i]
+...        print(lower, "-", upper, "  |", rows[i])
+...    plt.hist(sample, number)
+...    plt.xlabel('Значения выборки')
+...    plt.ylabel('Число элементов')
+...    plt.title('Гистограмма выборки')
+...    plt.show()
+...    return rows
+...
+>>> data = [random.gauss(1, 20) for _ in range(10)]
+>>> histogram (data, 3)
+Границы интервала | Число элементов
+-23.534334630492655 - -11.561019750784087   | 3
+-11.561019750784087 - 0.4122951289244803   | 2
+0.4122951289244803 - 12.385610008633048   | 5
+[3, 2, 5]
+```
+![График](Figure_3.png)
+
+## 3. 
+```py
+>>> linear_regression = lambda b1, b2, x: b1+b2 * x
+>>> result = linear_regression (2,3,5)
+>>> result
+17
+```
+
+

TEMA7/test.md

@@ -0,0 +1,30 @@
+# ИКЗ Тема 7 
+
+Сарайкина Вера, А-02-23
+
+## Задание (Вариант 25)
+
+25.Разработайте функцию, которая по входному списку или кортежу с целочисленными элементами (аргумент функции) определяет число повторений каждого числа и формирует словарь с элементами: ключи – целые числа из входного объекта, значения – целые числа повторений  значения ключа во входном объекте. Этот словарь должен возвращаться в вызывающую программу. Проверьте функцию на примере.
+
+## Выполнение
+```py
+def f(a):
+    d = {}  
+    
+    for i in a:  
+        if i in d:  
+            d[i] += 1  
+        else:  
+            d[i] = 1 
+    
+    return d
+spis=[1,2,2,2,3,3,4,4,4,4,4]
+cort=(1,1,1,1,1,2,3,4,4,5,5,5)
+print(f(spis),f(cort))
+
+```
+## Вывод
+```py
+{1: 1, 2: 3, 3: 2, 4: 5} {1: 5, 2: 1, 3: 1, 4: 2, 5: 3}
+
+```

TEMA8/report.md

@@ -0,0 +1,306 @@
+# Отчет по Теме 8
+
+Сарайкина Вера, А-02-23
+
+## 1 Запуск IDLE 
+
+## 2 Создание и использование модулей в среде Python
+
+### 2.1. Запуск модуля на выполнение путем его импорта.
+
+В данном пункте используется модуль Mod1, находящийся в рабочем каталоге.
+
+```py
+perm1=input('Mod1:Введите значение = ')
+Mod1:Введите значение = 12
+print('Mod1:Значение perm1=',perm1)
+Mod1:Значение perm1= 12
+import Mod1
+Mod1:Введите значение = 12
+Mod1:Значение perm1= 12
+import Mod1
+type(Mod1)
+<class 'module'>
+dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+Mod1.perm1
+'12'
+import Mod1
+importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\Вера\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+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']
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Вера\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_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:Введите значение = 10
+Mod1:Значение perm1= 10
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Вера\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+```
+
+### 2.3. Запуск модуля на выполнение с помощью функции exec().
+
+```py
+exec(open('Mod1.py').read())
+Mod1:Введите значение = 12
+Mod1:Значение perm1= 12
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 11
+Mod1:Значение perm1= 11
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1
+'3'
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 4
+Mod1:Значение perm1= 4
+perm1
+'4'
+```
+
+### 2.4. Использование инструкции from … import …
+
+Пример 1
+
+```py
+from Mod1 import perm1
+Mod1:Введите значение = 9
+Mod1:Значение perm1= 9
+perm1
+'9'
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'importlib', 'os', 'perm1', 'sys']
+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']
+```
+
+Как видно, в памяти объекта Mod1 нет, но в sys.modules.keys() появился. Кроме того, в рабочем пространстве появился объект perm1, импортированный из модуля, поэтому к нему можно обращаться по имени perm1.
+
+Пример 2 
+
+```py
+from Mod2 import beta
+g=beta(2)
+****BETA****
+g
+535.4916555247646
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']
+print(sorted(sys.modules.keys()))
+['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_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#30>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+from Mod2 import alpha as al
+al()
+****ALPHA****
+Значение t=2
+'2'
+del al,beta
+from Mod2 import alpha as al, beta as bt
+del al,bt
+from Mod2 import *
+tt=alpha()
+****ALPHA****
+Значение t=0.12
+uu=beta(float(tt))
+****BETA****
+uu
+1.4578913609506803
+```
+
+## 3. Создание многомодульных программ.
+
+### 3.1. Простая многомодульная программа.
+
+```py
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Вера\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Вера\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_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 Mod0
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=23
+tt= 23
+****BETA****
+qq= 2.402459849485247e+31
+Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
+'23'
+2.402459849485247e+31
+'5'
+```
+
+### 3.2. Еще один пример.
+
+```py
+import MM0
+k1,T,k2,Xm,A,F,N=10,5,20,0.2,4,0.002,45
+y= [0, 0, 0, 0, 0, 0, 0, 0, 0, -1.319802644385577, 46.01934525453105, -1405.3955775891707, 42745.94702692066, -1299970.5133264635, 39533945.50140401, -1202283133.3347626, 36563128408.478745, -1111936383153.658, 33815556107824.71, -1028378828326575.4, 3.1274452834020396e+16, -9.511002882653281e+17, 2.892430326884485e+19, -8.796289202203655e+20, 2.675075800776401e+22, -8.135283385301572e+23, 2.474054594638224e+25, -7.523949501635715e+26, 2.288139325051647e+28, -6.958554904853609e+29, 2.1161948415343663e+31, -6.435647441989787e+32, 1.9571712956052526e+34, -5.952034375513921e+35, 1.810097730681449e+37, -5.504762889302416e+38, 1.6740761536689568e+40, -5.091102059507955e+41, 1.548276052049398e+43, -4.708526180245838e+44, 1.4319293229856865e+46, -4.354699342288017e+47, 1.3243255834850482e+49, -4.02746117060638e+50, 1.2248078329844667e+52]
+```
+
+### 3.3. Области дейтсвия объектов в модулях.
+
+Попробуйте вставить в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    beta(t)
+    return t
+
+def beta(q):
+    print('****BETA****')
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+
+```py
+Mod1:Введите значение = 8
+Mod1:Значение perm1= 8
+perm1= 8
+****ALPHA****
+Значение t=6
+tt= 6
+****BETA****
+qq= 153552935.39544657
+```
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    print('****BETA****')
+    import math
+    expi=alpha()*math.pi
+    return math.exp(expi)
+```
+
+```py
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=8
+tt= 8
+****BETA****
+qq= 82226315585.59491
+```
+
+Попробуйте отобразить на экране в модуле Mod0 значения объектов t и expi.
+Из-за того, что функция alpha() возвращает t, проблем с её отображением нет. 
+А вот expi напрямую вывести нельзя, потому что это локальная переменная функции beta() и она не возвращается данной функцией.
+Т.к. возвращаемая переменная qq содержит expi в показателе степени экспоненты, то один из путей решения - проделать обратную операцию (взять натуральный логарифм от qq)
+
+```py
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=1
+t= 1
+****BETA****
+Traceback (most recent call last):
+  File "C:/Users/Вера/Desktop/python-labs/TEMA8/Mod0_copy.py", line 9, in <module>
+    print('expi=', Mod2.expi)
+NameError: name 'Mod2' is not defined. Did you mean: 'Mod1'?
+```
+
+```py
+#Модуль Mod0
+import Mod1, math
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('t=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('expi=', math.log(qq))
+```
+
+```py
+Mod1:Введите значение = 6
+Mod1:Значение perm1= 6
+perm1= 6
+****ALPHA****
+Значение t=1
+t= 1
+****BETA****
+expi= 3.141592653589793
+```
+
+Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+Т.к. perm1 имеет строковый тип, то без приведения к целочисленному типу при умножении будет повторение введённого значения 3 раза.
+
+```py
+#Модуль Mod0
+import Mod1, math
+print('perm1=',Mod1.perm1)
+print('3*perm1=', 3*Mod1.perm1)
+```
+
+```py
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+3*perm1= 333
+```
+
+```py
+#Модуль Mod0
+import Mod1, math
+print('perm1=',Mod1.perm1)
+print('3*perm1=', 3*int(Mod1.perm1))
+```
+
+```py
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+3*perm1= 9
+```
+
+Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq.
+Из-за того, что perm1 и tt представлены изначально в строковом виде, то ситуация будет такой же, как и ранее. При необходимости их можно предварительно перевести в целочисленный тип
+
+```py
+import Mod0
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+perm1= 1
+****ALPHA****
+Значение t=1
+tt= 1
+****BETA****
+qq= 23.140692632779267
+Mod0.Mod1.perm1*2
+'11'
+Mod0.tt*2
+'11'
+Mod0.qq*2
+46.281385265558534
+```

TEMA8/task.md

@@ -0,0 +1,114 @@
+# Общее контрольное задание по теме 8
+
+Сарайкина Вера, А-02-23
+
+## Задание
+
+Разработайте программу, состоящую из трех модулей:
+
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+## Решение
+
+```py
+
+#okz1.py
+
+def read_numbers_from_file(filename):
+    numbers = []
+    file = open(filename, 'r')
+    lines = file.readlines()
+    file.close()
+    
+    for line in lines:
+        line = line.strip()
+        if line:
+            parts = line.split()
+            for part in parts:
+                numbers.append(float(part))
+    
+    return numbers
+
+#okz2.py
+
+def correlation_coefficient(list1, list2):
+    length1 = len(list1)
+    length2 = len(list2)
+    min_length = min(length1, length2)
+    
+    if min_length < 2:
+        return 0.0
+    
+    x = list1[:min_length]
+    y = list2[:min_length]
+    
+    sum_x = 0.0
+    sum_y = 0.0
+    for i in range(min_length):
+        sum_x += x[i]
+        sum_y += y[i]
+    
+    average_x = sum_x / min_length
+    average_y = sum_y / min_length
+    
+    top = 0.0
+    sum_sq_x = 0.0
+    sum_sq_y = 0.0
+    
+    for i in range(min_length):
+        diff_x = x[i] - average_x
+        diff_y = y[i] - average_y
+        top += diff_x * diff_y
+        sum_sq_x += diff_x * diff_x
+        sum_sq_y += diff_y * diff_y
+    
+    if sum_sq_x == 0.0 or sum_sq_y == 0.0:
+        return 0.0
+    
+    bottom = (sum_sq_x * sum_sq_y) ** 0.5
+    result = top / bottom
+    
+    return result
+
+#okz3.py
+
+import okz1
+import okz2
+
+def main():
+    print("Введите имя первого файла:")
+    file_name1 = input()
+    
+    print("Введите имя второго файла:")
+    file_name2 = input()
+
+    numbers1 = module1.read_numbers_from_file(file_name1)
+    numbers2 = module1.read_numbers_from_file(file_name2)
+    
+    correlation = module2.correlation_coefficient(numbers1, numbers2)
+    
+    correlation = round(correlation, 3)
+    
+    print("Коэффициент корреляции:", correlation)
+
+#Проверка
+
+data1.txt
+1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0
+
+data2.txt
+10.0 9.0 9.5 8.0 7.0 5.0 4.0 2.0 1.0 7.5
+
+
+Введите имя первого файла: data1.txt
+Введите имя второго файла: data2.txt
+Коэффициент корреляции: -0.76
+Process finished with exit code 0
+```
+

TEMA8/test.md

@@ -0,0 +1,44 @@
+# ИКЗ Тема 7 
+
+Сарайкина Вера, А-02-23
+
+## Задание (Вариант 25)
+
+25.Разработайте функцию, которая по входному списку или кортежу с целочисленными элементами (аргумент функции) определяет число повторений каждого числа и формирует словарь с элементами: ключи – целые числа из входного объекта, значения – целые числа повторений  значения ключа во входном объекте. Этот словарь должен возвращаться в вызывающую программу. Проверьте функцию на примере.
+
+## Выполнение
+
+
+## Сначала создаем программу-модуль Mod_f.py
+```py
+def f(a):
+    d = {}  
+    for i in a:  
+        if i in d:  
+            d[i] += 1  
+        else:  
+            d[i] = 1 
+    return d
+```
+## Далее вызываем модуль в основной программе и записываем входные данные
+```py
+from Mod_f import f
+
+
+spis = [1, 2, 2, 2, 3, 3, 4, 4, 4, 4, 4]
+cort = (1, 1, 1, 1, 1, 2, 3, 4, 4, 5, 5, 5)
+
+
+result1 = f(spis)
+result2 = f(cort)
+
+
+print("Результат для списка:", result1)
+print("Результат для кортежа:", result2)
+```
+## Вывод
+```py
+Результат для списка: {1: 1, 2: 3, 3: 2, 4: 5}
+Результат для кортежа: {1: 5, 2: 1, 3: 1, 4: 2, 5: 3}
+
+```

TEMA9/M0.py

@@ -0,0 +1,43 @@
+import M2
+
+def main():
+    "Главная программа"
+    print("=" * 40)
+    print("АНАЛИЗ ВЫБОРКИ")
+    print("=" * 40)
+    
+    r = M2.main()
+    
+    if r:
+        d, mx, v, sx, med, ma = r
+        
+        print("\n" + "-" * 40)
+        print("РЕЗУЛЬТАТЫ:")
+        print(f"n = {len(d)}")
+        print(f"min = {min(d):.4f}")
+        print(f"max = {max(d):.4f}")
+        print(f"mx  = {mx:.4f}")
+        print(f"v   = {v:.4f}")
+        print(f"sx  = {sx:.4f}")
+        print(f"med = {med:.4f}")
+        print(f"ma  = {ma:.4f}")
+        
+        if abs(ma) < 0.5:
+            t = "~симм"
+        elif ma > 0:
+            t = "вправо"
+        else:
+            t = "влево"
+        
+        print(f"тип: {t}")
+        
+        if mx != 0:
+            cv = sx / mx * 100
+            print(f"CV  = {cv:.1f}%")
+    
+    print("\n" + "=" * 40)
+    print("КОНЕЦ")
+    print("=" * 40)
+
+if __name__ == "__main__":
+    main()

TEMA9/M1.py

@@ -0,0 +1,37 @@
+
+import math as m
+
+def f1(d):
+    "Функция 1: среднее, дисперсия, откл, медиана"
+    if not d:
+        return 0, 0, 0, 0
+    
+    n = len(d)
+    mx = sum(d) / n
+    
+    v = sum((x - mx) ** 2 for x in d) / (n - 1) if n > 1 else 0
+    sx = m.sqrt(v) if v > 0 else 0
+    
+    sd = sorted(d)
+    if n % 2 == 1:
+        med = sd[n // 2]
+    else:
+        med = (sd[n // 2 - 1] + sd[n // 2]) / 2
+    
+    return mx, v, sx, med
+
+def f2(d):
+    """Функция 2: коэффициент асимметрии"""
+    if not d:
+        return 0
+    
+    mx, _, sx, _ = f1(d)
+    
+    if sx == 0:
+        return 0
+    
+    n = len(d)
+    sc = sum((x - mx) ** 3 for x in d)
+    ma = sc / ((n - 1) * (sx ** 3)) if n > 1 else 0
+    
+    return ma

TEMA9/M2.py

@@ -0,0 +1,107 @@
+import os
+import struct
+import math
+import matplotlib.pyplot as plt
+import M1
+
+
+def read_file():
+    "Чтение файла с выборкой"
+    while True:
+        filename = input("Введите имя файла: ").strip()
+        if not filename.endswith('.txt'):
+            filename += '.txt'
+
+        if os.path.exists(filename):
+            try:
+                with open(filename, 'r', encoding='utf-8') as file:
+                    content = file.read()
+                    numbers = []
+                    for part in content.split():
+                        cleaned = part.strip(',;:')
+                        try:
+                            numbers.append(float(cleaned))
+                        except ValueError:
+                            continue
+
+                    if numbers:
+                        print(f"Прочитано {len(numbers)} чисел из файла {filename}")
+                        return numbers
+                    else:
+                        print("Файл не содержит чисел")
+            except Exception as e:
+                print(f"Ошибка при чтении файла: {e}")
+        else:
+            print(f"Файл {filename} не найден")
+
+
+def create_histogram(data):
+    "Создание и отображение гистограммы"
+    if not data:
+        return
+
+    # Определяем количество интервалов
+    num_bins = min(15, int(math.sqrt(len(data))))
+
+    plt.figure(figsize=(10, 6))
+    plt.hist(data, bins=num_bins, edgecolor='black', alpha=0.7)
+    plt.title('Гистограмма выборки')
+    plt.xlabel('Значения')
+    plt.ylabel('Частота')
+    plt.grid(True, alpha=0.3)
+
+
+    plt.savefig('histogram.png')
+    print("Гистограмма сохранена")
+
+
+    plt.show()
+
+
+def save_to_binary(stats, asymmetry):
+    "Сохранение результатов в бинарный файл"
+    try:
+        with open('Res3737.bin', 'wb') as file:
+            # Записываем все 5 значений
+            for value in [stats[0], stats[1], stats[2], stats[3], asymmetry]:
+                file.write(struct.pack('d', value))
+        print("Результаты сохранены в файл 'Res3737.bin'")
+    except Exception as e:
+        print(f"Ошибка при сохранении в файл: {e}")
+
+
+def main():
+    "Основная функция модуля M2"
+
+    sample = read_file()
+    if not sample:
+        print("Не удалось получить выборку. Программа завершена.")
+        return
+
+    print(f"\nХарактеристики выборки:")
+    print(f"Размер выборки: {len(sample)}")
+    print(f"Минимальное значение: {min(sample):.4f}")
+    print(f"Максимальное значение: {max(sample):.4f}")
+
+    # Расчет статистик
+    mean, variance, std_dev, median = M1.f1(sample)
+    asymmetry_coeff = M1.f2(sample)
+
+    print(f"\nРезультаты расчетов:")
+    print(f"Математическое ожидание: {mean:.4f}")
+    print(f"Дисперсия: {variance:.4f}")
+    print(f"Стандартное отклонение: {std_dev:.4f}")
+    print(f"Медиана: {median:.4f}")
+    print(f"Коэффициент асимметрии: {asymmetry_coeff:.4f}")
+
+
+    create_histogram(sample)
+
+
+    save_to_binary((mean, variance, std_dev, median), asymmetry_coeff)
+
+    return sample, mean, variance, std_dev, median, asymmetry_coeff
+
+
+if __name__ == "__main__":
+    main()

TEMA9/report.md

@@ -0,0 +1,259 @@
+Отчет по Теме 9
+
+Сарайкина Вера, А-02-23
+
+## 1. Запуск IDLE 
+
+## 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)#Отображение данных экземпляра класса
+
+z1=Class1()   #Создаём 1-й экземпляр класса
+z2=Class1()   #Создаём 2-й экземпляр класса
+z1.zad_zn('экз.класса 1')  #Обращение к методу класса у 1-го экз.
+z2.zad_zn(-632.453)         #Обращение к методу класса у 2-го экз.
+z1.otobrazh()      # Обращение ко второму методу класса
+экз.класса 1
+z2.otobrazh()
+-632.453
+z1.data='Новое значение атрибута у экз.1'
+z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+### 2.2. Создание класса-наследника
+
+```py
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+		print('значение=',self.data)#Отображение данных экземпляра
+
+z3=Class2()
+dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+z3.zad_zn('Совсем новое')
+z3.otobrazh()
+значение= Совсем новое
+z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+При вызове z3.otobrazh() сработал метод класса Class2, а не родительского Class1.
+
+## 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#65>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\Вера\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
+del z4
+import Mod3  #Полный импорт содержимого модуля
+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__ - это один из методов, осуществляющих так называемую «перегрузку» операторов.
+
+```py
+z5=Class3('abc') #При создании экземпляра срабатывает конструктор
+z5.otobrazh()
+значение= abc
+z6=z5+'def'
+z6.otobrazh()
+значение= abcdef
+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__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+z7=Class3(123)
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+dir(z7)==dir(Class3)
+False
+z7.fio
+'Иванов И.И.'
+Class3.fio
+'Иванов И.И.'
+z7.fio == Class3.fio
+True
+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']
+```
+Атрибут rozden не появился у класса Class3. Атрибуты экземпляра (z7.rozden) создаются в словаре z7.__dict__. Атрибуты класса (Class3.fio) создаются в словаре Class3.__dict__. Эти два словаря независимы друг от друга
+
+## 6. Выявление родительских классов
+Такое выявление делается с помощью специального атрибута __bases__
+
+```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'>)
+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)
+exempl=Class4(12)
+exempl.svojstvo
+12
+exempl.svojstvo=45
+print(exempl.svojstvo)
+45
+del exempl.svojstvo
+exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#107>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#101>", 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. Пример модели системы автоматического регулирования (САР)
+Модуль SAU.py
+```py
+class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+    
+    def model(self):
+        def inerz(x,T,yy):
+            return (x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 2
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
+        y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])
+
+```
+Тестирование
+
+```py
+###main_SAU
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+from SAU import *
+xx=[0]+[1]*20 #Входной сигнал – «ступенька»
+SAUe=SAU(prm)   # Создаём экземпляр класса
+yt=[]
+for xt in xx:   # Прохождение входного сигнала
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+
+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 0x000001C7B00DFB10>]
+pylab.show()
+```
+![](Ris1.png)

TEMA9/test.md

@@ -0,0 +1,300 @@
+# Тест по модулю 3
+
+Сарайкина Вера, А-02-23
+
+## Задание
+
+M3_24
+1)	Создайте модуль М1, содержащий две функции:
+
+- функция 1: аргумент - список или кортеж с выборкой; функция должна рассчитать по выборке оценки математического ожидания, дисперсии, стандартного отклонения и медианы;
+
+- функция 2: аргумент - список или кортеж с выборкой; функция должна произвести расчет по той же выборке оценки коэффициента асимметрии:
+
+     ma=[(x1-Mx)3+:+xN-Mx)^3]/[(N-1)*sx^3],
+
+где Mx,sx - оценки математического ожидания и стандартного отклонения по выборке. При этом среднее значение и стандартное отклонение должны быть вычислены с помощью функции 1.
+
+2)	Создайте еще один модуль М2, в котором должны выполняться следующие операции: 
+
+- запрашивается имя текстового файла с выборкой, проверяется его наличие и при отсутствии - повторяется запрос;
+
+- выборка вводится из файла и записывается в список;
+
+- с помощью функций 1 и 2 по выборке рассчитываются оценки математического ожидания, дисперсии, стандартного отклонения, медианы и коэффициента асимметрии,
+
+- по выборке рассчитывается гистограмма и отображается в виде графика на экране;
+
+- результаты расчета записываются в бинарный файл с именем Res3737.bin.
+
+3)	Создайте модуль М0 - главную программу, которая вызывает М2 и отображает результаты расчетов на экране.
+
+4)	Подготовьте 2 текстовых файла с выборками и проверьте программу.
+
+## Выполнение
+## модуль 1
+```py
+
+import math as m
+
+def f1(d):
+    "Функция 1: среднее, дисперсия, откл, медиана"
+    if not d:
+        return 0, 0, 0, 0
+    
+    n = len(d)
+    mx = sum(d) / n
+    
+    v = sum((x - mx) ** 2 for x in d) / (n - 1) if n > 1 else 0
+    sx = m.sqrt(v) if v > 0 else 0
+    
+    sd = sorted(d)
+    if n % 2 == 1:
+        med = sd[n // 2]
+    else:
+        med = (sd[n // 2 - 1] + sd[n // 2]) / 2
+    
+    return mx, v, sx, med
+
+def f2(d):
+    """Функция 2: коэффициент асимметрии"""
+    if not d:
+        return 0
+    
+    mx, _, sx, _ = f1(d)
+    
+    if sx == 0:
+        return 0
+    
+    n = len(d)
+    sc = sum((x - mx) ** 3 for x in d)
+    ma = sc / ((n - 1) * (sx ** 3)) if n > 1 else 0
+    
+    return ma
+
+```
+## модуль 2
+```py
+import os
+import struct
+import math
+import matplotlib.pyplot as plt
+import M1
+
+
+def read_file():
+    "Чтение файла с выборкой"
+    while True:
+        filename = input("Введите имя файла: ").strip()
+        if not filename.endswith('.txt'):
+            filename += '.txt'
+
+        if os.path.exists(filename):
+            try:
+                with open(filename, 'r', encoding='utf-8') as file:
+                    content = file.read()
+                    numbers = []
+                    for part in content.split():
+                        cleaned = part.strip(',;:')
+                        try:
+                            numbers.append(float(cleaned))
+                        except ValueError:
+                            continue
+
+                    if numbers:
+                        print(f"Прочитано {len(numbers)} чисел из файла {filename}")
+                        return numbers
+                    else:
+                        print("Файл не содержит чисел")
+            except Exception as e:
+                print(f"Ошибка при чтении файла: {e}")
+        else:
+            print(f"Файл {filename} не найден")
+
+
+def create_histogram(data):
+    "Создание и отображение гистограммы"
+    if not data:
+        return
+
+    # Определяем количество интервалов
+    num_bins = min(15, int(math.sqrt(len(data))))
+
+    plt.figure(figsize=(10, 6))
+    plt.hist(data, bins=num_bins, edgecolor='black', alpha=0.7)
+    plt.title('Гистограмма выборки')
+    plt.xlabel('Значения')
+    plt.ylabel('Частота')
+    plt.grid(True, alpha=0.3)
+
+
+    plt.savefig('histogram.png')
+    print("Гистограмма сохранена в файл ")
+
+
+    plt.show()
+
+
+def save_to_binary(stats, asymmetry):
+    "Сохранение результатов в бинарный файл"
+    try:
+        with open('Res3737.bin', 'wb') as file:
+            # Записываем все 5 значений
+            for value in [stats[0], stats[1], stats[2], stats[3], asymmetry]:
+                file.write(struct.pack('d', value))
+        print("Результаты сохранены в файл 'Res3737.bin'")
+    except Exception as e:
+        print(f"Ошибка при сохранении в файл: {e}")
+
+
+def main():
+    "Основная функция модуля M2"
+
+    sample = read_file()
+    if not sample:
+        print("Не удалось получить выборку. Программа завершена.")
+        return
+
+    print(f"\nХарактеристики выборки:")
+    print(f"Размер выборки: {len(sample)}")
+    print(f"Минимальное значение: {min(sample):.4f}")
+    print(f"Максимальное значение: {max(sample):.4f}")
+
+    # Расчет статистик
+    mean, variance, std_dev, median = M1.f1(sample)
+    asymmetry_coeff = M1.f2(sample)
+
+    print(f"\nРезультаты расчетов:")
+    print(f"Математическое ожидание: {mean:.4f}")
+    print(f"Дисперсия: {variance:.4f}")
+    print(f"Стандартное отклонение: {std_dev:.4f}")
+    print(f"Медиана: {median:.4f}")
+    print(f"Коэффициент асимметрии: {asymmetry_coeff:.4f}")
+
+
+    create_histogram(sample)
+
+
+    save_to_binary((mean, variance, std_dev, median), asymmetry_coeff)
+
+    return sample, mean, variance, std_dev, median, asymmetry_coeff
+
+
+if __name__ == "__main__":
+    main()
+```
+## основной модуль
+```py
+import M2
+
+def main():
+    "Главная программа"
+    print("=" * 40)
+    print("АНАЛИЗ ВЫБОРКИ")
+    print("=" * 40)
+    
+    r = M2.main()
+    
+    if r:
+        d, mx, v, sx, med, ma = r
+        
+        print("\n" + "-" * 40)
+        print("РЕЗУЛЬТАТЫ:")
+        print(f"n = {len(d)}")
+        print(f"min = {min(d):.4f}")
+        print(f"max = {max(d):.4f}")
+        print(f"mx  = {mx:.4f}")
+        print(f"v   = {v:.4f}")
+        print(f"sx  = {sx:.4f}")
+        print(f"med = {med:.4f}")
+        print(f"ma  = {ma:.4f}")
+        
+        if abs(ma) < 0.5:
+            t = "~симм"
+        elif ma > 0:
+            t = "вправо"
+        else:
+            t = "влево"
+        
+        print(f"тип: {t}")
+        
+        if mx != 0:
+            cv = sx / mx * 100
+            print(f"CV  = {cv:.1f}%")
+    
+    print("\n" + "=" * 40)
+    print("КОНЕЦ")
+    print("=" * 40)
+
+if __name__ == "__main__":
+    main()
+
+```
+## Вывод для test1
+```py
+C:\Users\Yarik\PycharmProjects\PythonProject1\.venv\Scripts\python.exe C:\Users\Yarik\Desktop\labi\python-labs\TEMA9\M0.py 
+========================================
+АНАЛИЗ ВЫБОРКИ
+========================================
+Введите имя файла: test1
+Прочитано 10 чисел из файла test1.txt
+
+Характеристики выборки:
+Размер выборки: 10
+Минимальное значение: 12.5000
+Максимальное значение: 17.4000
+
+Результаты расчетов:
+Математическое ожидание: 14.5900
+Дисперсия: 2.4766
+Стандартное отклонение: 1.5737
+Медиана: 14.5000
+Коэффициент асимметрии: 0.2955
+Гистограмма сохранена в файл 
+
+```
+![](Figure_2.png)
+## Вывод для test2
+```py
+C:\Users\Yarik\PycharmProjects\PythonProject1\.venv\Scripts\python.exe C:\Users\Yarik\Desktop\labi\python-labs\TEMA9\M0.py 
+========================================
+АНАЛИЗ ВЫБОРКИ
+========================================
+Введите имя файла: test2
+Прочитано 15 чисел из файла test2.txt
+
+Характеристики выборки:
+Размер выборки: 15
+Минимальное значение: 95.0000
+Максимальное значение: 110.0000
+
+Результаты расчетов:
+Математическое ожидание: 102.2667
+Дисперсия: 23.3524
+Стандартное отклонение: 4.8324
+Медиана: 102.0000
+Коэффициент асимметрии: 0.1178
+Гистограмма сохранена
+Результаты сохранены в файл 'Res3737.bin'
+
+----------------------------------------
+РЕЗУЛЬТАТЫ:
+n = 15
+min = 95.0000
+max = 110.0000
+mx  = 102.2667
+v   = 23.3524
+sx  = 4.8324
+med = 102.0000
+ma  = 0.1178
+тип: ~симм
+CV  = 4.7%
+
+========================================
+КОНЕЦ
+========================================
+
+Process finished with exit code 0
+
+```
+![](Figure_1.png)

TEMA9/test1.txt

@@ -0,0 +1,2 @@
+12.5 15.3 14.8 13.2 16.1
+17.4 12.9 15.8 14.2 13.7

TEMA9/test2.txt

@@ -0,0 +1 @@
+100 105 98 102 110 95 103 107 99 101 104 96 109 97 108