test: добавлен

TEMA1/Pr0.py

@@ -0,0 +1,6 @@
+#Программа по Теме 1 Анисенков Павел Дмитриевич
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('C:\\Users\\Professional\\Desktop\\python-labs\\TEMA1\\')
+

TEMA1/protokol.txt

@@ -0,0 +1,64 @@
+#Протокол по Теме 1 Анисенков Павел Дмитриевич
+Python 3.13.6 (tags/v3.13.6:4e66535, Aug  6 2025, 14:36:00) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+import os
+os.chdir('C:\\Users\\Professional\\Desktop\\python-labs\\TEMA1\\')
+
+============================================================ RESTART: C:/Users/Professional/Desktop/python-labs/TEMA1/Pr0.py ===========================================================
+Hello
+Your name=Paulik
+import Pr0
+Hello
+Your name=Paulik
+
+============================================================ RESTART: C:/Users/Professional/Desktop/python-labs/TEMA1/Pr0.py ===========================================================
+Hello
+Your name=Paulik
+import prb1
+Как Вас зовут? Paulik
+Привет, Paulik
+
+help(print)
+Help on built-in function print in module builtins:
+
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+
+help(print); help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+import tdemo_chaos

TEMA1/report.md

@@ -0,0 +1,135 @@
+# Отчет по теме 1
+
+Анисенков Павел, А-01-23
+
+## 1-2. Запуск 
+	Была запущена программа-интерпретатор:
+![](ZAPUSK.png)
+
+## 3-5. Диалоговое окно
+	
+	Были введены несколько инструкций в диалоговое окно интерпретатора:
+	
+```py
+print('hello')
+hello
+	
+h=input('Your name=')
+Your name=paulik
+	
+exit() - закрывает интерпретатор
+```
+	
+## 6-7. Интерактивная графическая оболочка
+
+![](OBOLOCHKA.png)
+	
+	было изучено устройство главного командного окна среды.
+	
+## 8. Настройка рабочего каталога.
+
+```py
+import os
+os.chdir('C:\\Users\\Professional\\Desktop\\python-labs\\TEMA1\\')
+```
+	
+## 9. Персонализация среды.
+
+![](IIIPIFT.png) 
+	
+![](COLOR.png)
+
+![](SIZE.png)
+	
+## 10. Окно редактора
+	Воспользовались окном редактора для написания кода, результат:
+	
+	============================================================ RESTART: C:/Users/Professional/Desktop/python-labs/TEMA1/Pr0.py ===========================================================
+    Hello
+    Your name=Paulik
+
+### Были использованы следующие методы запуска инструкций:
+1) Меню редактора: Run module
+2) Кнопка F5
+3) Команда import Pr0
+
+## 11. Запуск prb1
+	
+    import prb1
+    Как Вас зовут? Paulik
+    Привет, Paulik
+
+## 12-13. Просмотр pycache
+![](PROT.png)
+    Открыли каталог __pycache__ и попытались открыть в текстовом редакторе файл Pr0.cpython-34.pyc – результат работы компилятора среды. 
+![](ERROR.PNG)
+    .pyc - это не текстовые файлы: .pyc файлы содержат скомпилированный байт-код, а не читаемый текст. Поэтому IDLE, как текстовый редактор, не может правильно интерпретировать содержимое .pyc файла как текст.
+    Компиляция — это процесс перевода исходного кода на языке программирования в машинный код. Если этого не сделать, компьютер не поймёт, как выполнить инструкции разработчика. Поэтому мы отдаём компилятору строки кода, а он сравнивает их со своим словарём, учитывает контекст и выдаёт набор из нулей и единиц.
+	
+## 14. Вызов раздела помощи
+
+	help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+	  
+	  help(print); help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+	
+    Также были рассмотрены другие способы получения раздела помощи.
+
+F1 -- index:
+![](HELPPRINT.png)
+
+ 
+
+
+### 15.1 Открыт prb1.py
+    Как Вас зовут? Paulik
+    Привет, Paulik
+
+### 15.2 Перемещение между окнами и запуск программы из окна редактора
+![](4MIMIMAMOMU.png)
+
+### 15.3 Была запущена программа tdemo_chaos
+![](CHAOuS.png)
+
+### 15.4 Рассмотрение примеров использования графической составляющией среды Python
+    зашли в предложение «Помощь (Help)» и «Демонстрации (Turtle Demo)». В появившемся новом окне в меню выберали предложение «Примеры (Examples)» и из появляющегося списка примеров – «Часы (Clock)». Нажмали кнопку «Запуск (Start)» в нижней части окна.
+![](5orclock.png)
+    Данные примеры способны помочь в плане структуризации собственного кода и изучении новых команд.
+
+## 16. Выход из среды

TEMA1/task4.md

@@ -0,0 +1,17 @@
+## 4. Можно ли писать несколько инструкций в одной строке командного окна?
+
+### Ответ
+
+1) Да, можно. Применяется разделение точкой с запятой ;
+```py
+x = 5; y = 10; print(x + y)
+``` 
+2) Так же это можно осуществить с помощью if else
+```py
+if x > 0: print("Paulik") 
+``` 
+3) Множественное присваивание
+```py
+a, b, c = 1, 2, 3  # три присваивания в одной строке
+``` 
+При этом снижается читаемость кода

TEMA2/Protokol2.txt

@@ -0,0 +1,287 @@
+#Протокол по Теме 2 Анисенков Павел Дмитриевич
+import os
+ os.chdir('C:\\Users\\Professional\\Desktop\\python-labs\\Tema2')
+
+f1=16; f2=3
+f1,f2
+(16, 3)
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+type(f2)
+<class 'int'>
+del f1,f2
+f1,f2
+Traceback (most recent call last):
+  File "<pyshell#8>", line 1, in <module>
+    f1,f2
+NameError: name 'f1' is not defined
+gg1=1.6
+hh1='Строка'
+73sr=3
+SyntaxError: invalid decimal literal
+and=7
+SyntaxError: invalid syntax
+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']
+spis='['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']'
+SyntaxError: invalid syntax
+spis=['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']
+import builtins
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+print(abs(-5))
+5
+print(len("Hello"))
+5
+print(len([1, 2, 3]))
+3
+print(max(1, 5, 3))
+5
+print(min([10, 20, 5]))
+5
+print(pow(5, 2))
+25
+print(pow(4, 0.5))
+2.0
+print(round(3.14159))
+3
+print(round(2.675, 2))
+2.67
+print(sorted("hello"))
+['e', 'h', 'l', 'l', 'o']
+2
+print(sorted(numbers))
+[1, 2, 3, 4]
+print(sorted(numbers, reverse=True))
+[4, 3, 2, 1]
+names = ["Alice", "Bob"]
+ages = [25, 30]
+pop = zip(names, ages)
+print(list(pop))
+[('Alice', 25), ('Bob', 30)]
+print(type(5))
+<class 'int'>
+print(type("hello"))
+<class 'str'>
+print(type([1, 2, 3]))
+<class 'list'>
+print(dir("hello"))
+['__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']
+Gg1=45
+print(gg1,Gg1)
+1.6 45
+bb1 = True; bb2 = False
+bb1,bb2
+(True, False)
+type(bb1)
+<class 'bool'>
+ii1=-1234567890
+ff1=-8.9876e-12
+dv1=0b1101010
+vsm1-0o52765
+Traceback (most recent call last):
+  File "<pyshell#48>", line 1, in <module>
+    vsm1-0o52765
+NameError: name 'vsm1' is not defined
+vsm1=0o52765
+shest1=0x7109af6
+cc1=2-3j
+a=3.67;b=-0.45
+cc2=complex(a,b)
+ss1
+Traceback (most recent call last):
+  File "<pyshell#54>", line 1, in <module>
+    ss1
+NameError: name 'ss1' is not defined
+ss1='Это - строка символов'
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+ss1a
+'Это - " строка символов ", \n \t выводимая на двух строках'
+ss1b= 'Меня зовут: \n Анисенков П. Д.'
+ыы1и
+Traceback (most recent call last):
+  File "<pyshell#59>", line 1, in <module>
+    ыы1и
+NameError: name 'ыы1и' is not defined
+ss1b
+'Меня зовут: \n Анисенков П. Д.'
+print(ss1b)
+Меня зовут: 
+ Анисенков П. Д.
+print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+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]
+'-'
+ss1=ss1[:4]+'='+ss1[5:]
+slice1 = ss1b[:10]
+slice1
+'Меня зовут'
+slice2 = ss1b[12:]
+slice2
+'\n Анисенков П. Д.'
+slice5 = ss1b[::2]
+slice5
+'Мн оу:\nАиеквП .'
+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
+help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+spis1+['New item']
+[111, 'Список', (5-9j), 'New item']
+spis1+'ss1b'
+Traceback (most recent call last):
+  File "<pyshell#95>", line 1, in <module>
+    spis1+'ss1b'
+TypeError: can only concatenate list (not "str") to list
+spis1+['ss1b']
+[111, 'Список', (5-9j), 'ss1b']
+spis1+ss1b
+Traceback (most recent call last):
+  File "<pyshell#97>", line 1, in <module>
+    spis1+ss1b
+TypeError: can only concatenate list (not "str") to list
+spis1.pop(1)
+'Список'
+spis1
+[111, (5-9j)]
+spis2=[spis1,[4,5,6,7]]
+spis2[0][1]
+(5-9j)
+spis2[0][1]=78
+spis1
+[111, 78]
+spisk=[20,'Pavel',0.4532]
+spisk+ [1,2,3,4,5],{"имя":"Павел", "возраст": 20}
+([20, 'Pavel', 0.4532, 1, 2, 3, 4, 5], {'имя': 'Павел', 'возраст': 20})
+kort1=(222,'Kortezh',77+8j)
+kort1= kort1+(1,2)
+kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1= kort1+(ss1b,)
+kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Анисенков П. Д.')
+kort2=kort1[:2]+kort1[3:]
+kort1.index(2)
+4
+kort1.count(222)
+1
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#114>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+my_tuple = (
+    42,                    # целое число
+    "Привет",              # строка
+    [1, 2, 3],             # список
+    (4, 5, 6)              #кортеж
+)
+
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+dic1['Orel']
+
+56
+dic1['Pskov']=78
+вшс1
+Traceback (most recent call last):
+  File "<pyshell#119>", line 1, in <module>
+    вшс1
+NameError: name 'вшс1' is not defined
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+[45, 56, 78, 145]
+dic2={1:'mean',2:'standart deviation',3:'correlation'}
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+dic3['statistics'][2]
+'standart deviation'
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+spska = ('яблоко', 'банан', 'апельсин', 'виноград', 'киви', 'манго', 'груша')
+spysk = [10, 20, 30, 40, 50]
+res = dict(zip(spska, spysk))
+res
+{'яблоко': 10, 'банан': 20, 'апельсин': 30, 'виноград': 40, 'киви': 50}
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'линия связи', 'датчик', 'двигатель', 'микропроцессор'}
+len(mnoz1)
+4
+'датчик' in mnoz1
+True
+mnoz1.add('реле')
+mnoz1
+{'линия связи', 'датчик', 'двигатель', 'реле', 'микропроцессор'}
+mnoz1.remove('линия связи')
+mnoz1
+{'датчик', 'двигатель', 'реле', 'микропроцессор'}
+set123= {
+    42,                    # целое число
+    3.14,                  # число с плавающей точкой
+    "Привет",              # строка
+    (1, 2, 3),             # кортеж
+    True,                  # логическое значение
+    "Python",              # еще строка
+    frozenset([7, 8, 9]),  # неизменяемое множество
+    42                     # дубликат (будет удален)
+}
+set123.add([7, 8, 9])
+Traceback (most recent call last):
+  File "<pyshell#140>", line 1, in <module>
+    set123.add([7, 8, 9])
+TypeError: unhashable type: 'list'
+my_set.remove("Привет")
+Traceback (most recent call last):
+  File "<pyshell#141>", line 1, in <module>
+    my_set.remove("Привет")
+NameError: name 'my_set' is not defined
+set123.remove("Привет")
+set123
+{True, 3.14, 42, (1, 2, 3), 'Python', frozenset({8, 9, 7})}
+

TEMA2/report.md

@@ -0,0 +1,746 @@
+# Отчет по теме 2
+
+Анисенков Павел, А-01-23
+
+## 1. Запуск.
+
+### 1.1 Запуск оболочки IDLE и установка рабочего каталога.
+
+```py
+import os
+os.chdir('C:\\Users\\Professional\\Desktop\\python-labs\\TEMA1\\')
+```
+
+
+## 2. Изучение простых объектов.
+
+### 2.1 Операции присваивания
+
+```py
+f1=16; f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+``` 
+### 2.2 Функционал команд dir(), type() и del:
+
+Был получен список атрибутов объекта f1:
+
+```py
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+```
+
+Также была определена классовая принадлежность объекта f2:
+
+```py
+type(f2)
+<class 'int'>
+```
+
+Команда del отвечает за удаление объекта или его части из ОП.
+
+```py
+del f1, f2
+
+f1, f2
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    f1, f2
+NameError: name 'f1' is not defined
+```
+
+## 3-4. Правила именования и сохранение списка под именем:
+
+Были изучены правила именования введены некоторые предложенные команды, две из которых не соответствовали правилам именования:
+
+![](kylek.png)
+
+```py
+import keyword #список ключевых слов
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+``` 
+В данном случае полученному списку было присвоено следующее имя:
+
+```py
+pisok = keyword.kwlist
+pisok
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+## 5. Встроенные идентификаторы.
+
+### 5.1  Вывод списка встроенных идентификаторов:
+
+```py
+import builtins
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```	
+### 5.2 Изучение назначения функций:
+```py
+print(abs(-5))
+5
+print(len("Hello"))
+5
+print(len([1, 2, 3]))
+3
+print(max(1, 5, 3))
+5
+print(min([10, 20, 5]))
+5
+print(pow(5, 2))
+25
+print(pow(4, 0.5))
+2.0
+print(round(3.14159))
+3
+print(round(2.675, 2))
+2.67
+print(sorted("hello"))
+['e', 'h', 'l', 'l', 'o']
+numbers = [3, 1, 4, 2]
+print(sorted(numbers))
+[1, 2, 3, 4]
+print(sorted(numbers, reverse=True))
+[4, 3, 2, 1]
+names = ["Alice", "Bob"]
+ages = [25, 30]
+pop = zip(names, ages)
+print(list(pop))
+[('Alice', 25), ('Bob', 30)]
+```
+#### 5.2.1 Функция ABS:
+
+![](abs.png)
+
+#### 5.2.2 Функция len:
+
+![](len.png)
+
+#### 5.2.3 Функция max
+
+```py
+help(max)
+Help on built-in function max in module builtins:
+
+max(...)
+    max(iterable, *[, default=obj, key=func]) -> value
+    .......
+    With two or more positional arguments, return the largest argument.
+
+max(numbers)
+3
+```
+
+#### 5.2.4 Функция min
+
+```py
+help(min)
+Help on built-in function min in module builtins:
+
+min(...)
+    min(iterable, *[, default=obj, key=func]) -> value
+   ............
+    With two or more positional arguments, return the smallest argument.
+
+min(numbers)
+1
+```
+
+
+#### 5.2.5 Функция pow
+
+```py
+help(pow)
+Help on built-in function pow in module builtins:
+
+pow(base, exp, mod=None)
+    ...........
+invoked using the three argument form.
+
+pow(3, 2)
+9
+```
+
+#### 5.2.6 Функция round
+
+```py
+help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+round(1.5)
+2
+```
+
+#### 5.2.7 Функция sorted
+
+```py
+help (sorted)
+Help on built-in function sorted in module builtins:
+
+sorted(iterable, /, *, key=None, reverse=False)
+    Return a new list containing all items from the iterable in ascending order.
+
+    A custom key function can be supplied to customize the sort order, and the
+    reverse flag can be set to request the result in descending order.
+
+num = [3, 1, 2]
+sorted(num)
+[1, 2, 3]
+```
+
+
+
+#### 5.2.8 Функция sum
+
+```py
+help(sum)
+Help on built-in function sum in module builtins:
+
+sum(iterable, /, start=0)
+    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+
+    When the iterable is empty, return the start value.
+    This function is intended specifically for use with numeric values and may
+    reject non-numeric types.
+
+sum(num)
+6
+```
+
+#### 5.2.9 Функция zip
+
+```py
+help(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(*iterables, strict=False)
+ |
+ |  The zip object yields n-length tuples, where n is the number of iterables
+ |  passed as positional arguments to zip().  The i-th element in every tuple
+ |  comes from the i-th iterable argument to zip().  This continues until the
+...........................................
+
+num
+[3, 1, 2]
+numbers
+[1, 2, 3]
+j = zip(num, numbers)
+j
+<zip object at 0x000001E309D6DD00>
+zip_list = list(j)
+zip_list
+[(3, 1), (1, 2), (2, 3)]
+```
+
+## 6-7. Типы объектов.
+
+### 6. Проверка влияния больших и маленьких букв в имени переменных:
+
+```py
+Gg1=45
+gg1
+1.6
+Gg1
+45
+```
+### 7. Изучение базовых типов объектов:
+ 
+int — целые числа (положительные, отрицательные или нуль).
+float — числа с плавающей точкой (дробные числа).
+complex — комплексные числа (имеют действительную и мнимую части).
+str — строковый тип данных для хранения текстовой информации. Строка может содержать буквы, цифры, пробелы, символы.
+bool в Python — это логический тип, принимать только два значения: True и False.
+
+
+#### 7.1 Логический тип:
+
+```py
+bb1 = True
+bb2 = False
+bb1;bb2
+True
+False
+type(bb1)
+<class 'bool'>
+```
+
+#### 7.2 Иные простые типы: 
+
+```py
+ii1=-1234567890
+type(ii1)
+<class 'int'>
+
+ff1=-8.9876e-12  
+type(ff1)
+         
+<class 'float'>
+
+dv1=0b1101010
+         
+type(dv1)
+         
+<class 'int'>
+```
+
+Как можем заметить - двоичное число 0b1101010 в Python сохраняется в объекте класса int.
+
+```py
+vsm1=0o52765
+type(vsm1)
+<class 'int'>
+```
+
+```py
+shest1=0x7109af6
+type(shest1)
+<class 'int'>
+cc1=2-3j
+type(cc1)
+<class 'complex'>
+```
+
+Ниже представлен иной способ создания комплексного числа:
+
+```py
+a=3.67; b=-0.45
+cc2=complex(a,b)
+type(cc2)
+<class 'complex'>
+```
+
+#### 7.3 Строка символом:
+
+Строки выделяются как и апострофами, так и двойными кавычками, продемонстрируем:
+
+```py
+ss1='Это - строка символов'
+ss1="Это - строка символов"
+```
+
+##### Экранированные последовательности:
+```py
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+```
+
+Создадим строку по шаблону:
+
+```py
+ss1b= 'Меня зовут: \n Анисенков П.Д.'
+print(ss1b)
+Меня зовут: 
+ Анисенков П.Д.
+```
+
+Создадим строку со значением объекта при помощи тройных кавычек:
+
+```py
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+```py
+
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+ss1[6:9]
+'стр'
+ss1[13:]
+'символов'
+ss1[:13]
+'Это - строка '
+ss1[5:-8]
+' строка '
+ss1[3:17:2]
+'  тоасм'
+```
+Важно заметить, что цифра '2' здесь отвечает за шаг.
+
+
+Здесь, подобно примеру выше, мы перечислили элементы с индексами от 3 до 17, но в обратном порядке (с положительным шагом перечисление элементов в обратную сторону работать не будет).
+```py
+ss1[17:3:-2]
+'омсаот '
+```
+
+Изменив '17' на '-4' мы получим тот же результат, ведь два этих индекса соответствуют одному и тому же элементу строки.
+```py
+ss1[-4:3:-2]
+'омсаот '
+```
+
+Таким образом, мы переопределили элемент под индексом 4.
+```py
+ss1=ss1[:4]+'='+ss1[5:]
+ss1
+'Это = строка символов'
+``` 
+
+
+```py
+slice1 = ss1b[:10]
+slice1
+'Меня зовут'
+slice2 = ss1b[12:]
+slice2
+'\n Анисенков П. Д.'
+slice5 = ss1b[::2]
+slice5
+'Мн оу:\nАиеквП .'
+
+```
+
+## 8. Списки, кортежи, словари и множества.
+
+```py
+
+help(list)
+Help on class list in module builtins:
+
+class list(object)
+ |  list(iterable=(), /)
+ |
+ |  Built-in mutable sequence.
+ |
+ |  If no argument is given, the constructor creates a new empty list.
+ |  The argument must be an iterable if specified.
+
+
+help(tuple)
+Help on class tuple in module builtins:
+
+class tuple(object)
+ |  tuple(iterable=(), /)
+ |
+ |  Built-in immutable sequence.
+ |
+ |  If no argument is given, the constructor returns an empty tuple.
+ |  If iterable is specified the tuple is initialized from iterable's items.
+ |
+ |  If the argument is a tuple, the return value is the same object.
+ |
+ |  Built-in subclasses:
+ |      asyncgen_hooks
+ |      UnraisableHookArgs
+
+
+help(dict)
+Help on class dict in module builtins:
+
+class dict(object)
+ |  dict() -> new empty dictionary
+ |  dict(mapping) -> new dictionary initialized from a mapping object's
+ |      (key, value) pairs
+ |  dict(iterable) -> new dictionary initialized as if via:
+ |      d = {}
+ |      for k, v in iterable:
+ |          d[k] = v
+ |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
+ |      in the keyword argument list.  For example:  dict(one=1, two=2)
+
+help(set)
+Help on class set in module builtins:
+
+class set(object)
+ |  set(iterable=(), /)
+ |
+ |  Build an unordered collection of unique elements.
+
+```
+### 8.1 Работа со списками.
+
+Список может содержать в себе элементы разных типов.
+```py
+spis1=[111,'Spisok',5-9j]
+spis1
+[111, 'Spisok', (5-9j)]
+```
+
+Ввод можно производить в разных строках, пока не будет введена квадратная скобка.
+```py
+stup=[0,0,1,1,1,1,1,1,1]
+stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+
+spis = [1,2,3,4,
+        5,6,7,
+        8,9,10]
+spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+
+'-8' - есть элемент под индексом 1 в исходном списке, между :: ничего нет, значит срез произойдёт до самого последнего элемента, а '2' - есть шаг пересчёта элементов.
+```py
+
+spis1[-1]
+(5-9j)
+stup[-8::2]
+[0, 1, 1, 1]
+```
+
+```py
+spis1[1]='Список'
+spis1
+[111, 'Список', (5-9j)]
+len(spis1)
+3
+```
+
+
+С помощью '.append' можно добавить какой-либо элемент в список, а '.pop' - удалить.
+```py
+spis1.append('New Item')
+spis1
+[111, 'Список', (5-9j), 'New Item']
+spis1.append(ss1b)
+spis1
+[111, 'Spisok', (5-9j), 'New Item', 'Меня зовут: \n Анисенков П.Д.']
+spis1.pop(1)
+'Spisok'
+spis1
+[111, (5-9j), 'New Item', 'Меня зовут: \n Анисенков П.Д.']
+```
+
+
+
+```py
+spis1.insert(1, 'TITAN') вставит второй аргумент под номер индекса элемента.
+spis1
+[111, 'TITAN', (5-9j), 'New Item', 'Меня зовут: \n Ефремов С.И.'] 
+
+spis1.remove('TITAN') - удалит тот элемент, который полностью соответствует указанному в команде аргументу.
+spis1
+[111, (5-9j), 'New Item', 'Меня зовут: \n Анисенков П.Д.']
+
+spis1.clear() - удаляет все элементы из списка.
+spis1
+[]
+
+spis1
+[5, 3, 2, 1, 7, 6, 9]
+spis1.sort() - сортировка списка как и по числам*
+spis1
+[1, 2, 3, 5, 6, 7, 9]
+spisbukva = ['b', 'a', 'c', 'g', 't']
+spisbukva.sort() -  *так и по алфавиту
+spisbukva
+['a', 'b', 'c', 'g', 't']
+
+spisbukva.reverse() - перемешивает элементы в обратном порядке
+spisbukva
+['t', 'g', 'c', 'b', 'a']
+
+spis1
+[1, 2, 3, 5, 6, 7, 9]
+spis111 = spis1.copy() - копирует список.
+spis111
+[1, 2, 3, 5, 6, 7, 9]
+
+spis1
+[1, 2, 3, 5, 6, 7, 9]
+spis1.count(5) - считает то, сколько раз элемент из аргумента появляется в списке.
+1
+
+spis1.index(9) - возвращает индекс элемента, совпадающего по значению с аргументом.
+6
+```
+
+```py
+spis2=[spis1, [4,5,6,7]] - элементы переменной - два списка
+spis2
+[[1, 2, 3, 5, 6, 7, 9], [4, 5, 6, 7]]
+
+spis2[0][1] - обращение ко второму элементу первого списка
+2
+
+spis2[0][1]=78 - замена значения того же элемента на другое
+spis2
+[[1, 78, 3, 5, 6, 7, 9], [4, 5, 6, 7]]
+
+spis1
+[1, 78, 3, 5, 6, 7, 9] 
+
+spis2 содержит не копию списка spis1, а ссылку на тот же самый объект в памяти.
+В памяти создается объект-список, и spis1 указывает на него.
+spis2[0] - это не копия spis1, а та же самая ссылка на тот же объект в памяти.
+```
+#### Был придуман список, содержащий в себе 4 элемента разных типов: число, строка, логическое значение и список.
+
+```py
+list = ['glad', 18, True, ['a','b','c','d']]
+list
+['glad', 18, True, ['a', 'b', 'c', 'd']]
+type(list)
+<class 'list'>
+```
+
+### 8.2 Кортеж.
+
+*Похож на список, но изменить его нельзя
+```py
+kort1=(222,'Kortezh',77+8j)
+type(kort1)
+<class 'tuple'>
+kort1[2] = 90
+Traceback (most recent call last):
+  File "<pyshell#22>", line 1, in <module>
+    kort1[2] = 90
+TypeError: 'tuple' object does not support item assignment
+```
+
+Однако можно переопределить (добавить или удалить определенные элементы).
+```py
+kort1= kort1+(1,2) - добавление
+kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+kort2=kort1[:2]+kort1[3:] - удаление
+kort2
+(222, 'Kortezh', 1, 2)
+```
+
+Определение индекса и подсчёт заданного элемента:
+```py
+kort1.index(2)
+4
+kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1.count(222)
+1
+
+my_tuple = (
+    42,                    # целое число
+    "Привет",              # строка
+    [1, 2, 3],             # список
+    (4, 5, 6)              #кортеж
+)
+```
+### 8.3 Словарь
+
+-Является совокупностью пар типа 'key:value'
+
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+dic1['Saratov']
+145
+
+dic1['Pskov']=78
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+
+sorted(dic1.keys()) - отображают, но не сортируют 
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+[45, 56, 78, 145]
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78} 
+```
+
+```py
+dic2={1:'mean',2:'standart deviation',3:'correlation'}
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']} - элементом словаря может являться сам словарь
+dic3
+{'statistics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']}
+
+dic3['statistics'][2]
+'standart deviation'
+```
+
+```py
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: Анисенков П.Д.'}
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: Анисенков П.Д.'}
+```
+
+```py
+tupl3 = ('A', 'B', 'C', 'D', 'E', 'F','G')
+l1st = ['1', '2', '3', '4', '5']
+
+dict227 = dict(zip(tupl3,l1st))
+dict227
+{'A': '1', 'B': '2', 'C': '3', 'D': '4', 'E': '5'}
+len(dict227)
+5 - элеменов получится пять, ведь команда zip работала столько раз, сколько элементов в наиболее маленьком объекте
+```
+
+```py
+AVTI={'Курс I':[22,23,17,24,30,29,28,25,23,0,4,31,30,33,18,12,27],'Курс II':[18,16,12,15,29,18,21,23,13,0,4,20,31,26,16,], 'Курс III':[17,12,0,6,17,15,19,19,0,0,5,17,22,18,12], 'Курс IV':[27,16,0,13,17,15,19,20,0,0,2,15,18,16,17]}
+
+AVTI['Курс III'][5]
+15
+```
+### 8.4 Множество
+
+-типы разные или одинаковые, но только неизменяемые и неповторяющиеся.
+
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+print(mnoz1)
+{'двигатель', 'датчик', 'микропроцессор', 'линия связи'}
+
+len(mnoz1)
+4
+```
+операции во множестве:
+```py
+'датчик' in mnoz1
+True
+mnoz1.add('реле')
+print(mnoz1)
+{'двигатель', 'датчик', 'линия связи', 'микропроцессор', 'реле'}
+mnoz1.remove('линия связи')
+print(mnoz1)
+{'двигатель', 'датчик', 'микропроцессор', 'реле'}
+```
+Было создано множество:
+
+```py
+mnoz1 = {'лев', '1', True, ('тигр', 1, 3)}
+mnoz1
+{'1', True, 'лев', ('тигр', 1, 3)}
+mnoz1.remove(True)
+mnoz1
+{'1', 'лев', ('тигр', 1, 3)}
+mnoz1.add('черный')
+mnoz1
+{('тигр', 1, 3), 'лев', '1', 'черный'}
+```
+## 9.
+
+exit()
+

TEMA2/task.md

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

TEMA2/test6.md

@@ -0,0 +1,24 @@
+# Контрольное задание по теме 2
+
+Анисенков Павел, А-01-23
+
+## Задание
+6. Пусть создан объект
+ hh=-12.2758
+Напишите инструкцию вывода на экран значения этого объекта, округленного до двух знаков после точки.
+
+
+## Решение
+    Для того чтобы округлять обьект используется функция round()
+```py
+hh=-12.2758
+print(round(hh))
+-12
+```
+округление прошло до целого
+```py
+print(round(hh,2))
+-12.28
+```
+округление прошло до 2 знаков после точки 
+итогом получилось число -12.28 так как следующее число после 8 это 5 значит округляется вверх

TEMA3/protokol33.py

@@ -0,0 +1,527 @@
+Тема 3 <Анисенков Павел Дмитриевич>
+Python 3.13.6 (tags/v3.13.6:4e66535, Aug  6 2025, 14:36:00) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+logiz1=bool(56)
+logiz2=bool(0)
+logiz3=bool("Beta")
+logiz4=bool("")
+logiz1
+True
+logiz2
+False
+logiz3
+True
+logiz4
+False
+tt1=int(198.6)
+tt1
+198
+tt2=int("-76")
+tt2
+-76
+tt3=int("B",16)
+tt3
+11
+tt4=int("71",8)
+tt4
+57
+tt5=int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#16>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+\
+ flt1=float(789)
+SyntaxError: unexpected indent
+flt1=float(789)
+flt1
+789.0
+flt2=float(-6.78e2)
+flt2
+-678.0
+flt22=float(98.76)
+flt22
+98.76
+flt3=float("Infinity")
+flt3
+inf
+flt4=float("-inf")
+flt4
+-inf
+hh=123
+dv1=bin(hh)
+dv1
+'0b1111011'
+vos1=oct(hh)
+vos1
+'0o173'
+shs1=hex(hh)
+shs1
+'0x7b'
+int(dv1,2)
+123
+int(dv1,8)
+Traceback (most recent call last):
+  File "<pyshell#36>", line 1, in <module>
+    int(dv1,8)
+ValueError: invalid literal for int() with base 8: '0b1111011'
+int(vos1,8)
+123
+int(shs1,16)
+123
+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}"
+spis1=list("Строка символов")
+spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+spis2=list((124,236,-15,908))
+spis2
+[124, 236, -15, 908]
+spis3=list({"A":1,"B":2,"C":9})
+spis3
+['A', 'B', 'C']
+spis3 = list({"A":1,"B":2,"C":9}.values())
+spis3
+[1, 2, 9]
+spis3 = list({"A":1,"B":2,"C":9}.items())
+spis3
+[('A', 1), ('B', 2), ('C', 9)]
+kort7=tuple('Строка символов')
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+ kort8=tuple(spis2)
+ 
+SyntaxError: unexpected indent
+kort8=tuple(spis2)
+kort8
+(124, 236, -15, 908)
+kort9=tuple({"A":1,"B":2,"C":9})
+kort9
+('A', 'B', 'C')
+del strk5, kort8
+strk5
+Traceback (most recent call last):
+  File "<pyshell#67>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+kort8
+Traceback (most recent call last):
+  File "<pyshell#68>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+name= "Анисенков П. Д."
+namelist = list(name)
+namelist
+['А', 'н', 'и', 'с', 'е', 'н', 'к', 'о', 'в', ' ', 'П', '.', ' ', 'Д', '.']
+nametup = tuple(namelist)
+nametup
+('А', 'н', 'и', 'с', 'е', 'н', 'к', 'о', 'в', ' ', 'П', '.', ' ', 'Д', '.')
+namestr = str(nametup)
+namestr
+"('А', 'н', 'и', 'с', 'е', 'н', 'к', 'о', 'в', ' ', 'П', '.', ' ', 'Д', '.')"
+12+7+90
+109
+5.689e-1 - 0.456
+0.11289999999999994
+23.6+54
+77.6
+14-56.7+89
+46.3
+-6.7*12
+-80.4
+-234.5/6
+-39.083333333333336
+ a=178/45
+ 
+SyntaxError: unexpected indent
+a=178/45
+a
+3.9555555555555557
+type(a)
+<class 'float'>
+b=178//45
+b
+3
+c=-24.6//12.1
+c
+-3.0
+d=-18//4.76468
+d
+-4.0
+KeyboardInterrupt
+148%33
+16
+12.6%3.8
+1.2000000000000002
+18%4.45656
+0.17376000000000147
+-18%4.45656
+4.282799999999998
+14**3
+2744
+e=2.7**3.6
+e
+35.719843790663525
+g=52**22.8
+g
+1.333141459723109e+39
+z1 = 3 + 4j, z2 = 1 - 2j
+SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?
+z1=3+4j
+z2=1-2j
+z1+z2
+(4+2j)
+z1-z2
+(2+6j)
+z1*z2
+(11-2j)
+z1/z2
+(-1+2j)
+z1**2
+(-7+24j)
+z1//z2
+Traceback (most recent call last):
+  File "<pyshell#109>", line 1, in <module>
+    z1//z2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+z1%z2
+Traceback (most recent call last):
+  File "<pyshell#110>", line 1, in <module>
+    z1%z2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+dv1=9
+dv2=~dv1
+dv2
+-10
+dv1
+9
+7&9
+1
+7&8
+0
+7|9
+15
+7|8
+15
+14|5
+15
+14:5
+SyntaxError: illegal target for annotation
+14^5
+11
+h=14
+g=h<<2
+g
+56
+g1=h>>1
+g1
+7
+g2=h>>2
+g2
+3
+a = 0b10110101
+b = 0b01101011
+a&b
+33
+a|b
+255
+a^b
+222
+a<<2
+724
+b<<3
+856
+'Система '+'регулирования'
+'Система регулирования'
+['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+'ля-'*5
+'ля-ля-ля-ля-ля-'
+['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1=[0]*3+[1]*99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+stroka='Система автоматического управления'
+stroka
+'Система автоматического управления'
+'автомат' in stroka
+True
+'ку' in ['ку','-']*3
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+stroka='Температура = %g %s  %g'
+stroka
+'Температура = %g %s  %g'
+stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+KeyboardInterrupt
+stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka
+'Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+zz=-12
+zz
+-12
+zz+=5
+zz
+-7
+zz-=3
+zz
+-10
+stroka='Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+zz/=2
+zz
+-5.0
+zz*=5
+zz
+-25.0
+dd=56.8
+dd//=
+SyntaxError: invalid syntax
+dd//=2
+dd
+28.0
+dd%=3
+dd
+1.0
+dd+=4
+dd
+5.0
+dd**=2
+dd
+25.0
+w=v=10
+n1,n2,n3=(11,-3,'all')
+n1
+11
+n3
+'all'
+n1, n2, n3 = "11-"
+n1
+'1'
+n3
+'-'
+n1, n2, n3 = [11, -3, 'all']
+n1
+11
+n3
+'all'
+python
+n1, n2, n3 = {11, -3, 'all'}
+SyntaxError: multiple statements found while compiling a single statement
+n1, n2, n3 = {11, -3, 'all'}
+n1
+-3
+n2
+11
+n3
+'all'
+n1, n2, n3 = {'a': 11, 'b': -3, 'c': 'all'}
+т1
+Traceback (most recent call last):
+  File "<pyshell#194>", line 1, in <module>
+    т1
+NameError: name 'т1' is not defined
+n`
+SyntaxError: invalid syntax
+n1
+'a'
+n2
+'b'
+w==v
+True
+w!=v
+False
+w<v
+False
+w>w
+False
+w>v
+False
+w<=v
+True
+w>=v
+True
+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
+a=17
+b=
+SyntaxError: invalid syntax
+b=6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+age = 25
+has_subscription = True
+blacklist = {'spam@mail.com', 'fake@mail.com'}
+user_email = "user@example.com"
+access = (age >= 18) and has_subscription and (user_email not in blacklist)
+access
+True
+w=v=10
+w is v
+True
+w1=['A','B']
+v1=['A','B']
+w1 is v1
+False
+stroka.find('пр')
+-1
+stroka.count("с")
+1
+stroka.replace(' у',' автоматического у')
+'Система регулирования'
+stroka
+'Система регулирования'
+KeyboardInterrupt
+spis22=stroka.split(' ')
+spis22
+['Система', 'регулирования']
+stroka.upper()
+'СИСТЕМА РЕГУЛИРОВАНИЯ'
+stroka3=" ".join(spis22)
+stroka3
+'Система регулирования'
+stroka3.partition("с")
+('Си', 'с', 'тема регулирования')
+stroka3.rpartition("с")
+('Си', 'с', 'тема регулирования')
+strk1='Момент времени {}, значение = {}'
+strk1
+'Момент времени {}, значение = {}'
+strk1.format(1,89.7
+
+             )
+'Момент времени 1, значение = 89.7'
+strk2='Момент времени {1}, значение = {0}:{2}'
+strk2
+'Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+strk3='Момент времени {num}, значение = {znch}'
+strk3
+'Момент времени {num}, значение = {znch}'
+strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+strk3
+'Момент времени {num}, значение = {znch}'
+spsk = [10, 'hello', 3.14, True, 'world', 10, 'python']
+spsk.pop(2)
+3.14
+spsk.append('c')
+spsk
+[10, 'hello', True, 'world', 10, 'python', 'c']
+spsk.insert(2,'a')
+spsk
+[10, 'hello', 'a', True, 'world', 10, 'python', 'c']
+spsk.count('a')
+1
+spsk.pop(1)
+'hello'
+spsk
+[10, 'a', True, 'world', 10, 'python', 'c']
+my_tuple = (1, 2, 3, 2, 'a', 'b', 'a', True)
+my_tuple.count(2)
+2
+my_tuple.insert(2,'a')
+Traceback (most recent call last):
+  File "<pyshell#265>", line 1, in <module>
+    my_tuple.insert(2,'a')
+AttributeError: 'tuple' object has no attribute 'insert'
+my_tuple.append('c')
+Traceback (most recent call last):
+  File "<pyshell#266>", line 1, in <module>
+    my_tuple.append('c')
+AttributeError: 'tuple' object has no attribute 'append'
+my_tuple.append('c')
+Traceback (most recent call last):
+  File "<pyshell#267>", line 1, in <module>
+    my_tuple.append('c')
+AttributeError: 'tuple' object has no attribute 'append'
+
+my_dict = {'name': 'Alice', 'age': 25, 'city': 'Moscow', 'age': 26}
+my_dict.count(2)
+Traceback (most recent call last):
+  File "<pyshell#270>", line 1, in <module>
+    my_dict.count(2)
+AttributeError: 'dict' object has no attribute 'count'
+my_dict.pop(2)
+Traceback (most recent call last):
+  File "<pyshell#271>", line 1, in <module>
+    my_dict.pop(2)
+KeyError: 2
+my_dict.pop(25)
+Traceback (most recent call last):
+  File "<pyshell#272>", line 1, in <module>
+    my_dict.pop(25)
+KeyError: 25
+my_dict.pop(0)
+Traceback (most recent call last):
+  File "<pyshell#273>", line 1, in <module>
+    my_dict.pop(0)
+KeyError: 0
+my_dict.count(2)
+Traceback (most recent call last):
+  File "<pyshell#274>", line 1, in <module>
+    my_dict.count(2)
+AttributeError: 'dict' object has no attribute 'count'
+"keys():", list(my_dict.keys())
+('keys():', ['name', 'age', 'city'])
+"values():", list(my_dict.values())
+('values():', ['Alice', 26, 'Moscow'])
+"pop('city'):", my_dict.pop('city')
+("pop('city'):", 'Moscow')
+my_dict
+{'name': 'Alice', 'age': 26}
+set1 = {1, 2, 3, 4, 5}
+set2 = {4, 5, 6, 7, 8}
+"add(9):", set1.add(9)
+('add(9):', None)
+set1
+{1, 2, 3, 4, 5, 9}
+set2.remove(3)
+Traceback (most recent call last):
+  File "<pyshell#283>", line 1, in <module>
+    set2.remove(3)
+KeyError: 3
+set1.remove(3)
+set1
+{1, 2, 4, 5, 9}

TEMA3/report.md

@@ -0,0 +1,768 @@
+# Отчет по теме 3
+
+Анисенков Павел, А-01-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE и создан протокол
+
+
+## 2 Преобразование базовых типов обьектов в другие типы
+
+Было изучено, как преобразовывать обьекты одного типа, в обьекты другого типа.
+
+## 2.1 Преобразование обьектов в логический тип данных
+
+Было изучено, как преобразовывать обьекты типа строка и число, в обьекты логического типа.
+
+```py
+>>>logiz1=bool(56)
+>>>logiz2=bool(0)
+>>>logiz3=bool("Beta")
+>>>logiz4=bool("")
+>>>logiz1
+True
+logiz2
+False
+logiz3
+True
+logiz4
+False
+```
+
+## 2.2 Преобразование обьектов в числовой тип данных
+
+Было изучено, как преобразовывать обьекты типа строка и число, в обьекты целого и вещественного типа int и float.
+
+```py
+>>>tt1=int(198.6) #Отбрасывается дробная часть
+>>>tt1
+198
+>>>tt2=int("-76")  #Число – в строке символов, система по умолчанию - десятичная
+>>>tt2
+-76
+>>>tt3=int("B",16) #В шестнадцатиричной системе буква "В" соответствует числу 11
+>>>tt3
+11
+>>>tt4=int("71",8) #71 преобразуется в число в восьмеричной системе
+>>>tt4
+57
+>>>tt5=int("98.76") #Число представлено в виде строки, но само по себе оно относится к вещественным числам (типа float), поэтому сразу невозможно его преобразовать в целое. Для такого преобразования надо сначала переопределить его как float, а уже потом как int.
+Traceback (most recent call last):
+  File "<pyshell#14>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+>>>flt1=float(789)
+>>>flt1
+789.0
+>>>flt2=float(-6.78e2)
+>>>flt2
+-678.0
+>>>flt3=float("Infinity")
+>>>flt3
+inf
+>>>flt4=float("-inf")
+>>>flt4
+-inf
+```
+
+
+## 2.3 Преобразование целочисленных обьектов в строки с двоичным, восьмеричным и шестнадцатеричным представлением и обратное представление
+
+Были преобразованы целочисленных обьекты в строки с двоичным, восьмеричным и шестнадцатеричным представлением и обратно представлены в целочисленном виде.
+
+```py
+>>>hh=123
+>>>dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+>>>vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+>>>shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+>>>dv1
+'0b1111011'
+>>>vos1
+'0o173'
+>>>shs1
+'0x7b'
+>>>int(dv1,2)
+123
+>>>int(vos1, 8)
+123
+>>>int(shs1, 16)
+123
+```
+
+## 3 Преобразование сложных типов обьектов в другие типы
+
+## 3.1 Преобразование элементов в строку символов
+
+В строку были преобразованы число, логическая переменная, список, кортеж и словарь.
+
+```py
+>>>strk1=str(23.6)
+>>>strk1
+'23.6'
+>>>strk2=str(logiz3)
+>>>strk2
+'True'
+>>>strk3=str(["A","B","C"])  #Преобразуем список
+>>>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']
+>>>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'?
+>>>f_spis=list(f_str)
+>>>f_kort=tuple(f_spis)
+>>>f_sstr=str(f_kort)
+name= "Анисенков П. Д."
+namelist = list(name)
+namelist
+['А', 'н', 'и', 'с', 'е', 'н', 'к', 'о', 'в', ' ', 'П', '.', ' ', 'Д', '.']
+nametup = tuple(namelist)
+nametup
+('А', 'н', 'и', 'с', 'е', 'н', 'к', 'о', 'в', ' ', 'П', '.', ' ', 'Д', '.')
+namestr = str(nametup)
+namestr
+"('А', 'н', 'и', 'с', 'е', 'н', 'к', 'о', 'в', ' ', 'П', '.', ' ', 'Д', '.')"
+```
+
+## 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!
+>>>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'>
+>>>ddd=56.88//45
+>>>ddd
+1.0
+>>>type(ddd)
+<class 'float'>
+>>>eee=45//56.88
+>>>eee
+0.0
+```
+
+## 4.5 Изучение получения отсатка от деления
+
+Был применен операнд остатка от деления, операция применена по отношению к целым и вещественным числам.
+
+```py
+>>>148%33   #Остаток от деления двух целых чисел
+16
+>>>12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+>>>18%4.45656
+0.17376000000000147
+>>>-18%4.45656
+4.282799999999998
+```
+
+## 4.6 Изучение возведения в степень
+
+Была применена операция возведения в степень с вещественными и целыми числами. 
+
+```py
+>>>14**3  #Целое число возводится в целую степень
+2744
+>>>e=2.7**3.6
+>>>e
+35.719843790663525
+>>>g=52**22.8
+>>>g
+1.333141459723109e+39
+```
+
+Также самостоятельно были произведены операции над комплексными числами. Выяснено, что выполнимы все вышеприведенные операции, кроме деления с округлением вниз и определения остатка.
+
+```py
+>>>z1=3+4j
+>>>z2=1-2j
+>>>z1+z2
+(4+2j)
+>>>z1-z2
+(2+6j)
+>>>z1*z2
+(11-2j)
+>>>z1/z2
+(-1+2j)
+>>>z1**2
+(-7+24j)
+>>>z1//z2
+Traceback (most recent call last):
+  File "<pyshell#109>", line 1, in <module>
+    z1//z2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+>>>z1%z2
+Traceback (most recent call last):
+  File "<pyshell#110>", line 1, in <module>
+    z1%z2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+```
+
+## 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
+```
+    14:  1 1 1 0
+    5:   0 1 0 1
+         ↓ ↓ ↓ ↓
+    ^:   1 0 1 1
+    выдает 1 где разные значения, 0 - где одинаковые
+Число 11 получилось при переводе числа 1011 из двоичной системы в десятичную. Это можно сделать с помощью выражения: 1*2^3 + 0*2^2 + 1*2^1 + 1*2^0 = 8 + 0 + 2 + 1 = 11
+
+## 5.5 Изучение сдвига двоичного представления на заданное число разрядов влево или вправо с дополнением нулями
+
+Был произведен сдвиг двоичного представления влево и вправо с дополнением нулями.
+
+```py
+>>>h=14   #Двоичное представление = 1110
+>>>g=h<<2  # Новое двоичное представление = 111000
+>>>g
+56
+>>>g1=h>>1  # Новое двоичное представление = 0111
+>>>g1
+7
+>>>g2=h>>2  # Новое двоичное представление = 0011
+>>>g2
+3
+```
+
+```py
+>>>a = 0b10110101
+>>>b = 0b01101011
+>>>a&b
+33
+>>>a|b
+255
+>>>a^b
+222
+>>>a<<2
+724
+>>>b<<3
+856
+```
+
+## 6 Изучение операций при работе с последовательностями (строками, списками, кортежами)
+
+## 6.1 Изучение обьединения обьектов различных типов
+
+Были обьеденены строки, списки и кортежи.
+
+```py
+>>>'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+>>>['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>>('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+## 6.2 Изучение повторения элементов обьекта различных типов
+
+Было произведено повторение строки, списка и кортежа
+
+```py
+>>>'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+>>>['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+>>>('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>>signal1=[0]*3+[1]*99
+>>>signal2=(0,)*3+(1,)*5+(0,)*7
+>>>signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+>>>signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+
+## 6.3 Изучение проверки наличия элементов в обьекте
+
+Было проверено наличие определенных элементов в строке, списке и кортеже.
+
+```py
+>>>stroka='Система автоматического управления'
+>>>'автомат' in stroka  #Наличие подстроки в строке
+True
+>>>'ку' in ['ку','-']*3  #Наличие контекста в списке
+True
+>>>'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+False
+```
+
+## 6.4 Изучение подстановки элементов в обьект
+
+Была произведена подстановка чисел и строки в обьект.
+
+```py
+>>>stroka='Температура = %g %s  %g'
+>>>stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+>>>stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>>stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+## 7 Изучение оператора присваивания 
+
+## 7.1 Изучение присваивания для переменной
+
+Была создана переменная и ей присвоено определенное значение.
+
+```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
+>>>xxx="zz"
+>>>xxx*=5
+>>>xxx
+'zzzzzzzzzz'
+```
+
+## 7.4 Изучение деления с округлением вниз, получение остатка деления и возведение в степень
+
+На переменной были самостоятельно испробованы операции деления с округлением вниз, получение остатка деления и возведение в степень.
+
+```py
+>>>dd=56.8
+>>>dd//=2
+>>>dd
+28.0
+>>>dd%=3
+>>>dd
+1.0
+>>>dd+=4
+>>>dd
+5.0
+>>>dd**=2
+>>>dd
+25.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-"
+>>>n1
+'1'
+>>>n3
+'-'
+>>>n1, n2, n3 = [11, -3, 'all']
+>>>n1
+11
+>>>n3
+'all'
+>>>n1, n2, n3 = {11, -3, 'all'}
+>>>n1
+-3
+>>>n2
+11
+>>>n3
+'all'
+>>>n1, n2, n3 = {'a': 11, 'b': -3, 'c': 'all'}>>>
+>>>n1
+'a'
+>>>n2
+'b'
+```
+
+## 8 Изучение логических операций
+
+Были изучены и применены некоторые логические операции, а также некоторые действия, с помощью логических операций.
+
+## 8.1 Изучение операций сравнения
+
+К двум переменным были применены различные операции сравнения.
+
+```py
+>>>w==v
+True
+>>>w!=v
+False
+>>>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 Изучение создания выражений с соединительными словами И, ИЛИ, НЕ
+
+Были построены выражения с соединитиельными словами И, ИЛИ, НЕ.
+
+```py
+>>>a=17
+>>>b=-6
+>>>(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+>>>(5>6) and ('kazan' in dic1) and not ('Linchik' in mnoz1)
+False
+>>>(5>6) and (7>5) or ("Saratov" in dic1)
+True
+```
+
+## 8.4 Изучение проверки ссылок переменных на наличие одного и того же обьекта
+
+Было проверено, являются ли созданные обьекты одними и теми же обьектами в памяти.
+
+```py
+>>>w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+>>>w is v
+True
+>>>w1=['A','B']
+>>>v1=['A','B']
+>>>w1 is v1 #В данном случае эти переменные не записаны в один адрес памяти, питон создает для списков два разных обьекта, так как список это изменяемый тип и так как значение для переменных присваивалось по-отдельности. Так питон гарантирует, что изменение одного списка не повлияет на другой. 
+False
+```
+
+## 9 Изучение операций с обьектами, проводимыми с помощью методов
+
+Была создана строка и выведена все методы для нее.
+
+```py
+>>>stroka='Микропроцессорная система управления'
+>>>dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+## 9.1 Изучение методов применимых для строки
+
+Были применены разные методы для работы со строками.
+
+```py
+>>>stroka.find('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -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 = [10, 'hello', 3.14, True, 'world', 10, 'python']
+>>>spsk.pop(2)
+3.14
+>>>spsk.append('c')
+>>>spsk
+[10, 'hello', True, 'world', 10, 'python', 'c']
+>>>spsk.insert(2,'a')
+>>>spsk
+[10, 'hello', 'a', True, 'world', 10, 'python', 'c']
+>>>spsk.count('a')
+1
+>>>spsk.pop(1)
+'hello'
+>>>spsk
+[10, 'a', True, 'world', 10, 'python', 'c']
+```
+
+## 9.3 Изучение методов применимых к кортежам
+
+Были применены разные методы для работы с кортажами и применены.
+
+```py
+>>>my_tuple = (1, 2, 3, 2, 'a', 'b', 'a', True)
+>>>my_tuple.count(2)
+2
+>>>my_tuple.insert(2,'a')
+Traceback (most recent call last):
+  File "<pyshell#265>", line 1, in <module>
+    my_tuple.insert(2,'a')
+AttributeError: 'tuple' object has no attribute 'insert'
+>>>my_tuple.append('c')
+Traceback (most recent call last):
+  File "<pyshell#266>", line 1, in <module>
+    my_tuple.append('c')
+AttributeError: 'tuple' object has no attribute 'append'
+>>>my_tuple.append('c')
+Traceback (most recent call last):
+  File "<pyshell#267>", line 1, in <module>
+    my_tuple.append('c')
+AttributeError: 'tuple' object has no attribute 'append'
+```
+
+## 9.4 Изучение методов применимых к словарям 
+
+Были применены разные методы для работы со словарями и применен один из них.
+
+```py
+>>>my_dict = {'name': 'Alice', 'age': 25, 'city': 'Moscow', 'age': 26}
+>>>my_dict.count(2)
+Traceback (most recent call last):
+  File "<pyshell#270>", line 1, in <module>
+    my_dict.count(2)
+AttributeError: 'dict' object has no attribute 'count'
+>>>my_dict.pop(2)
+Traceback (most recent call last):
+  File "<pyshell#271>", line 1, in <module>
+    my_dict.pop(2)
+KeyError: 2
+>>>my_dict.pop(25)
+Traceback (most recent call last):
+  File "<pyshell#272>", line 1, in <module>
+    my_dict.pop(25)
+KeyError: 25
+>>>my_dict.pop(0)
+Traceback (most recent call last):
+  File "<pyshell#273>", line 1, in <module>
+    my_dict.pop(0)
+KeyError: 0
+>>>my_dict.count(2)
+Traceback (most recent call last):
+  File "<pyshell#274>", line 1, in <module>
+    my_dict.count(2)
+AttributeError: 'dict' object has no attribute 'count'
+"keys():", list(my_dict.keys())
+('keys():', ['name', 'age', 'city'])
+"values():", list(my_dict.values())
+('values():', ['Alice', 26, 'Moscow'])
+"pop('city'):", my_dict.pop('city')
+("pop('city'):", 'Moscow')
+```
+
+## 10 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.

TEMA3/task.md

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

TEMA3/test.md

@@ -0,0 +1,58 @@
+# Контрольное задание по 1 модулю
+
+Анисенков Павел, А-01-23
+
+## Задание 12
+1)	Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле?
+
+2)	Создайте объект-кортеж с 6 элементами - названиями фруктов. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Создайте новый кортеж добавлением к последним трем элементам ранее созданного кортежа ещё двух элементов: "фейхоа" и "маракуйя". Отобразите получившийся объект. Напишите инструкцию, позволяющую установить индекс элемента "фейхоа" в новом кортеже. 
+
+4)	Преобразуйте кортеж в список, а затем список - в новый кортеж. Отобразите полученный объект. Напишите инструкцию проверки совпадения нового и старого кортежей.
+
+5)	Преобразуйте кортеж в символьную строку. Отобразите объект. Напишите инструкцию, которая позволит определить начальную позицию, начиная с которой в строку входит подстрока с заданным наименованием фрукта.
+
+
+## Решение
+    Через cmd: python test.py
+    В  IDLE: test (без расширения написать в командном окне)
+             File - Open - test.py - F5
+             import test
+```py
+fruits = ('яблоко', 'банан', 'апельсин', 'киви', 'груша', 'ананас')
+type(fruits)
+<class 'tuple'>
+dir(fruits)
+['__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']
+```
+```py
+fruits5 = fruits[-3:] + ('фейхоа', 'маракуйя')
+fruits5
+('киви', 'груша', 'ананас', 'фейхоа', 'маракуйя')
+nomer = fruits5.index('фейхоа')
+nomer
+3
+```
+```py
+fruitspis = list(fruits5)
+type(fruitspis)
+<class 'list'>
+fruits4 = tuple(fruitspis)
+fruits4
+('киви', 'груша', 'ананас', 'фейхоа', 'маракуйя')
+type(fruits4)
+<class 'tuple'>
+fruits5 == fruits4
+True
+```
+
+```py
+fruits6 = str(fruits5)
+fruits6
+"('киви', 'груша', 'ананас', 'фейхоа', 'маракуйя')"
+fruits6.find('Груша')
+-1
+fruits6.find('груша')
+10
+```

TEMA4/protokl.txt

@@ -0,0 +1,93 @@
+#Тема 4 <Анисенков Павел Дмитриевич>
+
+Python 3.13.6 (tags/v3.13.6:4e66535, Aug  6 2025, 14:36:00) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+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\))
+     
+SyntaxError: unexpected character after line continuation character
+type(round(123.456,1))
+     
+<class 'float'>
+type(round(123.456,))
+     
+<class 'int'>
+len(123)
+     
+Traceback (most recent call last):
+  File "<pyshell#7>", line 1, in <module>
+    len(123)
+TypeError: object of type 'int' has no len()
+len('hello')
+     
+5
+import pylab
+imp
+ort sys
+SyntaxError: invalid syntax
+import sys
+x=list(range(-3,55,4))
+=list(range(15))
+SyntaxError: invalid syntax
+t=list(range(15))
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000002A6746F8F50>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+  pylab.xlabel('время')
+  
+SyntaxError: unexpected indent
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show() #Отображение графика на экране
+ывав
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000002A675E05950>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000002A675E05A90>]
+pylab.show()
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000002A6745F7CB0>, <matplotlib.patches.Wedge object at 0x000002A675783750>, <matplotlib.patches.Wedge object at 0x000002A675783B10>, <matplotlib.patches.Wedge object at 0x000002A675783D90>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()  #Отображение диаграммы
+data = [1, 2, 3, 3, 2, 3, 3, 3, 2]
+pylab.hist(data, bins=3)
+(array([1., 3., 5.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+SyntaxError: multiple statements found while compiling a single statement
+pylab.hist(data, bins=3)
+(array([1., 3., 5.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+pylab.title("Гистограмма")
+Text(0.5, 1.0, 'Гистограмма')
+Text(0.5, 1.0, 'Гистограмма')
+Traceback (most recent call last):
+  File "<pyshell#34>", line 1, in <module>
+    Text(0.5, 1.0, 'Гистограмма')
+NameError: name 'Text' is not defined. Did you mean: 'next'?
+pylab.show()
+c = ['A', 'B', 'C', 'D']
+v = [25, 40, 30, 50]
+pylab.bar(c, v)
+<BarContainer object of 4 artists>
+pylab.title("Столбиковая диаграмма")
+Text(0.5, 1.0, 'Столбиковая диаграмма')
+pylab.show()
+

TEMA4/protokol.py

@@ -0,0 +1,92 @@
+#Тема 4 <Анисенков Павел Дмитриевич>
+
+Python 3.13.6 (tags/v3.13.6:4e66535, Aug  6 2025, 14:36:00) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+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\))
+     
+SyntaxError: unexpected character after line continuation character
+type(round(123.456,1))
+     
+<class 'float'>
+type(round(123.456,))
+     
+<class 'int'>
+len(123)
+     
+Traceback (most recent call last):
+  File "<pyshell#7>", line 1, in <module>
+    len(123)
+TypeError: object of type 'int' has no len()
+len('hello')
+     
+5
+import pylab
+imp
+ort sys
+SyntaxError: invalid syntax
+import sys
+x=list(range(-3,55,4))
+=list(range(15))
+SyntaxError: invalid syntax
+t=list(range(15))
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000002A6746F8F50>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+  pylab.xlabel('время')
+  
+SyntaxError: unexpected indent
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show() #Отображение графика на экране
+ывав
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000002A675E05950>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000002A675E05A90>]
+pylab.show()
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000002A6745F7CB0>, <matplotlib.patches.Wedge object at 0x000002A675783750>, <matplotlib.patches.Wedge object at 0x000002A675783B10>, <matplotlib.patches.Wedge object at 0x000002A675783D90>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()  #Отображение диаграммы
+data = [1, 2, 3, 3, 2, 3, 3, 3, 2]
+pylab.hist(data, bins=3)
+(array([1., 3., 5.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+SyntaxError: multiple statements found while compiling a single statement
+pylab.hist(data, bins=3)
+(array([1., 3., 5.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+pylab.title("Гистограмма")
+Text(0.5, 1.0, 'Гистограмма')
+Text(0.5, 1.0, 'Гистограмма')
+Traceback (most recent call last):
+  File "<pyshell#34>", line 1, in <module>
+    Text(0.5, 1.0, 'Гистограмма')
+NameError: name 'Text' is not defined. Did you mean: 'next'?
+pylab.show()
+c = ['A', 'B', 'C', 'D']
+v = [25, 40, 30, 50]
+pylab.bar(c, v)
+<BarContainer object of 4 artists>
+pylab.title("Столбиковая диаграмма")
+Text(0.5, 1.0, 'Столбиковая диаграмма')
+pylab.show()

TEMA4/report.md

@@ -0,0 +1,466 @@
+# Отчет по теме 4
+
+Анисенков Павел, А-01-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE.
+
+## 2 Изучение стандартных встроенных функций 
+
+## 2.1 Изучение функции округления
+
+Была применена функция round, были изучены различия между указанием одного и двух аргументов.
+
+```py
+>>>help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+>>>round(123.456,1)
+123.5
+>>>round(123.456,0)
+123.0
+>>>type(round(123.456,1))
+<class 'float'>
+>>>type(round(123.456,0)) #В результате получаются числа класса float, так как указано сколько цифр после запятой нужно оставить. Два вышеупомянутых варианта отличаются тем что первое округляется по 1 цифре после запятой а второе - по целому числу.
+<class 'float'>
+>>>round(123.456)
+123
+>>>type(round(123.456)) #В данном случае получается число типа int, так как не указано количество цифр после запятой, и по умолчанию число округляется до целого.
+<class 'int'>
+```
+
+## 2.2 Изучение функции создания последовательности
+
+Была применена функция range и изучена разница между способами применения функции.
+
+```py
+>>>gg=range(76,123,9)
+>>>gg
+range(76, 123, 9) #итерируемый объект
+>>>list(gg)
+[76, 85, 94, 103, 112, 121]
+>>>range(23) #При указывание одного аргумента строится последовательность от 0 до указанного числа не включительно, с шагом 1.
+range(0, 23)
+>>>list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+## 2.3 Изучение функции zip
+
+Была применена функция zip и произведена попытка обращения к элементу созданной последовательности по индексу.
+
+```py
+>>>qq=["Anisenkov", "Filippov", "Filippova", "Podolskiy"]
+>>>ff=zip(gg,qq)
+>>>tuple(ff) #В итоге получится последовательность из 4 элементов, так как в qq 4 элемента, а в gg 6. Длина равна длине самого короткого списка.
+((76, 'Anisenkov'), (85, 'Filippov'), (94, 'Filippova'), (103, 'Podolskiy'))
+>>>ff[1] #Исходя из текста ошибки, можно сказать, что zip обьекты не поддерживают доступ по индексу.
+Traceback (most recent call last):
+  File "<pyshell#15>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+
+## 2.4 Изучение функции eval 
+
+Была применена функция eval.
+
+```py
+>>>fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=6
+>>>dan
+-126.0 #вычисляет выражение
+```
+
+## 2.5 Изучение функции exec
+
+Была применена функция exec.
+
+```py
+>>>exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>>gg
+221.456 #выполняет блок кода
+```
+Вывод: eval() для вычислений с возвратом значения, exec() для выполнения кода без возврата значения.
+exec() не возвращает значение функции, но он выполняет код, который может создавать, изменять или удалять переменные в текущей области видимости. Поэтому переменная gg становится доступной после выполнения exec().
+
+
+
+## 2.6 Изучение ряда полезных функций (abs, pow, max, min, sum, divmod, len, map)
+
+Был изучен и применен ряд полезных функций:
+
+abs - выдает значение по модулю;
+```py
+>>>abs(-5)
+5
+```
+pow - при двух аргументах: возводит первый в степень второго, при наличие третьего аргумента делит получившийся результат на третий аргумент и показывает остаток;
+```py
+>>>pow(3, 2, 3)
+0
+>>>pow(3, 2)
+9
+```
+max - выдает максимальное число из списка введенных в аргумент; 
+min - выдает минимальное число из списка введенных в аргумент;
+```py
+>>>max(3, 4)
+4
+>>>min(3, 4)
+3
+```
+sum - суммирует числа;
+```py
+>>>sum([2, 3])
+5
+```
+divmod  - возвращает кортеж (a // b, a % b), где а и b соответственно первый и второй аргумент;
+```py
+>>>divmod(7, 2)
+(3, 1)
+```
+len - выдает длину обьекта;
+```py
+>>>len('hello')   
+5
+```
+map - применяет функцию из первого аргумента к каждому элементу итерируемого обьекта, который указан во втором аргументе.
+```py
+>>>list(map(lambda x: x*2, [1, 2, 3, 4]))
+[2, 4, 6, 8]
+```
+
+## 3 Изучение функций из модуля math для работы с математическими выражениями и операциями.
+
+Был импортирован и изучен модуль math. Были изучены и применены некоторые функции из модуля math.
+
+```py
+>>>import math
+>>>dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>>help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+>>>math.factorial(5)
+120
+
+>>>help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+>>>help(math.ceil)
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+
+    This is the smallest integer >= x.
+```
+
+sin - считает и выдает синус аргумента в радианах;
+```py
+>>>math.sin(180)
+-0.8011526357338304
+```
+acos - считает и выдает арккосинус аргумента в радианах;
+```py
+>>>math.acos(0.5)
+1.0471975511965979
+```
+degrees - переводит число в радианах в градусы;
+```py
+>>>math.degrees(0.5)
+28.64788975654116
+```
+radians - переводит число в градусах в радианы;
+```py
+>>>math.radians(28)
+0.4886921905584123
+```
+exp - выдает значение числа e возведенного в степень, которая указана в аргументе;
+```py
+>>>math.exp(1)
+2.718281828459045
+```
+log - считает натуральный логарифм числа;
+log10 - считает делятичный логарифм числа;
+```py
+>>>math.log(1)
+0.0
+>>>math.log10(1)
+0.0
+```
+sqrt - считает корень из числа в аргументе;
+```py
+>>>math.sqrt(9)
+3.0
+```
+ceil - округляет число вверх;
+floor - округляет число вниз;
+```py
+>>>math.ceil(4.7)
+5
+>>>math.floor(4.7)
+4
+```
+pi - данная функция является представлением числа пи в питоне.
+```py
+>>>math.pi
+3.141592653589793
+```
+Вычисление значения функции sin(2π/7+e0.23 ):
+```py
+>>>math.sin(2*math.pi/7+math.exp(0.23))
+0.8334902641414562
+```
+
+## 4 Изучение модуля cmath для работы с комплексными числами
+
+Был импортирован и изучен модуль 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 Изучения стандартного модуля randon для работы с псевдослучайными числами
+Модуль random – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+Были самостоятельно изучены и применены методы модуля random:
+
+random - равномерно распределенное случайное число;  
+uniform- равномерно распределенное случайное число в диапазоне, заданном двумя аргументами;  
+randint - случайные целые числа в диапазоне от значения первого аргумента до значения второго;
+gauss - нормально распределенное случайное число с средним равным певому аргументу и стандартным отклонением равным второму аргументу; 
+choice - случайный выбор из совокупности указанной в аргументе; 
+shuffle - случайная перестановка элементов списка в аргументе; 
+sample - случайный выбор подмножества элементов из списка в первом аргументе (количество элементов равно числу, указанному во втором аргументе); 
+betavariate - случайное число с бета-распределением, где альфа равна первому аргументу, а бета равна второму аргументу;
+gammavariate - случайное число с гамма-распределением, где альфа равна первому аргументу, а бета равна второму аргументу.
+
+Также был самостоятельно создан список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям и с любыми допустимыми значениями параметров этих распределений.
+
+```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() # Использует текущее время системы
+# Каждый запуск программы даст разные последовательности
+# Фиксированное начальное значение
+# Всегда одинаковая последовательность для тестов
+>>>r = random.random() #случайное число от 0.0 до 1.0
+>>>r
+0.915829800247012
+>>>u = random.uniform(1, 10) #равномерное распределение на интервале [a, b] 
+>>>u
+6.398971726523061
+>>>rnd = random.randint(1, 10) # случайное целое число от a до b (включительно)
+>>>rnd
+3
+>>>g = random.gauss(0, 1) # - нормальное распределение(ср, ст откл)
+>>>g
+1.6312864971445826
+>>>l = ["a", "b", "c"]
+>>>ch = random.choice(l) # случайный элемент из последовательности
+>>>ch
+'b'
+>>>random.shuffle(l) # перемешивает список на месте
+>>>l
+['b', 'a', 'c']
+>>>s = random.sample(l, 2) # выбирает k уникальных элементов
+>>>s
+['c', 'b']
+>>>b = random.betavariate(2, 5) # бета-распределение
+>>>b
+0.20276652629326136
+>>>g = random.gammavariate(2, 2) # гамма-распределение
+>>>g
+4.361266204290336
+>>>random_list = [random.uniform(1, 10), random.gauss(5, 2), random.betavariate(2, 5),  random.gammavariate(2, 2)]
+>>>random_list
+[1.8429009082320071, 5.582736307655225, 0.21284691290111155, 2.9271296316078654]
+```
+
+## 6 Изучение модуля time для работы со временем и календарями
+
+Были изучены и применены методы из модуля time:
+
+time - возвращает время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г;
+gmtime - возвращает объект класса struct_time, содержащий полную информацию о текущем времени (UTC): год (tm_year), месяц (tm_mon), день tm_mday)...;
+localtime - для получения «местного» времени (которое стоит на компьютере);
+asctime - преобразовывает представление времени из кортежа в строку (просто отображает время в формате строки);
+ctime - преобразовывает время в секундах, прошедшего с начала эпохи, в строку;
+sleep - прерывает работу программы на заданное время в секундах; 
+mktime - преобразовает время из типа кортежа или struct_time в число секунд с начала эпохи.
+
+```py
+>>>import time
+>>>dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+>>>c1=time.time()
+>>>c1
+1757585123.0268378
+>>>c1=time.time() #Для проверки заново применили функцию спустя 14 секунд.
+>>>c1
+1757585137.4425445
+>>>c2=time.time()-c1
+>>>c2
+272.143741607666
+>>>dat=time.gmtime()
+>>>dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=10, tm_min=13, tm_sec=29, tm_wday=3, tm_yday=254, tm_isdst=0) #день недели  день года летнее время
+>>>dat.tm_mon
+9
+>>>tim=time.localtime() #местное
+>>>tim
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=12, tm_min=15, tm_sec=7, tm_wday=3, tm_yday=254, tm_isdst=0)
+>>>time.asctime() #из кортежа в строку
+'Thu Sep 11 12:16:36 2025'
+>>>time.ctime()
+'Thu Sep 11 12:16:57 2025'
+>>>time.sleep(2) #Две секунды в IDLE не появлялось приглашение для ввода команды.
+>>>time.mktime(tim)
+1757585707.0
+>>>time.localtime(c1)
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=12, tm_min=5, tm_sec=37, tm_wday=3, tm_yday=254, tm_isdst=0)
+```
+
+## 7 Изучение графических функций
+
+Был создан линейный график, на котором изображена зависимость сигналов от времени.
+
+```py
+>>>import pylab
+>>>x=list(range(-3,55,4))
+>>>x
+[-3, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53]
+>>>t=list(range(15))
+>>>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 0x0000022B3EEDAD50>]
+>>>pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>>pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>>pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>>pylab.show() #Отображение графика на экране
+```
+
+![](4.1.png)
+
+Были созданы два линейных графика на одном поле. (По оси y - значения из списка, по оси х - порядковый номер значений).
+
+```py
+>>>X1=[12,6,8,10,7]
+>>>X2=[5,7,9,11,13]
+>>>pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000022B3EFEB890>]
+>>>pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000022B3EFEB9D0>]
+>>>pylab.show()
+```
+
+![](4.2.png)
+
+Также была создана круговая диаграмма.
+
+```py
+>>>region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>>naselen=[65,12,23,17]  # Значения для диаграммы
+>>>pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000022B3EEAE3C0>, <matplotlib.patches.Wedge object at 0x0000022B42875590>, <matplotlib.patches.Wedge object at 0x0000022B42875950>, <matplotlib.patches.Wedge object at 0x0000022B42875BD0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>>pylab.show()  #Отображение диаграммы
+```
+
+![](4.3.png)
+
+Самостоятельно была создана гистограмма (по оси у - частота повторения значений, по оси х сами значения)
+
+```py
+>>>data = [1, 2, 3, 3, 2, 3, 3, 3, 2]
+>>>pylab.hist(data, bins=3)
+(array([1., 3., 5.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+>>>pylab.title("Гистограмма")
+Text(0.5, 1.0, 'Гистограмма')
+>>>pylab.show()
+```
+
+![](4.4.png)
+
+Самостоятельно была создана столбиковая диаграмма, где по оси х - категории, а по оси у - значения, относящиеся к каждой категории.
+
+```py
+>>>c = ['A', 'B', 'C', 'D']
+>>>v = [25, 40, 30, 50]
+>>>pylab.bar(c, v)
+<BarContainer object of 4 artists>
+>>>pylab.title("Столбиковая диаграмма")
+Text(0.5, 1.0, 'Столбиковая диаграмма')
+>>>pylab.show()
+```
+
+![](5.5.png)
+
+## 8 Изучение модуля statistics для работы в сфере статистики
+
+Самостоятельно был импортирован и изучен модуль statistics. Из него были использованы функции подсчета среднего значения, медианы и моды для выборки в списке.
+
+```py
+>>>import statistics
+>>>dir(statistics)
+['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_kernel_invcdfs', '_mean_stdev', '_newton_raphson', '_normal_dist_inv_cdf', '_quartic_invcdf', '_quartic_invcdf_estimate', '_random', '_rank', '_sqrt_bit_width', '_sqrtprod', '_ss', '_sum', '_triweight_invcdf', '_triweight_invcdf_estimate', 'acos', 'asin', 'atan', 'bisect_left', 'bisect_right', 'correlation', 'cos', 'cosh', 'count', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'isfinite', 'isinf', 'itemgetter', 'kde', 'kde_random', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'namedtuple', 'numbers', 'pi', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sin', 'sqrt', 'stdev', 'sumprod', 'sys', 'tan', 'tau', 'variance']
+>>>data = [1, 2, 2, 3, 4, 5, 5, 5, 6]
+>>>mean = statistics.mean(data)
+>>>mean
+3.6666666666666665
+>>>median = statistics.median(data)
+>>>median
+4
+>>>mode = statistics.mode(data)
+>>>mode
+5
+```
+
+## 9 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.
+ 
+

TEMA4/task.md

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

TEMA4/test.md

@@ -0,0 +1,26 @@
+# Индивидуальное контрольное задание по теме 4
+Анисенков Павел, А-01-23
+
+## Задание 7
+Создайте кортеж с 4 случайными числами, равномерно распределенными на интервале от 4.5 до 18.8. Реализуйте инструкцию случайного выбора одного из элементов кортежа. Отобразите его по шаблону: «Выбран элемент <значение> с индексом <индекс>».
+
+## Решение
+
+```py
+import random
+def one_number():
+    return round(random.uniform(4.5, 18.8), 2)
+
+# Создаем кортеж используя map с итерируемым объектом из 4 элементов
+numbers = tuple(map(lambda x: one_number(), [None]*4))
+numbers
+(13.26, 12.09, 13.92, 14.5)
+
+# Случайный выбор
+el = random.choice(numbers)
+13.26
+ind = numbers.index(el)
+0
+print(f"Выбран элемент {el} с индексом {ind}")
+Выбран элемент 13.26 с индексом 0
+```

TEMA5/report.md

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

TEMA5/task.md

@@ -0,0 +1,93 @@
+# Общее контрольное задание по теме 5
+
+Анисенков Павел, А-01-23
+
+## Задание
+
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+    • Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+    • Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+    • Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+
+```py
+>>>import string
+>>>text = "Why are you running?"
+>>>for char in text:
+    if char in string.ascii_lowercase:
+        order = string.ascii_lowercase.index(char) + 1
+        print(char, "=", order)
+    else:
+        print("это не буква")
+
+W = неопознанный объект  
+h = 8
+y = 25
+  = неопознанный объект  
+a = 1
+r = 18
+e = 5
+  = неопознанный объект 
+y = 25
+o = 15
+u = 21
+  = неопознанный объект 
+r = 18
+u = 21
+n = 14
+n = 14
+i = 9
+n = 14
+g = 7
+? = неопознанный объект   
+
+>>>Str = "Создайте список со словами из задания данного пункта"
+>>>L=list(Str.split())
+>>>L
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта']
+>>>slovo = 'список'
+>>>if slovo in L:
+    print("Это слово есть в тексте")
+else: print("Этого слова нет в тексте")
+
+Это слово есть в тексте
+>>>slovo = "Привет"
+>>>if slovo in L:
+    print("Это слово есть в тексте")
+else: print("Этого слова нет в тексте")
+
+Этого слова нет в тексте
+
+students = ["Anisenkov", "Anisenkov1", "Anisenkov22", "Anisenkov333"]
+leto = [4, 5, 3, 5]
+students2 = ["Anisenkov22", "Anisenkov333", "Anisenkov1", "Anisenkov"]
+zima = [5, 3, 2, 3]
+name=input("Введите фамилию студента: ")
+Введите фамилию студента: Anisenkov
+if name in students and name in students2:
+    leto_grade = leto[students.index(name)]
+    zima_grade = zima[students2.index(name)]
+    print("Студент:", name, ". Летняя:", leto_grade, ", Зимняя:", zima_grade)
+else:
+    print("Студент", name, "не найден.")
+
+    
+Студент: Anisenkov . Летняя: 4 , Зимняя: 3
+
+students = ["Anisenkov", "Anisenkov1", "Anisenkov22", "Anisenkov333"]
+leto = [4, 5, 3, 5]
+students2 = ["Anisenkov22", "Anisenkov333", "Anisenkov1", "Anisenkov"]
+zima = [5, 3, 2, 3]
+name=input("Введите фамилию студента: ")
+Введите фамилию студента: Morgenshtern
+if name in students and name in students2:
+    leto_grade = leto[students.index(name)]
+    zima_grade = zima[students2.index(name)]
+    print("Студент:", name, ". Летняя:", leto_grade, ", Зимняя:", zima_grade)
+else:
+    print("Студент", name, "не найден.")
+
+
+Студент Morgenshtern не найден.
+```

TEMA5/test.md

@@ -0,0 +1,36 @@
+# Индивидуальное контрольное задание по теме 5
+
+Анисенков Павел, А-01-23, Вариант 2
+
+## Задание
+
+Напишите инструкции, обеспечивающие формирование на основе заданного списка нового списка, содержащего только целочисленные элементы из первого списка. 
+
+## Решение
+
+```py
+primer = [1, 2.5, "hello", 3, True, 7.8, 10, "world", 15, None]
+celoe1 = []
+for el in primer:
+    if type(el) == int:
+        celoe1.append(el)
+    else:
+        continue 
+
+print(celoe1)
+[1, 3, 10, 15]
+
+
+celoe2 = []
+for el in primer:
+    if type(el) == int:
+        celoe2.append(el)
+
+print("Только целые числа:", celoe2)
+Только целые числа: [1, 3, 10, 15]
+
+
+celoe3 = [el for el in primer if type(el) == int]
+print(celoe3)
+[1, 3, 10, 15]
+```

TEMA6/Stroka.txt

@@ -0,0 +1 @@
+запись строки в файл

TEMA6/popul.txt

@@ -0,0 +1 @@
+{-0.48, 1.68, 2.38, 3.86, 4.91, 5.83, 4.2, 7.17, 8.31, 9.92, 9.68, 9.15, 9.52, 0.27, -6.61, -13.16, -0.15, -12.69, -9.35, -3.17, -7.77, -4.01, -18.3, -17.27, -17.51, -18.08, -14.69, -18.46, -16.27, -15.08, -18.42, -9.82, -17.19, -13.97, -6.91, -11.2, -11.48, -3.5, -2.11, -1.49}

TEMA6/report.md

@@ -0,0 +1,433 @@
+# Отчет по теме 6
+
+Анисенков Павел, А-01-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE.
+
+## 2 Вывод данных на экран дисплея
+
+Были изучены и применены различные способы вывода данных на экран.
+
+## 2.1 Изучение вывода данных в командной строке
+
+```py
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+## 2.2 Изучение вывода данных с помощью печати
+
+Была изучена функция print для вывода текста. Текст был выведен в одну строку, далее в две строки с использованием экранированных последовательностей, далее был выведен текст с дописанным в конце текстом, используя аргумент end. И также был выведен текст в три строки, используя троиные кавычки.
+
+```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 Вывод данных с помощью функции write
+
+Был испортирован модуль sys, и использована функция write, которая записывает и выводит текст, а так же возвращается количество байтов, записанных в строку. В первом вариаенте нет перехода на новую строку перед 13
+
+```
+>>>import sys
+>>>sys.stdout.write('Функция write') 
+Функция write13 #в cmd, если print то не будет
+>>>sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+
+## 3 Ввод данных с клавиатуры
+
+С помощью функции input был произведен вывод текста, введенного с клавиатуры. Так же был создан цикл, который просит пользователя ввести значение до тех пор, пока оно не будет удовлетворять определенному интервалу, а потом выводит это значение на дисплей. Также с помощью функции eval Была создана команда, благодаря которой выражение, введенное пользователен с консоли исполняется, и выдается результат расчета.
+
+```py
+>>>psw=input('Введите пароль:')
+Введите пароль:52spb
+>>>psw
+'52spb'
+>>>type(psw)
+<class 'str'> #функция input всегда возвращает строку
+>>>while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach<17.5 or znach>23.8:
+		print('Ошибка!')
+	else:
+		break
+
+	    
+Задайте коэф.усиления = 11.1
+Ошибка!
+Задайте коэф.усиления = 22.8
+>>>import math
+>>>print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## 4 Ввод вывод при работе с файлами
+
+Были изучены и применены разные способы чтения и записи данных.
+
+## 4.1 Изучение модуля os для работы с путями к файлам
+```py
+import os
+os.getcwd()
+'C:\\Users\\Professional\\AppData\\Local\\Programs\\Python\\Python313'
+Anisenkovv=os.getcwd()
+os.chdirs
+Anisenkovv = os.getcwd()
+Anisenkovv
+'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA6'
+os.mkdir("MIBOMBO")
+os.rmdir("MIBOMBO")
+os.listdir("C:\\Users\\Professional\\Desktop\\python-labs\\TEMA6")
+['.gitkeep', '1.png', '2.png', 'report.md', 'маамама.md']
+import os.path
+os.path.isdir("C:\\Users\\Professional\\Desktop\\python-labs\\TEMA6")
+True
+
+```
+Был просмотрен текущий рабочий каталог, занесен в переменную Anisenkovv. Были самостоятельно изучены и применены методы из модуля os и подмодуля os.path:
+
+mkdir - создает папку в рабочем каталоге (в приложенном фото видно, что в каталоге появилвсь папка); 
+![](1.png)
+rmdir - удаляет из каталога пустую папку;
+![](2.png)
+listdir - возвращает список имен файлов/папок в указанном каталоге (или если аргумент не указан, то в текущем каталоге);
+path.isdir - возвращает true, если папка является существующей в каталоге.
+
+Далее была создана переменная, содержащая строку - путь в файлу report и имя данного файла. Используя эту переменную, с помощью функций модуля os была создана строка содержащая только путь, потом только имя, а потом применена функция, которая разделяет в одну переменную - путь, в другую - имя файла. Далее было проверено существование определенного пути, и существование определенного файла с указаном каталоге. 
+
+```py
+
+>>>fil=os.path.abspath("report.md")
+>>>fil
+'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA6\\report.md'
+>>>drkt=os.path.dirname(fil) # путь к файлу report.md
+>>>drkt
+'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA6'
+>>>name = os.path.basename(fil) # имя файла
+>>>name
+'report.md'
+>>>head, tail = os.path.split(fil)
+>>>head
+'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA6'
+>>>tail
+'report.md'
+>>>os.path.exists ("C:\\Users\\Professional\\Desktop\\python-labs\\TEMA6")#существует ли путь
+True
+>>>os.path.exists("C:\\Users\\Professional\\Desktop\\python-labs\\TEMA10")
+False
+>>>os.path.isfile(fil) #наличие файла с известным расположением 
+True
+```
+
+## 4.2 Изучение обобщенного процесса работы с файлами
+
+Было определено, что для обмена данными с файлами необходимо:
+
+    • Открыть файла с указанием его имени и цели;
+    • Выполнить операции обмена данными с файлом;
+    • Закрыть файл.
+
+## 4.3 Функция open для открытия файлов с разной целью
+
+Была применена команда open с различным написанием аргументов, создан файловый обьект. Выведен тип и список атрибутов этого обьекта.
+	w – запись с созданием нового файла или перезапись существующего файла,
+	w+ - чтение и запись/перезапись файла,
+    r – только чтение (это значение - по умолчанию),
+	r+ - чтение и/или запись в существующий файл,
+	a – запись в конец существующего файла или, если его нет, запись с созданием файла,
+	a+ - то же, что и в «a», но с возможностью чтения из файла.
+
+```py
+help(open)
+Help on built-in function open in module _io:
+
+open(
+    file,
+    mode='r',
+    buffering=-1,
+    encoding=None,
+    errors=None,
+    newline=None,
+    closefd=True,
+    opener=None
+)
+    Open file and return a stream.  Raise OSError upon failure.
+    ...
+
+
+>>>fp=open(file=drkt+'\\zapis1.txt',mode='w') #сохраняет ссылку на открываемый файл и позволяет в дальнейшем ссылаться на файл, не указывая путь и имя открытого файла
+                                                          
+>>>fp=open(drkt+'\\zapis1.txt','w') #Если имя файла располагается на месте первого аргумента, а цель использования – на втором
+                                                          
+>>>fp=open('zapis1.txt','w') #Если путь в переменной drkt совпадает с рабочим каталогом
+                                                          
+>>>type(fp)
+                                                          
+<class '_io.TextIOWrapper'> #файловый объект для текстовых данных в Python, который имеет ряд атрибутов и методов
+>>>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']
+
+fp1=open(drkt+'\\zapis2.bin',mode='wb+') # бинарный файл
+```
+
+## 4.4 Закрытие файла
+```py
+>>>fp.close()
+
+```
+
+## 4.5 Изучение функции write для записи данных в текст
+
+Был создан список из 12 элементов и поочередно в файл записаны числа из списка в три строки.
+
+```py
+>>>sps=list(range(1,13))
+         
+>>>sps
+         
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+>>>fp2=open('zapis3.txt','w')
+         
+>>>fp2.write(str(sps[:4])+'\n')
+         
+13
+>>>fp2.write(str(sps[4:8])+'\n')
+         
+13
+>>>fp2.write(str(sps[8:])+'\n')
+         
+16
+>>>fp2.close()
+```
+
+![](31.png)
+
+Далее был создан список из трех списков и с помощью цикла for все элементы списка были вписаны в файл в одну строку.
+
+```py         
+>>>sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+         
+>>>sps3
+         
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>>fp3=open('zapis4.txt','w')
+         
+>>>for i in range(len(sps3)):
+	stroka4=sps3[i][0]+' '+str(sps3[i][1])
+	fp3.write(stroka4)
+
+         
+11
+11
+12
+>>>fp3.close()
+```
+![](4.png)
+         
+Далее с помощью цикла for три списка из общего списка были вписаны в файл поочередно в три строки. Запись цикла была сжата в одну строку, и проверено, что при написании той же инструкции в одну строку, содержимое файла не изменяется, относительно предыдущего метода с этими же инструкциями.
+
+```py
+>>>gh=open('zapis5.txt','w')
+         
+>>>for r in sps3:
+		gh.write(r[0]+' '+str(r[1])+'\n')
+
+         
+12
+12
+13
+>>>gh.close()
+         
+>>>gh=open('zapis6.txt','w')
+         
+>>>for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+
+         
+12
+12
+13
+```
+
+![](5.png)
+
+## 4.6 Изучение одного из способов чтения данных из файла с помощью цикла for
+
+С помощью open был открыт файл для чтения, и из его символов был сконструирован список, состоящий из символов. После символы в списке были преобразованы в числа, и список стал идентичен тому, который создавался ранее и записывался в файл.
+
+```py
+>>>sps1=[]
+>>>fp=open('zapis3.txt')
+>>>for stroka in fp:
+	stroka=stroka.rstrip('\n')
+	stroka=stroka.replace('[','')
+	stroka=stroka.replace(']','')
+	sps1=sps1+stroka.split(',')
+
+	
+>>>fp.close()
+>>>sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12'] #все элементы как строки
+
+>>>sps2=[]
+>>>for i in sps1:
+    sps2.append(int(i)) #каждый элемент из sps1 (который является строкой) преобразуется в целое число с помощью int(i)
+>>>sps2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+## 4.7 Изучение способа чтения данных из файла с помощью функции read
+
+Был открыт текстовый файл и с помощью функции read из него сначала было прочитано и отображено 12 символов, а потом прочитаны остальные символы с помощью функции 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'
+```
+
+## 4.8 Изучение чтения данных из файла по строкам
+
+Самостоятельно были изучены и применены функции: readline - которая читает одну строку, начиная с указателя текущей позиции, и функция readlines, которая по такому же принципу читает все строки и возвращает их в виде списка.
+
+```py
+>>>fp=open('zapis3.txt')
+         
+>>>s1 = fp.readline()
+         
+>>>s2=fp.readline()
+         
+>>>s1
+         
+'[1, 2, 3, 4]\n'
+>>>s2
+         
+'[5, 6, 7, 8]\n'
+>>>fp.close()
+         
+>>>fp=open('zapis3.txt')
+>>>s3 = fp.readlines()
+>>>s3
+['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+```
+
+## 4.9 Изучение работы с бинарными файлами с помощью модуля pickle
+
+С помощью модуля pickle созданное множество было вписано в бинарный файл, а потом данные прочитаны из этого файла.
+
+```py
+>>>import pickle
+>>>mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+>>>fp=open('zapis6.mnz','wb')  # Бинарный файл – на запись
+>>>pickle.dump(mnoz1,fp)  #dump – метод записи объекта в файл
+>>>fp.close()
+>>>fp=open('zapis6.mnz','rb')
+>>>mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+>>>fp.close()
+>>>mnoz2 #Результат не такой как при вводе множества mnoz1, так как множество не имеет повторений и порядка элементов, поэтому автоматически множество обьединило повторяющиеся слова.
+{'pen', 'iPhone', 'book', 'table'}
+mnoz1 == mnoz2
+True
+```
+
+![Просмотр бинарного файла](6.png)
+
+Также в файл было записано два обьекта и прочитано поочередно с помощью load.
+
+```py
+>>>fp=open('zapis7.2ob','wb')
+>>>pickle.dump(mnoz1,fp)
+>>>pickle.dump(sps3,fp)
+>>>fp.close()
+>>>fp=open('zapis7.2ob','rb')
+>>>obj1=pickle.load(fp)  #Первое обращение к load читает первый объект
+>>>obj2=pickle.load(fp)  #Второе – читает второй
+>>>fp.close()
+>>>obj1
+{'pen', 'iPhone', 'book', 'table'}
+>>>obj2
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+
+## 5. Перенаправление потоков ввода и вывода данных.
+
+Был создан текстовый файл, куда с помощью модуля sys и методы stdout был перенаправлен поток вывода, и в нем был напечатан текст. Далее поток вывода был перенаправлен обратно и проведена проверка с помощью print.
+
+```py
+>>>import sys
+>>>vr_out=sys.stdout  #Запоминаем текущий поток вывода
+>>>fc=open('Stroka.txt','w') #Откроем файл вывода
+>>>sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+>>>print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>>sys.stdout=vr_out  #Восстановление текущего потока
+>>>print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+>>>fc.close()
+```
+
+![Просмотр содержимого файла stroka.txt](7.png)
+
+Также был перенаправлен ввод на файл, и реализован цикл, в котором считывается текст из файла и печатается на экран.
+
+```py
+>>>tmp_in = sys.stdin #Запоминаем текущий поток ввода
+>>>fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+>>>sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+>>>sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+>>>while True:
+	try:
+		line = input () #Считываем из файла строку
+		print(line)  # Отображаем считанное
+	except EOFError:
+		break
+
+	    
+запись строки в файл
+>>>fd.close()
+>>>sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+```
+ 
+## 6 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.

TEMA6/task.md

@@ -0,0 +1,73 @@
+# Общее контрольное задание по теме 6
+
+Анисенков Павел, А-01-23
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+    • Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+    • Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+    • Записывается кортеж в бинарный файл.
+    • Записывается в этот же файл список и закрывается файл.
+    • Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+    • Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+    • Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Решение
+
+```py
+>>>import random
+>>>import os
+>>>import pickle
+>>>str_kor = tuple(str(random.randint(6, 56)) for _ in range(125))
+>>>str_kor
+('27', '38', '7', '18', '35', '11', '41', '35', '20', '24', '43', '7', '48', '17', '26', '39', '35', '17', '54', '22', '31', '11', '8', '38', '7', '34', '22', '14', '36', '7', '15', '23', '48', '34', '31', '18', '39', '55', '18', '11', '32', '18', '51', '34', '41', '31', '8', '11', '28', '25', '42', '56', '10', '52', '6', '9', '15', '53', '36', '27', '48', '6', '53', '50', '51', '49', '11', '11', '16', '36', '39', '39', '18', '52', '14', '44', '13', '27', '26', '27', '23', '13', '36', '24', '34', '27', '21', '6', '37', '29', '53', '13', '54', '22', '26', '46', '36', '22', '48', '11', '24', '28', '9', '23', '36', '45', '6', '55', '9', '31', '22', '42', '50', '55', '46', '7', '55', '17', '54', '32', '39', '41', '14', '49', '22')
+
+>>>L_fam = ["Anisenkov1", "Anisenkov2", "Anisenkov3", "Anisenkov4", "Anisenkov5"]
+
+>>>os.chdir("C:\\Users\\Professional\\Desktop\\python-labs\\TEMA6")
+
+>>>f = open('bin.mnz', 'wb')
+>>>pickle.dump(str_kor, f)
+>>>pickle.dump(L_fam, f)
+>>>f.close()
+
+>>>f = open('bin.mnz', 'rb')
+>>>obj1 = pickle.load(f)
+>>>obj2_spis = pickle.load(f)
+>>>obj1
+('27', '38', '7', '18', '35', '11', '41', '35', '20', '24', '43', '7', '48', '17', '26', '39', '35', '17', '54', '22', '31', '11', '8', '38', '7', '34', '22', '14', '36', '7', '15', '23', '48', '34', '31', '18', '39', '55', '18', '11', '32', '18', '51', '34', '41', '31', '8', '11', '28', '25', '42', '56', '10', '52', '6', '9', '15', '53', '36', '27', '48', '6', '53', '50', '51', '49', '11', '11', '16', '36', '39', '39', '18', '52', '14', '44', '13', '27', '26', '27', '23', '13', '36', '24', '34', '27', '21', '6', '37', '29', '53', '13', '54', '22', '26', '46', '36', '22', '48', '11', '24', '28', '9', '23', '36', '45', '6', '55', '9', '31', '22', '42', '50', '55', '46', '7', '55', '17', '54', '32', '39', '41', '14', '49', '22')
+>>>obj2_spis
+['Anisenkov1', 'Anisenkov2', 'Anisenkov3', 'Anisenkov4', 'Anisenkov5']
+>>>if obj1 == str_kor:
+    print("обьекты кортежа совпадают")
+else: print("обьекты кортежа не совпадают")
+
+обьекты кортежа совпадают
+
+>>>if obj2_spis == L_fam:
+    print("обьекты списка совпадают")
+else: print("обьекты списка не совпадают")
+
+обьекты списка совпадают
+
+>>>List = []
+>>>for i in range(0, 125, 5):
+    List.append(list(str_kor[i:i + 5]))
+
+    
+>>>List
+[['27', '38', '7', '18', '35'], ['11', '41', '35', '20', '24'], ['43', '7', '48', '17', '26'], ['39', '35', '17', '54', '22'], ['31', '11', '8', '38', '7'], ['34', '22', '14', '36', '7'], ['15', '23', '48', '34', '31'], ['18', '39', '55', '18', '11'], ['32', '18', '51', '34', '41'], ['31', '8', '11', '28', '25'], ['42', '56', '10', '52', '6'], ['9', '15', '53', '36', '27'], ['48', '6', '53', '50', '51'], ['49', '11', '11', '16', '36'], ['39', '39', '18', '52', '14'], ['44', '13', '27', '26', '27'], ['23', '13', '36', '24', '34'], ['27', '21', '6', '37', '29'], ['53', '13', '54', '22', '26'], ['46', '36', '22', '48', '11'], ['24', '28', '9', '23', '36'], ['45', '6', '55', '9', '31'], ['22', '42', '50', '55', '46'], ['7', '55', '17', '54', '32'], ['39', '41', '14', '49', '22']]
+
+>>>lists_dict = {}
+>>>for i in range(25):
+    list_name = f"list{i + 1}"
+    code = f"{list_name} = List[{i}]"
+    exec(code)
+    
+>>>print(list1)
+>>>print(list2)
+
+['27', '38', '7', '18', '35']
+['11', '41', '35', '20', '24']
+```

TEMA6/test.md

@@ -0,0 +1,60 @@
+# Контрольное задание Модуль 2
+
+Анисенков Павел, А-01-23
+
+## Задание
+
+M2_8
+Создайте множество с 40 элементами - случайными  числами, равномерно распределенными на интервале от -20 до +10. Числа должны быть округлены до двух знаков после точки.
+
+Запросите у пользователя и введите имя бинарного файла для сохранения множества. Если во введенном имени есть пробелы, замените их на пустые строки.
+
+Запишите множество в бинарный файл с указанным именем.
+
+Удалите из памяти созданное множество.
+
+Прочитайте множество из файла и рассчитайте по его элементам среднее значение. Отобразите его на экране по шаблону: " По <число элементов> среднее = <рассчитанное значение>". Выводимое среднее округлить до двух знаков после точки.
+
+
+## Решение
+
+```py
+>>>import random
+>>>import os
+>>>import pickle
+>>>os.chdir("C:\\Users\\Professional\\Desktop\\python-labs\\TEMA6")
+
+>>>numbers = {round(random.uniform(-20, 10), 2) for _ in range(40)}
+numbers
+{-0.48, 1.68, 2.38, 3.86, 4.91, 5.83, 4.2, 7.17, 8.31, 9.92, 9.68, 9.15, 9.52, 0.27, -18.3, -17.27, -17.51, -3.5, -14.69, -0.15, -9.82, -6.91, -18.08, -18.46, -16.27, -15.08, -18.42, -17.19, -13.97, -11.2, -11.48, -9.35, -13.16, -7.77, -6.61, -12.69, -4.01, -3.17, -2.11, -1.49}
+
+file_name = input("Введите имя бинарного файла: ")
+Введите имя бинарного файла: popul.txt
+file_name = file_name.replace(" ", "")
+
+f=open('popul.txt', 'wb')
+pickle.dump(numbers, f)
+f.close()
+
+del numbers
+numbers
+Traceback (most recent call last):
+  File "<pyshell#44>", line 1, in <module>
+    numbers
+NameError: name 'numbers' is not defined. Did you forget to import 'numbers'?
+
+f=open('popul.txt', 'rb')
+obj1 = pickle.load(f)
+obj1
+{-0.48, 1.68, 2.38, 3.86, 4.91, 5.83, 4.2, 7.17, 8.31, 9.92, 9.68, 9.15, 9.52, 0.27, -6.61, -13.16, -0.15, -12.69, -9.35, -3.17, -7.77, -4.01, -18.3, -17.27, -17.51, -18.08, -14.69, -18.46, -16.27, -15.08, -18.42, -9.82, -17.19, -13.97, -6.91, -11.2, -11.48, -3.5, -2.11, -1.49}
+
+if obj1:
+    average = sum(obj1) / len(obj1)
+    average = round(average, 2)
+    print(f"По {len(obj1)} элементам среднее = {average}")
+else:
+    print("Множество пустое")
+
+    
+По 40 элементам среднее = -5.31
+```

TEMA6/zapis3.txt

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

TEMA6/zapis4.txt

@@ -0,0 +1 @@
+Иванов И. 1Петров П. 2Сидоров С. 3

TEMA6/маамама.md

@@ -0,0 +1,252 @@
+# Отчёт по теме 6. Ввод-вывод данных и операции с файлами
+
+Выполнил Огарков Илья, А-03-23
+
+## 1. Начало работы
+
+Создание текстового файла `report.md`
+
+## 2. Вывод данных на экран дисплея
+
+**2.1. Вывод в командной строке**
+```python
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+**2.2. Вывод с использованием функции  print**
+```python
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+fff=234.5;gg='Значение температуры = '
+print(gg,fff, sep="/")
+Значение температуры = /234.5
+print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+**2.3. Вывод с использованием метода write  объекта sys.stdout**
+```python
+import sys
+sys.stdout.write('Функция write')//это файловый объект, который представляет стандартный вывод программы; функция write выводит количесто символов
+Функция write13
+sys.stdout.write('Функция write\n')
+Функция write
+14//количество символов увеличилось на +1, так как /n - это тоже отдельныйы символ
+```
+
+## 3. Ввод данных с клавиатуры
+```python
+psw=input('Введите пароль:')
+Введите пароль:1234
+psw;type(psw)
+'1234'
+<class 'str'>
+
+while True:
+    znach=float(input('Задайте коэф.усиления = '))
+    if znach<17.5 or znach>23.8:
+        print('Ошибка!')
+    else:
+        break
+
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета =  math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## 4. Ввод-вывод при работе с файлами.
+
+**4.1. Функции для работы с путем к файлу**
+```python
+import os
+os.getcwd() //функция показывает, какой рабочий каталог установлен в текущий момент времени(cwd = current working directory)
+'C:\\Program Files\\Python311'
+Ogarkov = os.getcwd();print(Ogarkov)
+C:\Program Files\Python311
+
+os.chdir('d:\\users\\tmp5\\') \\изменение расположения рабочего каталога
+
+os.mkdir("C:\\Users\\Ilya\\Desktop\\mkdir") \\создание новой директории
+os.rmdir("C:\\Users\\Ilya\\Desktop\\mkdir") \\удаляет пустую директорию. Если в директории есть файлы или другие папки - возникает ошибка
+os.listdir("C:\\Users\\Ilya\\Desktop") \\возвращает список имён всех файлов и папок в указанной директории
+['1.py', 'Adobe Photoshop 2025.lnk', 'AIDA64.lnk', 'bar', 'Cisco Secure Client.lnk', 'desktop.ini', 'Google Chrome.lnk', 'Labs', 'MSI Afterburner.lnk', 'Nexus', 'OBS Studio.lnk', 'python-labs', 'qBittorrent.lnk', 'Remote Desktop Connection.lnk', 'Telegram.lnk', 'Visual Studio Code.lnk', 'Wub', 'Yandex.lnk', 'ВАЖНОЕ_СЕРВЕР.txt', 'Документы огарков А.С', 'Золотой фонд цитат.txt', 'КМ1ОгарковИльяА-03-23.docx', 'Новая папка', 'Покер', 'Расписание.txt', 'РКН ФИКС', 'ТАУ', 'Фото']
+import os.path
+os.path.isdir("C:\\Users\\Ilya\\Desktop\\ТАУ") \\проверяет, является ли указанный путь директорией, возвращает True, если путь существует и является директорией
+True
+
+os.path.abspath("LICENSE.txt")
+'C:\\Users\\Ilya\\AppData\\Local\\Programs\\Python\\Python313\\LICENSE.txt'
+drkt = os.path.dirname(fil);drkt \\функция os.path.dirname(fil) возвращает директорию (папку) из указанного пути, убирая последний компонент (обычно имя файла)
+'C:\\Users\\Ilya\\AppData\\Local\\Programs\\Python\\Python313'
+os.path.basename(Ogarkov) \\возвращает последний компонент пути - обычно это имя файла или конечной папки
+'Python313'
+os.path.split(Ogarkov) \\разделяет путь на две части: директорию и имя файла/папки. Возвращает кортеж (head, tail)
+('C:\\Users\\Ilya\\AppData\\Local\\Programs\\Python', 'Python313')
+os.path.exists(Ogarkov) \\проверяет существование пути
+True
+os.path.exists("C:\\Users\\Ilya\\AppData\\Local\\Programs\\Python\\mkdir")
+os.path.isfile(fil) \\проверяет наличие файла в рабочем каталоге
+              
+True
+```
+
+**4.3. Открытие файла для записи или чтения данных – функция open.**
+```python
+os.chdir('C:\\Users\\Ilya\\Desktop\\python-labs\\TEMA6')
+              
+fp=open(file='zapis1.txt',mode='w')
+
+type(fp);dir(fp)
+              
+<class '_io.TextIOWrapper'>
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+fp1=open('zapis2.bin',mode='wb+')
+```
+
+**4.4. Закрытие файла**
+```python
+fp.close();fp1.close()
+```
+
+**4.5. Запись информации в файл с помощью метода write**
+```python
+sps = list(range(1,13))
+fp2=open('zapis3.txt','w')          
+fp2.write(str(sps[:4])+'\n')           
+13
+fp2.write(str(sps[4:8])+'\n')          
+13
+fp2.write(str(sps[8:])+'\n')            
+16
+fp2.close()
+
+for i in range(len(sps3)):
+              stroka4=sps3[i][0]+' '+str(sps3[i][1])
+              fp3.write(stroka4)
+11
+11
+12
+fp3.close()
+
+gh = open('zapis5.txt','w')    
+for r in sps3:
+              gh.write(r[0]+' '+str(r[1])+'\n')
+12
+12
+13
+gh.close() 
+```
+
+**4.6. Первый способ чтения информации из текстового файла**
+```python
+fp = open('zapis3.txt')
+for stroka in fp:
+    stroka=stroka.rstrip('\n')
+    stroka=stroka.replace('[','')
+    stroka=stroka.replace(']','')
+    sps1=sps1+stroka.split(',')
+
+fp.close()
+sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+```
+
+**4.7. Чтение информации из файла с помощью метода read**
+```python
+fp = open('zapis3.txt')
+stroka1 = fp.read(12); stroka1 \\число показывает количество читаемых символов в txt или количество бит в бит файле
+'[1, 2, 3, 4]'
+stroka2 = fp.read()
+stroka2
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+fp.close()
+```
+
+**4.8. Чтение информации с помощью методов readline и readlines**
+```python
+fp = open('zapis3.txt', 'r')
+fp.readline() \\функция читает одну строку
+'[1, 2, 3, 4]\n'
+fp.close()
+
+fp = open('zapis3.txt', 'r')
+fp.readlines() \\функция читает все строки
+['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+fp.close()
+```
+
+**4.9. Ввод-вывод объектов с использованием функций из модуля pickle**
+```python
+import pickle \\это модуль в Python для сериализации и десериализации объектов. Он преобразует объекты Python в поток байтов (сериализация) и обратно (десериализация)
+mnoz1={'pen','book','pen','iPhone','table','book'}
+fp = open('zapis6.mnz','wb')
+pickle.dump(mnoz1, fp) \\функция dump принимает объект и сериализует в поток байтов
+fp.close()
+
+fp = open('zapis6.mnz', 'rb')
+mnoz2 = pickle.load(fp); mnoz2 \\load – метод чтения объекта из бинарного файла
+{'pen', 'iPhone', 'book', 'table'}
+fp.close()
+
+fp = open('zapis7.2ob', 'wb')
+pickle.dump(mnoz1, fp)
+sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+pickle.dump(sps3,fp)
+fp.close()
+fp = open('zapis7.2ob', 'rb')
+obj1 = pickle.load(fp); obj1
+{'pen', 'iPhone', 'book', 'table'}
+obj2 = pickle.load(fp); obj2
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+fp.close()
+```
+
+## 5. Перенаправление потоков ввода и вывода данных
+```python
+import sysм \\это импорт встроенного модуля sys, который предоставляет доступ к системным параметрам и функциям, связанным с интерпретатором Python
+vr_out = sys.stdout
+fc = open('Stroka.txt', 'w')
+sys.stdout = fc
+print('запись строки в файл')
+sys.stdout = vr_out
+print('запись строки на экран')
+запись строки на экран
+fc.close()
+
+tmp_in = sys.stdin
+fd = open("Stroka.txt", "r")
+sys.stdin = fd
+sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+while True:
+    try:
+        line = input()
+        print(line)
+    except EOFError:
+        break
+
+запись строки в файл
+fd.close()
+sys.stdin = tmp_in
+```

TEMA7/report.md

@@ -0,0 +1,573 @@
+# Отчет по теме 7
+
+Анисенков Павел, А-01-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE.
+```py
+os.chdir('C:\\Users\\Professional\\Desktop\\python-labs\\TEMA7')
+```
+
+## 2 Изучение создания пользовательских функций
+
+Было изучено создание функций.
+
+## 2.1 Изучение создания функции без аргументов
+
+Была создана и потом применена функция, которая печатает определенный текст. Был определен класс функции и просмотрено пространство имен, в котором появилось название созданной функции. Просмотрена помощь по функции, в которой был выведен комментарий, созданный при создании функции. Можно сделать вывод, что в описании к функции нужно описать ее концепцию, что делает функция и какие аргументы нужно указывать.
+
+```py
+>>>def uspeh():
+    """Подтверждение успеха операции"""
+    print('Выполнено успешно!')
+
+    
+>>>uspeh()
+Выполнено успешно!
+>>>type(uspeh)
+<class 'function'>
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+>>>help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+docstring помогает другим разработчикам понимать, что делает функция, не изучая её код.
+
+## 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
+>>>n,m="А","а";sravnenie(n,m)
+А  меньше  а #Каждому символу присвоен кодовый номер в стандарте Unicode A = U+0041 (десятичное: 65), a = U+0061 (97)
+```
+
+## 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([1,2],[-1,-2],[0,2],[-1,-1]) #Сложение списков
+q
+[1, 2, -1, -2, 0, 2, -1, -1]
+>>>kor = ("a", 8)
+>>>kor2 = ("b", 9)
+>>>kor3 = ("c", 10)
+>>>kor4 = ("d", 11)
+>>>k=slozh(kor, kor2, kor3, kor4)
+>>>k
+('a', 8, 'b', 9, 'c', 10, 'd', 11)
+>>>sl1 = {"A": 8, "B": 9}
+>>>sl2 = {"B": 10, "C": 11}
+>>>sl3 = {"D": 12, "E": 13}
+>>>sl4 = {"F": 14, "H": 15}
+>>>sl=slozh(sl1, sl2, sl3, sl4)
+Traceback (most recent call last):
+  File "<pyshell#47>", line 1, in <module>
+    sl=slozh(sl1, sl2, sl3, sl4)
+  File "<pyshell#29>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+>>>mn1 = {"A", "B"}
+>>>mn2 = {"C", "D"}
+>>>mn3 = {"E", "F"}
+>>>mn4 = {"H", "J"}
+>>>mn=slozh(mn1, mn2, mn3, mn4)
+Traceback (most recent call last):
+  File "<pyshell#55>", line 1, in <module>
+    mn=slozh(mn1, mn2, mn3, mn4)
+  File "<pyshell#29>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+
+## 2.5 Изучение создания функции, которая создает список со значениями вычисленных сигналов
+
+Была создана функция, которая вычисляет значение по определенной формуле, далее реализован цикл, в котором созданный ранее список пополняется новыми значениями выходного сигнала, которые зависят от предыдущего значения выходного сигнала. По данным выходного сигнала был построен график.
+
+```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 pylab
+>>>spsm = list(range(101))
+>>>pylab.plot(spsm, spsy)
+[<matplotlib.lines.Line2D object at 0x000001E1619A6850>]
+>>>pylab.show()
+```
+
+![](1.png)
+
+## 3 Изучение действий с функциями как с обьектами
+
+## 3.1 Изучение вывода подсказок по функции
+
+Были выведены атрибуты созданной функции и применен один из них, который показал описание функции, которое также было выведено с помощью функции help.
+
+```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__
+'Модель устройства с памятью:\n       x- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства'
+>>>help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+           x- текущее значение вх.сигнала,
+    T -постоянная времени,
+    ypred - предыдущее значение выхода устройства
+```
+
+## 3.2 Изучение создания ссылки на обьект
+
+Была создана ссылка на функцию и уже по этой ссылке вызвана функция, которая сравнила два числа по величине.
+
+```py
+>>>fnkt=sravnenie
+>>>v=16
+>>>fnkt(v,23)
+16  меньше  23
+```
+
+## 3.3 Изучение применения условия if для применения разных функций
+
+Был создан цикл-условия, в котором при одном условии функция определяется одними инструкциями, а при другом условии - другими. И была вызвана эта функция.
+
+```py
+>>>typ_fun=8
+>>>if typ_fun==1:
+	def func():
+		print('Функция 1')
+else:
+	def func():
+		print('Функция 2')
+
+		
+>>>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
+```
+
+## 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.3363486314678965
+```
+## 4.3 Изучение передачи аргументов функции в произвольном порядке
+Функция была вызвана с передачей аргументов не по порядку, а по названию аргументов.
+
+```py
+>>>logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами a/(1+math.exp(-b))
+0.34498724056380625
+```
+
+## 4.4 Изучение передачи аргумента в виде ссылки на список/ кортеж
+
+Была вызвана функция, которой в качестве аргументов была передана ссылка на список.
+
+```py
+b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+>>>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
+```
+
+## 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 #  (-1) * 9 + 2
+
+>>>def func5(**slovar):
+    print(slovar)
+>>>func5(a=5, n=8, m=30)
+{'a': 5, 'n': 8, 'm': 30}
+```
+
+## 4.9 Изучение изменения обьектов внутри функции
+
+Были созданы функции, внутри которых передаваемый аргумент как-либо был изменен, и после применения функции, просмотрено значение переменных. Числовая переменная осталась такой же (а созданная внутри функции переменная "a" не имела связи с созданной "а" вне функции), какой была задана, элемент списка изменился, а при попытке передать в функцию кортеж вышла ошибка.
+
+```py
+>>>a=90    # Числовой объект – не изменяемый тип
+>>>def func3(b):
+	a=5*b+67
+
+	
+>>>a #Переменная не изменилась
+90
+>>>sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+>>>def func2(sps):
+	sps[1]=99
+
+	
+>>>func2(sps1)
+>>>print(sps1) #Элемент списка изменился
+[1, 99, 3, 4]
+>>>kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+>>>def func2(kort):
+        kort[1]=99
+    
+>>>print(kort)
+(1, 2, 3, 4)
+```
+
+## 5 Изучение специальных типов пользовательских функций
+
+Были изучены и созданы анонимные функции и функции-генераторы.
+
+## 5.1 Изучение анонимных функций
+
+Были созданы и применены функции без имени без аргументов, с двумя аргументами и с необязательным аргументом.
+
+```py
+>>>import math
+>>>anfun1=lambda: 1.5+math.log10(17.23)  #Анонимная функция без аргументов
+>>>anfun1()   # Обращение к объекту-функции
+2.7362852774480286
+>>>anfun2=lambda a,b : a+math.log10(b)  #Анонимная функция с 2 аргументами
+>>>anfun2(17,234)
+19.369215857410143
+>>>anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
+>>>anfun3(100)
+102.36921585741014
+```
+
+## 5.2 Изучение функции-генератора
+
+Была создана функция-генератор, которая производит последовательность чисел. Она была выведена с помощью цикла for, а также генерирующиеся значения были выведены поотдельности, с помощью метода __next__.
+
+```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#165>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+## 6 Изучение обьектов в функциях
+
+Были изучены локальные и глобальные обьекты, а также смоделирована система управления.
+
+## 6.1 Изучение работы с глобальными и локальными обьектами
+
+Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции.
+Была создана функция, внутри которой уже существующей в глобальном пространстве переменной было присвоено определенное новое значение. При выполнении функции глобальная переменная не изменялась. Далее внутри созданной функции была попытка напечатать переменную, которой не существует в пространстве имен функции. Также была создана функция, внутри которой была обьявлена переменная как глобальная и после этого она была изменена внутри функции, что изменило ее в глобальном пространстве.
+
+```py
+>>>glb=10
+>>>def func7(arg):
+	loc1=15
+	glb=8
+	return loc1*arg
+
+    
+>>>res=func7(glb) #Для получения результата здесь использовалось значение переменной glb=10, то есть глобальной переменной, потому что именно она была передана в arg, который использовался в вычислениях.
+>>>res
+150
+>>>glb #Значение переменной не изменилось, так как это глобальная переменная и вне функции она не переопределялась.
+10
+>>>def func8(arg):
+	loc1=15
+	print(glb)  
+	glb=8
+	return loc1*arg
+
+    
+>>>res=func8(glb) #В данном случае выведется ошибка, так как до функции print внутри пространства имен функции переменной glb не существует 
+Traceback (most recent call last):
+  File "<pyshell#178>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#177>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+
+>>>glb=11
+>>>def func7(arg):
+	loc1=15
+	global glb
+	print(glb)
+	glb=8
+	return loc1*arg
+
+    
+>>>res=func7(glb)
+11
+>>>glb #В этом случае значение переменной меняется, так как внутри функции обьявляется именно глобальная переменная glb.
+8
+>>>res #Однако в виде arg мы передали именно значение glb равное 11, поэтому как аргумент будет использоваться именно это значение, хоть сама переменная glb и была изменена. 
+165
+```
+
+## 6.2 Изучение нахождения локальных и глобальных обьектов
+
+Были выведены локальные и глобальные обьекты в глобальном пространстве видимости и также внутри функции.
+
+```py
+>>>globals().keys() #На глобальном уровне локальная и глобальная области видимости совпадают.
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+>>>locals().keys() #В данном случае отличий не будет, так как локализация обьектов запрашивается в глобальной области видимости.
+>>>def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+	return loc1*arg
+
+    
+>>>hh=func8(glb) #В этом случае глобальные обьекты остались те же, место локализации - функция, в ней существуют три локальных обьекта.
+>>>hh
+165
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+'glb' in globals().keys()
+True
+```
+
+## 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 #75
+	loc1=5
+	glb=func9_1(loc1)
+	print('loc_func9:',locals().keys())
+	print('glob_func9:',globals().keys())
+	return arg2+arg3*glb #85
+
+    
+>>>kk=func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', '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__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+
+## 6.4 Изучение моделирования системы управления
+
+Была смоделирована система управления, состоящая из реального двигателя, тахогенератора и зоны нечувствительности (их модели представляются пользовательскими функциями). На вход системы подается синусоидальный сигнал, который проходит через отрицательную обратную связь. Модель реального двигателя и тахогенератора представлены интеграторами и усилителями, а зона нечувствительности ограничивает значения выходного сигнала. В результате работы программы вычисляется и выводится список значений, представляющих выходной сигнал системы.
+
+```py
+>>>znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=0.5,35,0.6,5,1000,5,15
+>>>k1=float(znach[0])
+>>>T=float(znach[1])
+>>>k2=float(znach[2])
+>>>Xm=float(znach[3])
+>>>A=float(znach[4])
+>>>F=float(znach[5])
+>>>N=float(znach[6])
+>>>import math
+>>>vhod=[]
+>>>for i in range(N):
+    vhod.append(A*math.sin((2*i*math.pi)/F))
+>>>vhod
+[0.0, 951.0565162951535, 587.7852522924733, -587.785252292473, -951.0565162951536, -2.4492935982947065e-13, 951.0565162951535, 587.7852522924734, -587.7852522924728, -951.0565162951538, -4.898587196589413e-13, 951.0565162951528, 587.7852522924736, -587.7852522924726, -951.0565162951538]
+>>>def realdvig(xtt,kk1,TT,yti1,ytin1):
+    #Модель реального двигателя
+    yp=kk1*xtt  #усилитель
+    yti1=yp+yti1  #Интегратор
+    ytin1=(yti1+TT*ytin1)/(TT+1)
+    return [yti1,ytin1]
+
+>>>def tahogen(xtt,kk2,yti2):
+    #Модель тахогенератора
+    yp=kk2*xtt   #усилитель
+    yti2=yp+yti2 #интегратор
+    return yti2
+
+>>>def nechus(xtt,gran):
+    #зона нечувствительности
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt
+
+>>>yi1=0;yin1=0;yi2=0
+>>>vyhod=[]
+>>>for xt in vhod:
+    xt1=xt-yi2   #отрицательная обратная связь
+    [yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1)
+    yi2=tahogen(yin1,k2,yi2)
+    yt=nechus(yin1,Xm) #Если скорость yin1 = 0.3 → выход yt = 0 (слишком мало)
+    vyhod.append(yt)
+
+    
+>>>print('y=',vyhod)
+y= [0, 8.209118281877132, 29.104924685415277, 40.86232427117668, 38.3075414151359, 34.68635884409398, 42.90679739719954, 57.19526562043458, 60.53754513466764, 47.64611630565597, 31.742316122264157, 25.812753880749888, 24.278160244795345, 10.44509996519298, -10.518946273258612]
+```
+
+
+## 7 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.

TEMA7/signal_belogo_shuma.txt

@@ -0,0 +1,4 @@
+5.918285660014072,9.853825872834358,4.914306865322827
+3.0855612967600674,6.9542382200414385,2.0434201644665984
+3.5800023965008387,9.325616310281028,8.954675432931069
+1.1625623856949419,5.6526777248438265,2.7489262769221523

TEMA7/task.md

@@ -0,0 +1,89 @@
+# Общее контрольное задание по теме 7
+
+Анисенков Павел, А-01-23
+
+## Задание
+
+Общее контрольное задание.
+    • Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+    • Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+    • Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+
+## Решение
+
+```py
+
+def signal_zaderzka(vhod_spisok, zaderzka):
+    """
+    Возвращает сигнал, где каждое значение - это значение входного сигнала
+    zaderzka тактов назад (0 для первых zaderzka тактов)
+    """
+    vihod = []
+    istoriya = []  # Отдельный список для истории
+
+    for el in vhod_spisok:
+        istoriya.append(el)  # Добавляем текущее значение в историю
+        
+        if len(istoriya) <= zaderzka:
+            # Еще не накопили достаточно истории
+            vihod.append(0)
+        else:
+            # Берем значение, которое было zaderzka тактов назад
+            el_zad = istoriya[len(istoriya) - zaderzka - 1]
+            vihod.append(el_zad)
+    
+    return vihod
+zaderzka = 3
+vhod = [1, 2, 3, 4, 5]
+vihod = signal_zaderzka(vhod, zaderzka)  
+print("входной сигнал: ", vhod, "выходной сигнал: ", vihod)
+входной сигнал:  [1, 2, 3, 4, 5] выходной сигнал:  [0, 0, 0, 1, 2]
+```
+
+```py
+def histogram(data, num_bins):
+    """Вычисляет и выводит гистограмму в виде таблицы, возвращает bins и counts."""
+    min_val, max_val = min(data), max(data)
+    bin_width = (max_val - min_val) / num_bins
+    bins = [min_val + i * bin_width for i in range(num_bins + 1)] #список границ интервалов min=0, max=10, num_bins=5 → bins=[0, 2, 4, 6, 8, 10]
+    counts = []
+    for i in range(num_bins):
+        count = 0
+        for x in data:
+            if bins[i] <= x < bins[i+1] or (x == max_val and i == num_bins - 1):
+                count += 1
+        counts.append(count)
+
+    print("Гистограмма:")
+    for i in range(num_bins):
+        print(f"Интервал: [{bins[i]:.2f}, {bins[i+1]:.2f}], Элементов: {int(counts[i])}")
+
+    return bins, counts
+
+import random
+data = [random.gauss(0, 1) for _ in range(1000)]
+num_bins = 10
+bins, counts = histogram(data, num_bins)
+Гистограмма:
+Интервал: [-3.07, -2.46], Элементов: 11
+Интервал: [-2.46, -1.85], Элементов: 33
+Интервал: [-1.85, -1.24], Элементов: 64
+Интервал: [-1.24, -0.64], Элементов: 160
+Интервал: [-0.64, -0.03], Элементов: 207
+Интервал: [-0.03, 0.58], Элементов: 246
+Интервал: [0.58, 1.19], Элементов: 168
+Интервал: [1.19, 1.80], Элементов: 75
+Интервал: [1.80, 2.41], Элементов: 26
+Интервал: [2.41, 3.02], Элементов: 10
+```
+
+```py
+>>>anon = lambda b1, b2, X: b1+b2*X
+>>>Y = anon(1,2,3)
+>>>Y
+7
+```
+
+

TEMA7/test.md

@@ -0,0 +1,62 @@
+# Индивидуальное контрольное задание по теме 7
+
+Анисенков Павел, А-01-23
+
+## Задание
+3.Разработайте функцию с 4 аргументами, создающую последовательность отсчетов случайно-го, равномерно распределенного сигнала типа белого шума с заданными параметрами: грани-цы диапазона изменения,  число отсчетов (аргументы функции). Сигнал должен быть записан построчно, по 3 элемента в строке с разделителем - запятая в текстовый файл с заданным именем (4-й аргумент функции), а также возвращен в вызывающую программу в виде списка.
+
+
+## Решение
+
+```py
+import random
+import math 
+import os
+
+def bely_shum(niz_gr, verh_gr, kol_otschetov, moifail):
+    """
+    Создает последовательность отсчетов случайного, равномерно 
+    распределенного сигнала типа белого шума с заданными параметрами
+    
+    Аргументы:
+    niz_gr - нижняя граница диапазона
+    verh_gr - верхняя граница диапазона
+    kol_otschetov - число отсчетов
+    moifail - имя файла для записи
+    
+    Возвращает:
+    Список сгенерированных значений
+    
+    """
+    signal = []
+    for i in range(kol_otschetov):
+        sluch = niz_gr + (verh_gr - niz_gr) * random.random()
+        signal.append(sluch)
+    
+    fail = open(moifail, 'w')
+    
+    i = 0
+    while i < len(signal):
+        str_el = signal[i:i+3]
+        zapis = ','.join(str(chislo) for chislo in str_el)
+        fail.write(zapis + '\n')
+        i += 3
+    fail.close()
+    return signal
+
+    os.chdir(r'C:\Users\Professional\Desktop\python-labs\TEMA7')
+    
+    nizhnyaya = 0.0 
+    verhnyaya = 10.0
+    kolichestvo = 12     
+    moifail = "signal_belogo_shuma.txt"  
+
+    res = bely_shum(nizhnyaya, verhnyaya, kolichestvo, moifail)
+    
+    print("Сгенерированный сигнал:")
+    print(res)
+    print(f"Данные записаны в файл: {moifail}")
+    
+```
+
+

TEMA8/M1.py

@@ -0,0 +1,9 @@
+import random
+import math
+def logistic_tuple(N):
+
+    logistic = lambda X: 1.0 / (1.0 + math.exp(X)) # Анонимная функция — логистическая
+    random_list = [random.uniform(-20, 68) for _ in range(N)] #список из N случайных чисел в диапазоне [-20, 68]
+    
+    result_tuple = tuple(logistic(x) for x in random_list)
+    return result_tuple

TEMA8/M2.py

@@ -0,0 +1,8 @@
+from M1 import logistic_tuple
+N = int(input("Введите число элементов: "))
+result = logistic_tuple(N)
+print("\nРезультат:")
+print(result)
+if len(result) > 5:
+    print("\nПервые 5 значений:")
+    print(result[:5])

TEMA8/MM0.py

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

TEMA8/MM1.py

@@ -0,0 +1,22 @@
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+    #Модель реального двигателя
+    yp=kk1*xtt  #усилитель
+    yti1=yp+yti1  #Интегратор
+    ytin1=(yti1+TT*ytin1)/(TT+1)
+    return [yti1,ytin1]
+
+def tahogen(xtt,kk2,yti2):
+    #Модель тахогенератора
+    yp=kk2*xtt   #усилитель
+    yti2=yp+yti2 #интегратор
+    return yti2
+
+def nechus(xtt,gran):
+    #зона нечувствит
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt

TEMA8/MM2.py

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

TEMA8/Mod0.py

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

TEMA8/Mod11.py

@@ -0,0 +1,8 @@
+def read_number_list(filename):
+    number_list = []
+    with open(filename, 'r') as file:
+        for line in file:
+            numbers = line.strip().split()
+            for num in numbers:
+                number_list.append(float(num))
+    return number_list 

TEMA8/Mod13.py

@@ -0,0 +1,28 @@
+# noise_gen.py
+# Тема 8. Генератор равномерного белого шума
+
+import random
+
+def generate_uniform_noise(min_val, max_val, num_samples, filename):
+    """
+    Генерирует последовательность равномерно распределённого белого шума.
+    
+    Аргументы:
+        min_val (float): нижняя граница диапазона
+        max_val (float): верхняя граница диапазона
+        num_samples (int): количество отсчётов
+        filename (str): имя текстового файла для записи
+    
+    Возвращает:
+        list: список сгенерированных чисел
+    """
+    # Генерация списка
+    noise = [random.uniform(min_val, max_val) for _ in range(num_samples)]
+    
+    # Запись в файл: по 3 элемента в строке, через запятую
+    with open(filename, 'w', encoding='utf-8') as f:
+        for i in range(0, len(noise), 3):
+            line = noise[i:i+3]
+            f.write(','.join(f"{x:.6f}" for x in line) + '\n')
+    
+    return noise

TEMA8/Mod2(3).py

@@ -0,0 +1,39 @@
+# test_noise.py
+# Тема 8. Тестирование генератора шума
+
+from Mod13 import generate_uniform_noise
+
+def main():
+    print("Генерация равномерного белого шума")
+    
+    # Ввод исходных данных
+    try:
+        min_val = float(input("Введите нижнюю границу диапазона (min_val): "))
+        max_val = float(input("Введите верхнюю границу диапазона (max_val): "))
+        if min_val >= max_val:
+            print("Ошибка: min_val должно быть меньше max_val")
+            return
+        
+        num_samples = int(input("Введите число отсчётов (num_samples): "))
+        if num_samples <= 0:
+            print("Ошибка: число отсчётов должно быть положительным")
+            return
+        
+        filename = input("Введите имя файла для записи (например, noise.txt): ").strip()
+        if not filename:
+            filename = "noise.txt"
+    
+    except ValueError:
+        print("Ошибка: введены некорректные данные")
+        return
+
+    # Вызов функции
+    noise_list = generate_uniform_noise(min_val, max_val, num_samples, filename)
+    
+    # Отображение результатов
+    print(f"\nСгенерировано {len(noise_list)} отсчётов.")
+    print(f"Первые 10 значений: {[round(x, 4) for x in noise_list[:10]]}")
+    print(f"Результат записан в файл: {filename}")
+
+if __name__ == "__main__":
+    main()

TEMA8/Mod2.py

@@ -1,11 +1,13 @@
+
 def alpha():
     print('****ALPHA****')
-    t=input('Значение t=')
+    t = input('Значение t=')
-    return t
+    return t  # возвращает строку
 
 def beta(q):
     print('****BETA****')
     import math
-    expi=q*math.pi
+    expi = q * math.pi
-    return math.exp(expi)
+    result = math.exp(expi)
-    
+    # Возвращаем не только результат, но и expi (если нужно)
+    return result, expi  # возвращаем кортеж

TEMA8/Mod22.py

@@ -0,0 +1,22 @@
+import math
+
+def calculate_correlation(list1, list2):
+    if not list1 or not list2:
+        print("Ошибка: Один или оба списка пусты.")
+        return None
+
+    n = min(len(list1), len(list2))  # Используем меньшую длину
+    sum_x = sum(list1[:n])
+    sum_y = sum(list2[:n])
+    sum_x_squared = sum(x**2 for x in list1[:n])
+    sum_y_squared = sum(y**2 for y in list2[:n])
+    sum_xy = sum(list1[i] * list2[i] for i in range(n))
+
+    numerator = n * sum_xy - sum_x * sum_y
+    denominator = math.sqrt((n * sum_x_squared - sum_x**2) * (n * sum_y_squared - sum_y**2))
+
+    if denominator == 0:
+        print("Предупреждение: Деление на ноль при вычислении корреляции.")
+        return None
+
+    return numerator / denominator

TEMA8/Mod23.py

@@ -0,0 +1,39 @@
+# test_noise.py
+# Тема 8. Тестирование генератора шума
+
+from Mod1(3) import generate_uniform_noise
+
+def main():
+    print("Генерация равномерного белого шума")
+    
+    # Ввод исходных данных
+    try:
+        min_val = float(input("Введите нижнюю границу диапазона (min_val): "))
+        max_val = float(input("Введите верхнюю границу диапазона (max_val): "))
+        if min_val >= max_val:
+            print("Ошибка: min_val должно быть меньше max_val")
+            return
+        
+        num_samples = int(input("Введите число отсчётов (num_samples): "))
+        if num_samples <= 0:
+            print("Ошибка: число отсчётов должно быть положительным")
+            return
+        
+        filename = input("Введите имя файла для записи (например, noise.txt): ").strip()
+        if not filename:
+            filename = "noise.txt"
+    
+    except ValueError:
+        print("Ошибка: введены некорректные данные")
+        return
+
+    # Вызов функции
+    noise_list = generate_uniform_noise(min_val, max_val, num_samples, filename)
+    
+    # Отображение результатов
+    print(f"\nСгенерировано {len(noise_list)} отсчётов.")
+    print(f"Первые 10 значений: {[round(x, 4) for x in noise_list[:10]]}")
+    print(f"Результат записан в файл: {filename}")
+
+if __name__ == "__main__":
+    main()

TEMA8/Mod33.py

@@ -0,0 +1,14 @@
+import Mod11
+import Mod22
+
+if __name__ == "__main__":
+    file1_name = input("Введите имя первого файла: ")
+    file2_name = input("Введите имя второго файла: ")
+
+    list1 = Mod11.read_number_list(file1_name)
+    list2 = Mod11.read_number_list(file2_name)
+
+    if list1 is not None and list2 is not None:
+        correlation = Mod22.calculate_correlation(list1, list2)
+        if correlation is not None:
+            print(f"Коэффициент корреляции: {correlation:.3f}")

TEMA8/data1.txt

@@ -0,0 +1,3 @@
+1.0 2.5 3.3
+4.1 5
+6.7

TEMA8/data2.txt

@@ -0,0 +1,3 @@
+2.1 3.0
+4.2 5.5 6.1
+7.8

TEMA8/noise.txt

@@ -0,0 +1,4 @@
+-2.010928,1.714263,1.137040
+1.024900,0.097800,1.820752
+-1.874113,-0.357603,-4.461175
+-0.753859

TEMA8/report.md

@@ -0,0 +1,329 @@
+# Отчет по лабораторной работе 8
+
+Анисенков Павел, А-01-23
+
+## 1 Открытие и настройка интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE, указан рабочий каталог и импортированы необходимые модули.
+
+```py
+>>>import os
+>>>os.chdir('C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8')
+>>>os.getcwd()  #Контролируем корректность установки текущего каталога
+'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8'
+>>>import importlib
+>>>import sys
+```
+## 2 Создание и использование модулей в среде Python.
+
+## 2.1 Запуск модуля на выполнение
+
+Был запущен созданный модуль на выполнение, введенное на запрос число было сохранено в переменную perm1, созданную в модуле. Были просмотрены атрибуты и тип модуля. Была неудачно произведена попытка заново запустить модуль на выполнение..."Выполняется весь код в этом файле один раз. Сохраняется модуль в специальный кэш — словарь sys.modules. Любой последующий вызов import Mod1 не перезапускает код модуля — Python просто возвращает уже загруженный объект модуля из sys.modules." После этого модуль был запущен еще раз с помощью метода reload. Была просмотрена переменная perm1 и установлено, что данная переменная была переопределена.
+
+```py
+>>>import Mod1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>>>type(Mod1)
+<class 'module'>
+>>>dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+>>>Mod1.perm1
+'5'
+>>>import Mod1
+>>>importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+>>>Mod1.perm1
+'3'
+```
+
+## 2.2 Изучение удаления модуля из словаря
+
+Был выведен словарь - значение атрибута sys.modules, среди которых был модуль Mod1. Далее этот модуль был удален, и снова изображен словарь, в котором Mod1 отсутствовал. Потом модуль был снова запущен и снова удален из словаря.
+
+```py
+>>>print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_distutils_hack', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'encodings.utf_8_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>>sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Professional\\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', '_distutils_hack', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'encodings.utf_8_sig', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>>import Mod1
+Mod1:Введите значение = 2
+Mod1:Значение perm1= 2
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+```
+
+## 2.3 Изучение запуска модуля с помощью exec
+
+Модуль был запущен на выполнение с помощью функции exec, которая читает код. Далее трижды было введено значение perm1, и выведено на экран.
+
+```py
+>>>exec(open('Mod1.py').read()) #не указана кодировка encoding='utf-8'
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>>>exec(open('Mod1.py').read())
+Mod1:Введите значение = 4
+Mod1:Значение perm1= 4 #объект-модуль при этом не создается
+>>>exec(open('Mod1.py').read())
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+```
+
+## 2.4 Изучение запуска модуля с помощью from … import …
+
+Была импортирована лишь часть обьектов модуля, просмотрены обьекты, а так же выведено значение переменной perm1.
+
+```py
+>>>from Mod1 import perm1
+Mod1:Введите значение = 6 #выполняется потому что до этого мы его удалили из словаря
+Mod1:Значение perm1= 6
+>>>dir()
+['Mod1', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'fg', 'imp', 'importlib', 'os', 'perm1', 'summa', 'sys']
+>>>perm1
+'6'
+```
+
+Пример:
+```py
+>>>from Mod2 import beta
+>>>g=beta(2)
+>>>****BETA****
+>>>g
+535.4916555247646
+>>>dir()
+['Mod1', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']# была создана ссылка на функцию beta, не создаёт переменную с именем Mod2 в текущем пространстве имён из-за from..
+>>>alpha()
+Traceback (most recent call last):
+  File "<pyshell#29>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+>>>from Mod2 import alpha as al
+>>>al()
+****ALPHA****
+Значение t=4
+'4'
+>>>del al,beta #удаляет ссылку на обьект но не обьект
+>>>from Mod2 import alpha as al, beta as bt
+>>>del al #модуль остаётся загруженным, и его можно импортировать снова
+>>>del bt
+>>>from Mod2 import * #Звездочка означает, что импортируется весь модуль, а не конкретные функции.
+tt=alpha()  #На запрос введите значение 0.12
+****ALPHA****
+Значение t=0.12
+>>>uu=beta(float(tt))
+>>>uu
+1.4578913609506803 #math.exp(q*math.pi)
+```
+
+## 3 Создание многомодульных программ.
+
+## 3.1 Пример:
+
+Был создан еще один модуль Mod0, в котором вызываются модуль 1 и функции из модуля 2. Также выведены значения обьектов, созданных во время выполнения программы.
+
+```py
+>>>sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+>>>sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+>>>import Mod0
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+perm1= 1
+****ALPHA****
+Значение t=2
+tt= 2
+****BETA****
+qq= 535.4916555247646 #переменные (tt, qq) и модуль (Mod1) становятся атрибутами объекта модуля Mod0, потому что они были созданы внутри его кода
+Mod0.tt;Mod0.qq;Mod0.Mod1.perm1 #Mod0 содержит ссылку на Mod1 в котором есть perm1(локальная переменная)
+'2'
+535.4916555247646
+'1'
+```
+
+## 3.2 Создание модулей для реализации программы моделирования системы управления
+
+Были созданы модули MM1 - с функциями реализующими реальный двигатель, тахогенератор и нелинейное звено; MM2 - с инструкциями, обеспечивающими ввод параметров задачи, формирование входного сигнала, импорт модуля ММ1 и реализацию модели при расчете выходного сигнала; MM0 - содержащую импорт модуля MM2 и печатающую получившийся выходной сигнал. Был вызван модуль MM0.
+
+```py
+>>>import MM0
+k1,T,k2,Xm,A,F,N=0.5,35,0.6,5,1000,5,15
+y= [0, 8.209118281877132, 29.104924685415277, 40.86232427117668, 38.3075414151359, 34.68635884409398, 42.90679739719954, 57.19526562043458, 60.53754513466764, 47.64611630565597, 31.742316122264157, 25.812753880749888, 24.278160244795345, 10.44509996519298, -10.518946273258612]
+```
+
+## 3.3 Изучение области действия обьектов в модулях
+
+Была изучена область действия обьектов в модулях. Исходя из примеров, приведенных ниже, можно сказать, что обьекты входящие в один модуль будут локализованы в этом модуле и доступны в нем. К переменным из другого модуля, даже импортированного в главный (выполняемый) модуль, прямого доступа не будет.
+
+## 3.3.1 Изучение области действия обьектов в модулях (пример 1)
+
+Внутрь модуля Mod2 в функцию alpha был добавлен вызов функции beta.
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    n = beta(6)
+    print(n)
+    return t
+
+def beta(q):
+    print('****BETA****')
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+Далее запущен модуль и вызвана функция alpha. Можно заметить, что инструкции успешно выполнились.
+
+```py
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+>>>import Mod2
+>>>alpha()
+****ALPHA****
+Значение t=9
+153552935.39544657
+'9'
+```
+Далее в модуле в функции beta был добавлен вызов функции alpha.
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    alpha()
+    return math.exp(expi)
+```
+
+Функция beta была успешно вызвана
+
+```py
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+>>>import Mod2
+>>>beta(6)
+****ALPHA****
+Значение t=9
+153552935.39544657
+```
+
+## 3.3.2 Изучение области действия обьектов в модулях (пример 2)
+
+В модуль Mod0 была добавлена функция печати переменных t и expi, которые есть в Mod2. Мod2 переделан в исходный вариант
+
+```py
+import Mod1
+print('perm1 =', Mod1.perm1)
+from Mod2 import alpha, beta
+t = alpha()
+print('tt =', t)
+t_num = float(t)
+qq, expi = beta(t_num) 
+print(t)
+print(expi)
+print(qq)
+```
+Итог:
+
+```py
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+sys.modules.pop('Mod0')
+<module 'Mod0' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod0.py'>
+import Mod0
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+perm1= 1
+****ALPHA****
+Значение t=0.12
+tt = 0.12
+****BETA****
+qq = 1.4578913609506803
+expi = 0.37699111843077515
+```
+
+## 3.3.3 Изучение области действия обьектов в модулях (пример 3)
+
+В модуле Mod0 были добавлены инструкции, где переменная perm1 была увеличена в 3 раза и напечатана
+
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+perm1 = Mod1.perm1*3
+print("perm1*3= ", perm1)
+```
+
+При запуске модуля напечаталась переменная perm1 умноженная на 3. Так как эта переменная класса строка, то строка была повторена трижды и сформирована новая строка.
+
+```py
+sys.modules.pop('Mod0')
+<module 'Mod0' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod0.py'>
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+import Mod0
+Mod1:Введите значение = 4
+Mod1:Значение perm1= 4
+perm1= 4
+****ALPHA****
+Значение t=3
+tt= 3
+****BETA****
+qq= (12391.647807916694, 9.42477796076938)
+perm1*3=  444
+```
+
+## 3.3.4 Изучение области действия обьектов в модулях (пример 4)
+
+В командной строке после выполнения главного модуля была произведена попытка изменить переменные perm1, tt, qq.
+
+```py
+sys.modules.pop('Mod0')
+<module 'Mod0' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod0.py'>
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Professional\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+import Mod0
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+****ALPHA****
+Значение t=4
+tt= 4
+****BETA****
+qq= (286751.31313665316, 12.566370614359172)
+perm1*3=  333
+Mod0.Mod1.perm1 = str(2 * float(Mod0.Mod1.perm1))
+Mod0.tt = str(2 * float(Mod0.tt))
+Mod0.qq = 2 * Mod0.qq
+Mod0.Mod1.perm1
+'6.0'
+Mod0.tt
+'8.0'
+Mod0.qq
+(286751.31313665316, 12.566370614359172, 286751.31313665316, 12.566370614359172)
+```
+
+## 4 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.

TEMA8/task.md

@@ -0,0 +1,77 @@
+# Общее контрольное задание по теме 8
+
+Анисенков Павел, А-01-23
+
+## Задание
+
+Разработайте программу, состоящую из трех модулей:
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+## Решение
+```py
+Mod11
+def read_number_list(filename):
+    number_list = []
+    with open(filename, 'r') as file:
+        for line in file:
+            numbers = line.strip().split()
+            for num in numbers:
+                number_list.append(float(num))
+    return number_list 
+```
+
+```py
+Mod22
+import math
+def calculate_correlation(list1, list2):
+    if not list1 or not list2:
+        print("Ошибка: Один или оба списка пусты.")
+        return None
+
+    n = min(len(list1), len(list2))  # Используем меньшую длину
+    sum_x = sum(list1[:n])
+    sum_y = sum(list2[:n])
+    sum_x_squared = sum(x**2 for x in list1[:n])
+    sum_y_squared = sum(y**2 for y in list2[:n])
+    sum_xy = sum(list1[i] * list2[i] for i in range(n))
+
+    numerator = n * sum_xy - sum_x * sum_y
+    denominator = math.sqrt((n * sum_x_squared - sum_x**2) * (n * sum_y_squared - sum_y**2))
+
+    if denominator == 0:
+        print("Предупреждение: Деление на ноль при вычислении корреляции.")
+        return None
+
+    return numerator / denominator
+```
+
+```py
+Mod33
+import Mod11
+import Mod22
+
+if __name__ == "__main__":
+    file1_name = input("Введите имя первого файла: ")
+    file2_name = input("Введите имя второго файла: ")
+
+    list1 = Mod11.read_number_list(file1_name)
+    list2 = Mod11.read_number_list(file2_name)
+
+    if list1 is not None and list2 is not None:
+        correlation = Mod22.calculate_correlation(list1, list2)
+        if correlation is not None:
+            print(f"Коэффициент корреляции: {correlation:.3f}")
+```
+
+
+
+```py
+= RESTART: C:\Users\Professional\Desktop\python-labs\TEMA8\Mod33.py
+Введите имя первого файла: data1.txt
+Введите имя второго файла: data2.txt
+Коэффициент корреляции: 0.991
+
+```

TEMA8/test.md

@@ -0,0 +1,43 @@
+# Индивидуальное контрольное задание по теме 8 вариант 20
+
+Анисенков Павел, А-01-23
+
+## Задание
+
+Разработайте функцию с одним аргументом – числом элементов. Функция должна включать анонимную функцию с аргументом Х, вычисляющую от заданного входного числового аргу-мента X значение логистической функции: 1/(1+exp(X)). Общая функция должна создавать список с заданным в аргументе числом случайных элементов, равномерно распределенных в диапазоне от -20 до +68. После этого она должна формировать кортеж с элементами – значе-ниями логистической функции от соответствующих элементов списка. Этот кортеж должен возвращаться, как результат функции. Проверить функцию на примере.
+
+## Решение
+```py
+
+M1
+import random
+import math
+def logistic_tuple(N):
+
+    logistic = lambda X: 1.0 / (1.0 + math.exp(X)) 
+    random_list = [random.uniform(-20, 68) for _ in range(N)] 
+    
+    result_tuple = tuple(logistic(x) for x in random_list)
+    return result_tuple
+
+M2
+from M1 import logistic_tuple
+N = int(input("Введите число элементов: "))
+result = logistic_tuple(N)
+print("\nРезультат:")
+print(result)
+if len(result) > 5:
+    print("\nПервые 5 значений:")
+    print(result[:5])
+```
+
+Вывод:
+
+
+```py
+Введите число элементов: 5
+
+Результат:
+(1.7003103585087036e-25, 8.372020498532923e-12, 0.013308504481261372, 5.733447989484467e-14, 2.048829680249727e-09)
+
+```

TEMA9/M0.py

@@ -0,0 +1,19 @@
+# M0.pyimport sys
+import os
+import M2
+
+output_lines = []
+output_lines.append("Результаты анализа данных о запасах угля")
+
+for country, value in zip(M2.result_countries, M2.result_per_capita):
+    line = f"{country}: {value:.6f} трлн т/млн чел"
+    output_lines.append(line)
+    
+output_lines.append(f"\nОбщее отношение ресурсов к населению: {M2.result_overall:.6f}")
+
+f = open("Res3030.txt", "w", encoding="utf-8")
+for line in output_lines:
+    f.write(line + "\n")
+f.close()
+
+print("\nРезультаты записаны в файл Res3030.txt")

TEMA9/M1.py

@@ -0,0 +1,42 @@
+import pylab
+def func1(data_dict):
+    """
+    Аргумент: словарь {страна: [население, ресурс]}
+    Возвращает:
+        - список стран,
+        - список ресурс/душу,
+        - общее отношение суммарных ресурсов к суммарному населению
+    """
+    countries = []
+    per_capita = []
+    total_pop = 0.0
+    total_res = 0.0
+
+    for country, values in data_dict.items():
+        pop = values[0]
+        res = values[1]
+        countries.append(country)
+        per_capita.append(res / pop if pop != 0 else 0)
+        total_pop += pop
+        total_res += res
+
+    overall_ratio = total_res / total_pop if total_pop != 0 else 0
+    return countries, per_capita, overall_ratio
+
+
+def func2(data_dict):
+    """
+    столбиковая диаграмма распределения ресурсов по странам.
+    """
+    countries = list(data_dict.keys())
+    resources = []
+    for country in countries:
+        resources.append(data_dict[country][1])
+
+    pylab.figure(figsize=(10, 5))
+    pylab.bar(countries, resources, color='blue')
+    pylab.title("Распределение угля по странам (трлн т)")
+    pylab.xlabel("Страны")
+    pylab.ylabel("Запасы угля")
+    pylab.tight_layout()
+    pylab.show()

TEMA9/M2.py

@@ -0,0 +1,25 @@
+# M2.py
+import os
+import pickle
+from M1 import func1, func2
+
+filename = input("Введите имя файла с данными: ").strip()
+
+f = open(filename, "rb")
+data = pickle.load(f)
+f.close()
+
+countries, per_capita, overall_ratio = func1(data)
+
+print("\nСтраны и ресурс на душу населения:")
+for i in range(len(countries)):
+    print(f"{countries[i]}: {per_capita[i]:.6f} трлн т/млн чел")
+
+print(f"\nОбщее отношение суммарных ресурсов к суммарному населению: {overall_ratio:.6f}")
+
+func2(data)
+
+result_countries = countries
+result_per_capita = per_capita
+result_overall = overall_ratio
+result_data = data

TEMA9/Mod3.py

@@ -0,0 +1,11 @@
+class Class1: #Объявление класса Class1 в модуле
+    def zad_zn(self,znach): # 1 Метод класса
+        self.data=znach # self - ссылка на экземпляр класса Class1
+    def otobrazh(self): # 2 Метод класса
+        print(self.data)#Отображение данных экземпляра
+
+class Class2(Class1): #Class2 - наследник класса Class1
+    def otobrazh(self): # Метод класса Class2
+        print('значение=',self.data)#Отображение данных экземпляра
+    def otobrazh(objekt): #Объявление самостоятельной функции
+        print('значение объекта=',objekt)

TEMA9/Res3030.txt

@@ -0,0 +1,9 @@
+Результаты анализа данных о запасах угля
+США: 0.076821 трлн т/млн чел
+Россия: 0.103425 трлн т/млн чел
+Австралия: 0.500000 трлн т/млн чел
+Китай: 0.009217 трлн т/млн чел
+Индия: 0.007279 трлн т/млн чел
+Германия: 0.039759 трлн т/млн чел
+
+Общее отношение ресурсов к населению: 0.023178

TEMA9/SAU.py

@@ -0,0 +1,21 @@
+class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+    
+    def model(self):
+        def inerz(x,T,yy):
+            return (x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 2
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
+        y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])

TEMA9/create_data.py

@@ -0,0 +1,15 @@
+import pickle
+
+data = {
+    "США": [302, 23.2],
+    "Россия": [146, 15.1],
+    "Австралия": [28, 14.0],
+    "Китай": [1443, 13.3],
+    "Индия": [1415, 10.3],
+    "Германия": [83, 3.3]
+}
+
+f = open("ugol.dat", "wb")
+pickle.dump(data, f)
+f.close()
+print("Бинарный файл ugol.dat создан.")

TEMA9/data1.txt

@@ -0,0 +1,4 @@
+1.2 3.5
+-2.1 4.8 5.0
+2.3 1.1 6.7 0.0 3.3
+7.2 -1.5