картинка к икз 3

TEMA1/Pr0.py

@@ -0,0 +1,6 @@
+#Программа по Теме 1 Кузьменко Елена Алексеевна
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r"C:\Users\u522-15\Desktop\python-labs\TEMA1")
+os.getcwd()

TEMA1/Pr100.py

@@ -0,0 +1,33 @@
+# Протокол по Теме 1 Кузьменко Елена Алексеевна
+
+Python 3.11.5 (tags/v3.11.5:cce6ba9, Aug 24 2023, 14:38:34) [MSC v.1936 64 bit (AMD64)] on win32
+Type "help", "copyright", "credits" or "license()" for more information.
+import os
+os.chdir('C:\Users\u522-15\Desktop\python-labs\TEMA1')
+SyntaxError: incomplete input
+os.chdir(r"C:\Users\u522-15\Desktop\python-labs\TEMA1")
+
+
+
+os.chdir(r"C:\Users\u522-15\Desktop\python-labs\TEMA1")
+os.getcwd()
+'C:\\Users\\u522-15\\Desktop\\python-labs\\TEMA1'
+import os
+os.chdir(r"C:\Users\u522-15\Desktop\python-labs\TEMA1")
+os.getcwd()
+'C:\\Users\\u522-15\\Desktop\\python-labs\\TEMA1'
+# test
+
+========== RESTART: C:/Users/u522-15/Desktop/python-labs/TEMA1/p 10.py =========
+Hello
+Your name=Lena
+import Pr0
+Hello
+Your name=Lena
+
+========== RESTART: C:/Users/u522-15/Desktop/python-labs/TEMA1/Pr0.py ==========
+Hello
+Your name=Lena
+import prb1
+Как Вас зовут? Лена
+Привет, Лена

TEMA1/p 10.py

@@ -0,0 +1,6 @@
+#Программа по Теме 1 Кузьменко Елена Алексеевна
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r"C:\Users\u522-15\Desktop\python-labs\TEMA1")
+os.getcwd()

TEMA1/report.md

@@ -0,0 +1,239 @@
+# Отчёт по Теме 1
+
+Кузьменко Елена, А-02-23
+
+## 1 пункт
+
+С сервера git склонировали папку "python-labs", в которой находится папка TEMA1 для дальнейшей работы
+
+![](p1.png)
+
+## 2 пункт
+
+Открыта для выполнения ЛР1 программа-интерпетатор.
+
+![](p2.png)
+
+## 3 пункт 
+
+В диалогов окне введём инструкцию print('Hello'). Получим соответствующей текст:
+
+```py
+>>> print('Hello')
+Hello
+```
+
+## 4 пункт
+
+Воспользуемся ещё одной командой-инструкцией. После введения команды на следующей строчке можно написать имя.
+
+```py
+>>> h=input('Your name=')
+Your name=Lena
+```
+
+## 5 пункт
+
+С помощью следующей команды завершим работу в консоли:
+
+```py 
+exit()
+```
+
+После введённой команды можно заметить, что диалоговое окно закрылось.
+
+## 6 пункт 
+
+Работу с интерактивной графической оболочкой IDLE. Запустим:
+
+![](p3.png)
+
+## 7-8 пункты
+
+Было изучено главное командное окно среды.
+
+Следующей инструкцией зададим рабочий каталог:
+
+```py
+>>>import os
+>>>os.chdir(r"C:\Users\u522-15\Desktop\python-labs\TEMA1")
+>>>os.getcwd()
+'C:\\Users\\u522-15\\Desktop\\python-labs\\TEMA1'
+```
+
+## 9 пункт
+
+С помощью настройки диалового окна поменяем оформление, а именно шрифт, размер окна и "цвет комментария"
+
+![](p9.png)
+
+![](p92.png)
+
+![](p93.png)
+
+После применения изменений в командной строке можно заметить изменения:
+
+![](p94.png)
+
+## 10 пункт 
+
+Откроем окно текстового редактора: 
+
+![](p10.png)
+
+Тут же попробуем записать те же команды, которые мы упоминали в предыдущих пунктах:
+
+![](p101.png)
+
+Чтобы активировать выполнения нашего кода, необходимо прибегнуть к одному из способов:
+1)Кнопка Run Modelu
+2)Та же кнопка, но по горячей клавише F5
+
+Это позволит за один запуск применить сразу все команды. Выполнение представлено в консоли:
+
+```py 
+========== RESTART: C:/Users/u522-15/Desktop/python-labs/TEMA1/p 10.py =========
+Hello
+Your name=Lena
+```
+
+Можно также воспользоваться и другим способом. Для этого впишем название файла с нашим сохранённым кодом:
+
+```py
+>>>import Pr0
+Hello
+Your name=Lena
+```
+
+## 11 пункт
+
+С помощью команды import из текущего каталога откроем файл prb1.py
+
+```py
+>>>import prb1
+Как Вас зовут? Лена
+Привет, Лена
+```
+Код представлял собой вопрос "Как Вас зовут?"
+
+В данном примере было изучено применения предыдущих команд путём их редактиварония
+
+## 12 пункт
+
+Попробуем в диалоговом окне открыть файл иного расширения, который представляет из себя результат работы компилятора.
+
+![](p12.png)
+
+Хаотичный набор символов, представленный на картинке, можно сочесть за ошибку, так как редактор открывает файл и ожидает текст, однако файл формата .pyc содержит двоичные данные(представляет из себя байт код), то есть каждый байт, который пытается прочитать машина превращаются в случайные символы.
+Из чего можно сделать вывод, что файл.pyc уже скомпилированный байт-код(легче и эффективнее интепретировать), а не текст, который должен прочитать редактор IDLE.
+
+
+## 13 пункт
+
+Все данные из командной строки были занесены в текстовый редактор. Файл используется как протокол.
+
+![](p13.png)
+
+## 14 пункт
+
+Изучение раздела помощи Help. Его вариации:
+
+1.В диалогово окне:
+
+![](p13.png)
+
+2.В командной строке введём инструкцию помощи по команде print:
+
+```py
+>>>help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+```
+
+В одной строке можно также ввести инструкции нескольких функций:
+
+```py
+>>>help(print); help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+```
+
+3)С помощью клавиши F1 можно перейти на следующий сайт:
+
+![](p141.png)
+
+Перейдя по ссылке Index перейдём в поисковик функций и найдём команду: print() (built-in function)
+
+![](p142.png)
+
+Здесь можно посмотреть справку:
+
+![](p143.png)
+
+В окне пункта 1) также можно открть сайт по кнопке Python Docs.
+
+## 15 пункт
+
+1.Открыли и прогнали файл prb1.py
+
+![](p15.png)
+
+2.По такому же принципу проверили файл Pr0.py
+
+![](p151.png)
+
+3.Запустим файл tdemo_chaos.py
+
+![](p152.png)
+
+Можно менять демонстрацию графического модуля, вот несколько вариантов:
+
+1)Clock
+
+![](p153.png)
+
+2)Tree
+
+![](p154.png)
+
+3)Peace
+
+![](p155.png)
+
+## 16 пункт
+
+Завершение работы со средой exit().
+

TEMA1/test.md

@@ -0,0 +1,20 @@
+## Общий контрольный вопрос по Теме 1
+
+Кузьменко Елена, А-02-23
+
+## Вопрос
+
+4)Можно ли писать несколько инструкций в одной строке командного окна?
+
+## Ответ
+
+Можно, в случае, если команды разделены точкой с запятой. В данной лабораторной работе был пример(п.14), когда необходимо было найти справку по функция print(), input().
+Был введён следующий код:
+
+```py
+>>>help(print); help(input)
+```
+
+Результат данной строчки вывел справку данных инструкций по порядку.
+
+## Итог: Можно, используя ";".

TEMA2/Pr0.py

@@ -0,0 +1,454 @@
+#Протокол по Теме 2 Кузьменко Е.А.
+
+#1
+>>> import os
+>>> os.chdir(r"C:\Users\Admin\Desktop\python-labs\TEMA2")
+>>> os.getcwd()
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA2'
+
+#2
+>>> f1=16; f2=3
+>>> f1,f2
+(16, 3)
+>>> f1;f2
+16
+3
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+>>> dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__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_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
+>>> type(f1)
+<class 'int'>
+>>> del f1
+>>> del f2
+>>> dir(f1)
+Traceback (most recent call last):
+  File "<pyshell#12>", line 1, in <module>
+    dir(f1)
+NameError: name 'f1' is not defined
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+
+#3
+>>> gg1=1.6; gg1
+1.6
+>>> hh1='Строка'; hh1
+'Строка'
+>>> 73sr=3; 73sr
+SyntaxError: invalid syntax
+>>> and=7; and
+SyntaxError: invalid syntax
+
+#4
+>>> import keyword
+>>> keyword.kwlist
+['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> key=keyword.kwlist
+>>> key
+['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> type(key)
+<class 'list'>
+
+#5
+>>> import builtins
+>>> dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', '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']
+>>> help(abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+
+>>> abs(13-40)
+27
+>>> help(len)
+Help on built-in function len in module builtins:
+
+len(obj, /)
+    Return the number of items in a container.
+
+>>> len("2932")
+4
+>>> len(key)
+36
+>>> help(max)
+Help on built-in function max in module builtins:
+
+max(...)
+    max(iterable, *[, default=obj, key=func]) -> value
+    max(arg1, arg2, *args, *[, key=func]) -> value
+    
+    With a single iterable argument, return its biggest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more arguments, return the largest argument.
+
+>>> max(0,19,20,-2,200,-1012,99,134)
+200
+>>> max("в", "з", "щ", "я")
+'я'
+>>> help(min)
+Help on built-in function min in module builtins:
+
+min(...)
+    min(iterable, *[, default=obj, key=func]) -> value
+    min(arg1, arg2, *args, *[, key=func]) -> value
+    
+    With a single iterable argument, return its smallest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more arguments, return the smallest argument.
+
+>>> min(0,19,20,-2,200,-1012,99,134)
+-1012
+>>> min("в", "з", "щ", "я")
+'в'
+>>> help(pow)
+Help on built-in function pow in module builtins:
+
+pow(base, exp, mod=None)
+    Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
+    
+    Some types, such as ints, are able to use a more efficient algorithm when
+    invoked using the three argument form.
+
+>>> pow(2,3)
+8
+>>> pow(2,3,3)
+2
+>>> pow(4,-3)
+0.015625
+>>> 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)
+123
+>>> round(123.456,1)
+123.5
+>>> round(123.456,-1)
+120.0
+>>> 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.
+
+>>> n=[-10,8,2,-3,5.5]
+>>> sorted(n)
+[-10, -3, 2, 5.5, 8]
+>>> sorted(n,reverse=True)
+[8, 5.5, 2, -3, -10]
+>>> w=["apple","banana","kiwi","strawberry"]
+>>> sorted(w)
+['apple', 'banana', 'kiwi', 'strawberry']
+>>> sorted(w,reverse=True)
+['strawberry', 'kiwi', 'banana', 'apple']
+>>> help(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(*iterables) --> A zip object yielding tuples until an input is exhausted.
+ |  
+ |     >>> list(zip('abcdefg', range(3), range(4)))
+ |     [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+ |  
+ |  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
+ |  shortest argument is exhausted.
+ |  
+ |  Methods defined here:
+ |  
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |  
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |  
+ |  __next__(self, /)
+ |      Implement next(self).
+ |  
+ |  __reduce__(...)
+ |      Return state information for pickling.
+ |  
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |  
+ |  __new__(*args, **kwargs) from builtins.type
+ |      Create and return a new object.  See help(type) for accurate signature.
+
+>>> list1=[1,2,3];list2=['a','b','c']
+>>> z=zip(list1,list2)
+>>> list(z)
+[(1, 'a'), (2, 'b'), (3, 'c')]
+>>> list3=[4,5,6]
+>>> list(zip(list1,list2,list3))
+[(1, 'a', 4), (2, 'b', 5), (3, 'c', 6)]
+
+#6
+>>> Gg1=45
+>>> gg1
+1.6
+
+#7
+#7.1
+>>> bb1=True; bb2=False
+>>> bb1;bb2
+True
+False
+>>> type(bb1)
+<class 'bool'>
+#7.2
+>>> ii1=-1234567890;ii1;type(ii1)
+-1234567890
+<class 'int'>
+>>> ff1=-8.9876e-12;ff1;type(ff1)
+-8.9876e-12
+<class 'float'>
+>>> dv1=0b1101010;dv1;type(dv1)
+106
+<class 'int'>
+>>> vsm1=0o52765;vsm1;type(vsm1)
+22005
+<class 'int'>
+>>> shest1=0x7109af6;shest1;type(shest1)
+118528758
+<class 'int'>
+>>> cc1=2-3j;cc1;type(cc1)
+(2-3j)
+<class 'complex'>
+>>> a=3.67;b=-0.45;cc2=complex(a,b);cc2;type(cc2)
+(3.67-0.45j)
+<class 'complex'>
+#7.3
+>>> ss1='Это - строка символов';ss1
+'Это - строка символов'
+>>> ss1="Это - строка символов";ss1
+'Это - строка символов'
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух сторонах"; print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух сторонах
+>>> ss1b='Меня зовут: \n Кузьменко Е.А.'; print(ss1b)
+Меня зовут: 
+ Кузьменко Е.А.
+>>> mnogo="""Нетрудно заметить, что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые учавствуют в операции."""; print(mnogo)
+Нетрудно заметить, что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые учавствуют в операции.
+>>> ss1
+'Это - строка символов'
+>>> ss1[0]
+'Э'
+>>> ss1[8]
+'р'
+>>> ss1[-2]
+'о'
+>>> ss1[6:9]
+'стр'
+>>> ss1[13:]
+'символов'
+>>> ss1[:13]
+'Это - строка '
+>>> ss1[5:-8]
+' строка '
+>>> ss1[3:17:2]
+'  тоасм'
+>>> ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#120>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+>>> ss1=ss1[:4]+'='+ss1[5:];ss1
+'Это = строка символов'
+#Примеры с ss1b
+>>> print(ss1b)
+Меня зовут: 
+ Кузьменко Е.А.
+>>> ss1b
+'Меня зовут: \n Кузьменко Е.А.'
+>>> ss1b[0]
+'М'
+>>> ss1b[14:]
+'Кузьменко Е.А.'
+>>> ss1b[0:15:3]
+'Мяот\n'
+>>> ss1b1=ss1b[:10]+' : \n'+ss1b[14:];print(ss1b1)
+Меня зовут : 
+Кузьменко Е.А.
+#Объекты разных типов
+>>> x1=6-24j;x1;type(x1)
+(6-24j)
+<class 'complex'>
+>>> x2=0.14e-13;x2;type(x2)
+1.4e-14
+<class 'float'>
+>>> x3=0b0101;x3;type(x3)
+5
+<class 'int'>
+>>> x4=True;x4;type(x4)
+True
+<class 'bool'>
+>>> x5=None;x5;type(x5)
+<class 'NoneType'>
+
+#8
+#8.1
+>>> spis1=[111,'Spisok',(5-9j)];spis1
+[111, 'Spisok', 5-9j]
+>>> stup=[0,0,1,1,1,1,1,1,1];stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+>>> spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+>>> spis1[-1]
+(5-9j)
+>>> stup[-8::2] #Начииная от 8 элемента с конца и заканчивая последним значением с шагом 2
+[0, 1, 1, 1]
+>>> spis1[1]='Список';spis1
+[111, 'Список', (5-9j)]
+>>> len(spis1)
+3
+#Методы добавления и удаления объекта
+>>> dir()
+['Gg1', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'bb1', 'bb2', 'builtins', 'cc1', 'cc2', 'dv1', 'f', 'ff1', 'gg1', 'hh1', 'ii1', 'key', 'keyword', 'list1', 'list2', 'list3', 'mnogo', 'n', 'os', 'rating', 'shest1', 'spis', 'spis1', 'ss1', 'ss1a', 'ss1b', 'ss1b1', 'students', 'stup', 'vsm1', 'w', 'x1', 'x2', 'x3', 'x4', 'x5', 'z', 'z1']
+>>> help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+>>> spis1.append('New item');spis1
+[111, 'Список', (5-9j), 'New item']
+>>> spis1+['New item'];spis1 #Только отображается!
+[111, 'Список', (5-9j), 'New item', 'New item']
+[111, 'Список', (5-9j), 'New item']
+>>> spis1.pop(1)
+'Список'
+>>> spis1
+[111, (5-9j), 'New item']
+>>> spis1.append(ss1b);print(spis1)
+[111, (5-9j), 'New item', 'Меня зовут: \n Кузьменко Е.А.']
+#Другие методы
+>>> spis1.insert(3,'Новый объект');spis1 #Вставляет объект на указанную позицию
+[111, (5-9j), 'New item', 'Новый объект', 'Меня зовут: \n Кузьменко Е.А.']
+>>> spis1.remove('New item');spis1 #Удаляет конкретный объект
+[111, (5-9j), 'Новый объект', 'Меня зовут: \n Кузьменко Е.А.']
+>>> spis2=['aa',123,'bb'];spis2
+['aa', 123, 'bb']
+>>> spis1.extend(spis2);spis1 #Добавляет объекты в конец списка
+[111, (5-9j), 'Новый объект', 'Меня зовут: \n Кузьменко Е.А.', 'aa', 123, 'bb']
+>>> spis2.clear();spis2 #Очищает список
+[]
+>>> spis3=[-9,2,5,0,10,-11];spis3.sort();spis3 #Сортирует по возрастанию
+[-11, -9, 0, 2, 5, 10]
+>>> spis3.sort(reverse=True);spis3 #Сортирует по убыванию
+[10, 5, 2, 0, -9, -11]
+>>> spis1.reverse();spis1 #Выписывает список в обратном порядке
+['bb', 123, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111]
+>>> copy1=spis1.copy();copy2=spis3.copy();print(copy1,copy2) #Копирует список
+['bb', 123, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111] [10, 5, 2, 0, -9, -11]
+>>> spis4=[1,1,0,2,4,5,5,1];spis4.count(1) #Считает сколько раз конкретный элемент вошёл в список
+3
+>>> spis4.index(5) #Находит индекс первого вхождения "5"
+5
+#Вложенные списки
+>>> spis2=[spis1,[4,5,6,7]];spis2
+[['bb', 123, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111], [4, 5, 6, 7]]
+>>> spis2[0][1] #Обращение к элементу первого списка(т.к. "0")
+123
+>>> spis2[0][1]=78;spis2;spis1
+[['bb', 78, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111], [4, 5, 6, 7]]
+['bb', 78, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111]
+>>> spis0=[123, 'ice cream', False, spis2];spis0
+[123, 'ice cream', False, [['bb', 78, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111], [4, 5, 6, 7]]]
+#8.2
+>>> kort1=(222,'Kortezh',77+8j)
+>>> kort1
+(222, 'Kortezh', (77+8j))
+>>> kort1=kort1+(1,2)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+>>> kort1=kort1+(ss1b,);kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Кузьменко Е.А.')
+>>> kort2=kort1[:2]+kort1[3:];kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n Кузьменко Е.А.')
+>>> kort1.index(2);kort1 #Первое появление двойки
+4
+>>> kort1.count(222)
+1
+>>> kort1[2]=90;kort1 #Нельзя изменить кортеж
+Traceback (most recent call last):
+  File "<pyshell#207>", line 1, in <module>
+    kort1[2]=90;kort1
+TypeError: 'tuple' object does not support item assignment
+
+>>> kort3=(16,'boo',[1,2,"aa"],(2,"bb",2));kort3
+(16, 'boo', [1, 2, 'aa'], (2, 'bb', 2))
+#8.3
+>>> dic1={'Saratov':145,'Orel':56,'Vologda':45};dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>> dic1['Orel']
+56
+>>> dic1['Pskov']=78;dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+
+#Сортировка по ключам и значениям
+>>> sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>> sorted(dic1.values())
+[45, 56, 78, 145]
+
+#Создание словарей
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'};dic2
+{1: 'mean', 2: 'standart deviation', 3: 'correlation'}
+>>> dic3={'statics':dic2,'POAS':['base','elementary','programming']};dic3
+{'statics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']}
+>>> dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)]);dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Кузьменко Е.А.'}
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]));dic5 #Объединение ключей и значений
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Кузьменко Е.А.'}
+
+>>> kort11=(2,6,'sa',True,False,12,1);kort11
+(2, 6, 'sa', True, False, 12, 1)
+>>> spis11=[2,'oo','bb',3,5];spis11
+[2, 'oo', 'bb', 3, 5]
+>>> dic11=dict(zip(kort11,spis11));dic11
+{2: 2, 6: 'oo', 'sa': 'bb', True: 3, False: 5}
+#Пример словаря
+>>> 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]
+
+#8.4
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'};mnoz1
+{'двигатель', 'микропроцессор', 'линия связи', 'датчик'}
+>>> len(mnoz1)
+4
+>>> 'датчик' in mnoz1
+True
+>>> mnoz1.add('реле');mnoz1
+{'двигатель', 'микропроцессор', 'реле', 'линия связи', 'датчик'}
+>>> mnoz1.remove('линия связи');mnoz1
+{'двигатель', 'микропроцессор', 'реле', 'датчик'}
+>>> mnoz2={4.12,'rr',True,True,2,2,3.2,'rr','rr',(1,2)};mnoz2
+{True, 2, 3.2, (1, 2), 4.12, 'rr'}
+>>> len(mnoz2)
+6
+>>> 2 in mnoz2
+True
+>>> 3 in mnoz2
+False
+>>> mnoz2.add('oo');mnoz2
+{True, 2, 3.2, (1, 2), 4.12, 'oo', 'rr'}
+>>> mnoz2.remove(3.2);mnoz2
+{True, 2, (1, 2), 4.12, 'oo', 'rr'}
+
+#9
+#Завершение работы exit()

TEMA2/report.md

@@ -0,0 +1,514 @@
+# Отчёт по Теме 2
+
+Кузьменко Елена, А-02-23
+
+## 1.Работа в оболочке IDLE. Задание рабочего каталога.
+
+```py
+>>> import os
+>>> os.chdir(r"C:\Users\Admin\Desktop\python-labs\TEMA2")
+>>> os.getcwd()
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA2'
+```
+
+Был открыт текстовый редактор для дальнейшего заполнения протокола. 
+
+![](p1.png)
+
+Файл Pr0.py(в каталоге ТЕМА2) будет нести в себе все команды и их вывод данной лаборатрной работы.
+
+## 2.Простые объекты
+
+Операции присваивания представлены в следующем примере:
+
+```py
+>>> f1=16; f2=3
+>>> f1,f2
+(16, 3)
+>>> f1;f2
+16
+3
+```
+
+Здесь f1,f2 - переменные, несущие в себе значения, которые задаются после знака "=".
+Если мы захотим узнать, какое значение имеет определённая переменная, это можно провести через знак ","(в одной строке) или ";"(каждая следующая строка), в зависимости от того, как мы собираемся разделять полученные значения.
+
+Следующая функция позволяет узнать какие объекты на данный момент существуют в среде:
+
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+
+Помимо встроенных в среду объектов, также можно заметить нами созданные: f1 и f2.
+
+Добавив аргумент, мы обращаемся к конкретному объекту:
+
+```py
+>>> dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
+```
+
+Функцией type() для этого же объекта определим классовую принадлежность:
+
+```py
+>>> type(f1)
+<class 'int'>
+```
+
+В данном случае переменная f1 и вправду несёт в себе целое число "16".
+
+Если нам необходимо удалить объект из оперативной памяти следует использовать инструкцию del. Попробуем удалить f1 и f2:
+
+```py
+>>> del f1
+>>> del f2
+>>> dir(f1)
+Traceback (most recent call last):
+  File "<pyshell#12>", line 1, in <module>
+    dir(f1)
+NameError: name 'f1' is not defined
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+Заметим, что эти объекты были удалены, а при прямом указания аргумента в инструкции dir() выдаёт ошибку.
+
+## 3.Именования объектов в среде.
+
+Правильные:
+
+```py
+>>> gg1=1.6; gg1
+1.6
+>>> hh1='Строка'; hh1
+'Строка'
+```
+
+Неправильные:
+
+```py
+>>> 73sr=3; 73sr
+SyntaxError: invalid syntax
+>>> and=7; and
+SyntaxError: invalid syntax
+```
+
+## 4.Список ключевых слов.
+
+```py
+>>> import keyword
+>>> keyword.kwlist
+['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> key=keyword.kwlist
+>>> key
+['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> type(key)
+<class 'list'>
+```
+
+## 5.Список встроенных идентификаторов.
+
+```py
+>>> import builtins
+>>> dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+
+Изучим некоторые функции из данного списка. Для этого также будем обращаться к помощи по следующей инструкции(для остальных функций по такому же принципу, можно посмотреть в протоколе):
+
+## Модуль числа
+
+```py
+>>> help(abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+
+>>> abs(13-40)
+27
+```
+
+## Количество элементов в объекте
+
+```py
+>>> len("2932")
+4
+>>> len(key)
+36
+```
+
+## Максимальное и минимальное значение
+
+```py
+>>> max(0,19,20,-2,200,-1012,99,134)
+200
+>>> max("в", "з", "щ", "я")
+'я' #По алфавиту позже остальных букв в данном перечне
+>>> min(0,19,20,-2,200,-1012,99,134)
+-1012
+>>> min("в", "з", "щ", "я")
+'в' #По алфавиту раньше остальных букв в данном перечне
+```
+
+## Возведение числа в степень
+
+```py
+>>> pow(2,3)
+8
+>>> pow(2,3,3) #3 аргумент - mod, вычисляет остаток в результате деления на mod
+2
+>>> pow(4,-3)
+0.015625
+```
+
+## Округление
+
+```py
+>>> round(123.456)
+123
+>>> round(123.456,1)
+123.5
+>>> round(123.456,-1)
+120.0
+```
+
+## Сортировка по возрастанию и убыванию
+
+```py
+>>> n=[-10,8,2,-3,5.5]
+>>> sorted(n)
+[-10, -3, 2, 5.5, 8]
+>>> sorted(n,reverse=True)
+[8, 5.5, 2, -3, -10]
+>>> w=["apple","banana","kiwi","strawberry"]
+>>> sorted(w)
+['apple', 'banana', 'kiwi', 'strawberry']
+>>> sorted(w,reverse=True)
+['strawberry', 'kiwi', 'banana', 'apple']
+```
+
+## Суммирование
+
+```py
+>>> sum(n)
+2.5
+>>> sum(n,10) #Задаём начальное значение(по умолчанию 0, здесь - 10)
+12.5
+>>> sum([x*2 for x in n]) #Каждое значение берётся в квадрат и суммируется с последующим
+5.0
+```
+
+## Объединение нескольких объектов
+
+```py
+>>> list1=[1,2,3];list2=['a','b','c']
+>>> z=zip(list1,list2)
+>>> list(z)
+[(1, 'a'), (2, 'b'), (3, 'c')]
+>>> list3=[4,5,6]
+>>> list(zip(list1,list2,list3))
+[(1, 'a', 4), (2, 'b', 5), (3, 'c', 6)]
+```
+
+## 6.Регистр
+
+```py
+>>> Gg1=45
+>>> gg1
+1.6
+```
+
+Если мы введём новую переменную, отличающуюся лишь регистром, она будет считаться отдельной. Gg1 и gg1 - разные переменные с разными значениями.
+
+## 7.Базовые типы объектов
+
+## 7.1.Логический тип.
+
+```py
+>>> bb1=True; bb2=False
+>>> bb1;bb2
+True
+False
+>>> type(bb1)
+<class 'bool'>
+```
+
+## 7.2.Другие простые типы
+
+```py
+>>> ii1=-1234567890;ii1;type(ii1)
+-1234567890
+<class 'int'>
+>>> ff1=-8.9876e-12;ff1;type(ff1)
+-8.9876e-12
+<class 'float'>
+>>> dv1=0b1101010;dv1;type(dv1)
+106
+<class 'int'>
+>>> vsm1=0o52765;vsm1;type(vsm1)
+22005
+<class 'int'>
+>>> shest1=0x7109af6;shest1;type(shest1)
+118528758
+<class 'int'>
+>>> cc1=2-3j;cc1;type(cc1)
+(2-3j)
+<class 'complex'>
+>>> a=3.67;b=-0.45;cc2=complex(a,b);cc2;type(cc2)
+(3.67-0.45j)
+<class 'complex'>
+```
+
+## 7.3.Строка символов
+
+```py
+>>> ss1='Это - строка символов';ss1
+'Это - строка символов'
+>>> ss1="Это - строка символов";ss1
+'Это - строка символов'
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух сторонах"; print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух сторонах
+>>> ss1b='Меня зовут: \n Кузьменко Е.А.'; print(ss1b)
+Меня зовут: 
+ Кузьменко Е.А.
+>>> mnogo="""Нетрудно заметить, что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые учавствуют в операции."""; print(mnogo)
+Нетрудно заметить, что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые учавствуют в операции.
+>>> ss1
+'Это - строка символов'
+>>> ss1[0]
+'Э'
+>>> ss1[8]
+'р'
+>>> ss1[-2]
+'о'
+>>> ss1[6:9]
+'стр'
+>>> ss1[13:]
+'символов'
+>>> ss1[:13]
+'Это - строка '
+>>> ss1[5:-8]
+' строка '
+>>> ss1[3:17:2]
+'  тоасм'
+>>> ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#120>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+>>> ss1=ss1[:4]+'='+ss1[5:];ss1
+'Это = строка символов'
+# Примеры с ss1b
+>>> print(ss1b)
+Меня зовут: 
+ Кузьменко Е.А.
+>>> ss1b
+'Меня зовут: \n Кузьменко Е.А.'
+>>> ss1b[0]
+'М'
+>>> ss1b[14:]
+'Кузьменко Е.А.'
+>>> ss1b[0:15:3]
+'Мяот\n'
+>>> ss1b1=ss1b[:10]+' : \n'+ss1b[14:];print(ss1b1)
+Меня зовут : 
+Кузьменко Е.А.
+
+>>> x1=6-24j;x1;type(x1)
+(6-24j)
+<class 'complex'>
+>>> x2=0.14e-13;x2;type(x2)
+1.4e-14
+<class 'float'>
+>>> x3=0b0101;x3;type(x3)
+5
+<class 'int'>
+>>> x4=True;x4;type(x4)
+True
+<class 'bool'>
+>>> x5=None;x5;type(x5)
+<class 'NoneType'>
+```
+
+## 8.Сложные типы объектов.
+
+## 8.1.Список
+
+```py
+>>> spis1=[111,'Spisok',(5-9j)];spis1
+[111, 'Spisok', 5-9j]
+>>> stup=[0,0,1,1,1,1,1,1,1];stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+>>> spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+>>> spis1[-1]
+(5-9j)
+>>> stup[-8::2] #Начииная от 8 элемента с конца и заканчивая последним значением с шагом 2
+[0, 1, 1, 1]
+>>> spis1[1]='Список';spis1
+[111, 'Список', (5-9j)]
+>>> len(spis1)
+3
+# Методы добавления и удаления объекта
+>>> dir()
+['Gg1', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'bb1', 'bb2', 'builtins', 'cc1', 'cc2', 'dv1', 'f', 'ff1', 'gg1', 'hh1', 'ii1', 'key', 'keyword', 'list1', 'list2', 'list3', 'mnogo', 'n', 'os', 'rating', 'shest1', 'spis', 'spis1', 'ss1', 'ss1a', 'ss1b', 'ss1b1', 'students', 'stup', 'vsm1', 'w', 'x1', 'x2', 'x3', 'x4', 'x5', 'z', 'z1']
+>>> help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+>>> spis1.append('New item');spis1
+[111, 'Список', (5-9j), 'New item']
+>>> spis1+['New item'];spis1 #Только отображается!
+[111, 'Список', (5-9j), 'New item', 'New item']
+[111, 'Список', (5-9j), 'New item']
+>>> spis1.pop(1)
+'Список'
+>>> spis1
+[111, (5-9j), 'New item']
+>>> spis1.append(ss1b);print(spis1)
+[111, (5-9j), 'New item', 'Меня зовут: \n Кузьменко Е.А.']
+# Другие методы
+>>> spis1.insert(3,'Новый объект');spis1 #Вставляет объект на указанную позицию
+[111, (5-9j), 'New item', 'Новый объект', 'Меня зовут: \n Кузьменко Е.А.']
+>>> spis1.remove('New item');spis1 #Удаляет конкретный объект
+[111, (5-9j), 'Новый объект', 'Меня зовут: \n Кузьменко Е.А.']
+>>> spis2=['aa',123,'bb'];spis2
+['aa', 123, 'bb']
+>>> spis1.extend(spis2);spis1 #Добавляет объекты в конец списка
+[111, (5-9j), 'Новый объект', 'Меня зовут: \n Кузьменко Е.А.', 'aa', 123, 'bb']
+>>> spis2.clear();spis2 #Очищает список
+[]
+>>> spis3=[-9,2,5,0,10,-11];spis3.sort();spis3 #Сортирует по возрастанию
+[-11, -9, 0, 2, 5, 10]
+>>> spis3.sort(reverse=True);spis3 #Сортирует по убыванию
+[10, 5, 2, 0, -9, -11]
+>>> spis1.reverse();spis1 #Выписывает список в обратном порядке
+['bb', 123, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111]
+>>> copy1=spis1.copy();copy2=spis3.copy();print(copy1,copy2) #Копирует список
+['bb', 123, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111] [10, 5, 2, 0, -9, -11]
+>>> spis4=[1,1,0,2,4,5,5,1];spis4.count(1) #Считает сколько раз конкретный элемент вошёл в список
+3
+>>> spis4.index(5) #Находит индекс первого вхождения "5"
+5
+# Вложенные списки
+>>> spis2=[spis1,[4,5,6,7]];spis2
+[['bb', 123, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111], [4, 5, 6, 7]]
+>>> spis2[0][1] #Обращение к элементу первого списка(т.к. "0")
+123
+>>> spis2[0][1]=78;spis2;spis1
+[['bb', 78, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111], [4, 5, 6, 7]]
+['bb', 78, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111]
+```
+При изменении spis2[0][1], мы поменяли второй элемент в самом списке spis1, так как заданный spis2[0] и есть spis1.
+
+```py
+>>> spis0=[123, 'ice cream', False, spis2];spis0
+[123, 'ice cream', False, [['bb', 78, 'aa', 'Меня зовут: \n Кузьменко Е.А.', 'Новый объект', (5-9j), 111], [4, 5, 6, 7]]]
+```
+
+## 8.2.Объект-кортеж
+
+```py
+>>> kort1=(222,'Kortezh',77+8j)
+>>> kort1
+(222, 'Kortezh', (77+8j))
+>>> kort1=kort1+(1,2)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+>>> kort1=kort1+(ss1b,);kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Кузьменко Е.А.')
+>>> kort2=kort1[:2]+kort1[3:];kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n Кузьменко Е.А.')
+>>> kort1.index(2);kort1 #Первое появление двойки
+4
+>>> kort1.count(222)
+1
+>>> kort1[2]=90;kort1 #Нельзя изменить кортеж
+Traceback (most recent call last):
+  File "<pyshell#207>", line 1, in <module>
+    kort1[2]=90;kort1
+TypeError: 'tuple' object does not support item assignment
+
+>>> kort3=(16,'boo',[1,2,"aa"],(2,"bb",2));kort3
+(16, 'boo', [1, 2, 'aa'], (2, 'bb', 2))
+```
+
+## 8.3.Объект-словарь
+
+```py
+>>> dic1={'Saratov':145,'Orel':56,'Vologda':45};dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>> dic1['Orel']
+56
+>>> dic1['Pskov']=78;dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+
+# Сортировка по ключам и значениям
+>>> sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>> sorted(dic1.values())
+[45, 56, 78, 145]
+
+# Создание словарей
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'};dic2
+{1: 'mean', 2: 'standart deviation', 3: 'correlation'}
+>>> dic3={'statics':dic2,'POAS':['base','elementary','programming']};dic3
+{'statics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']}
+>>> dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)]);dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Кузьменко Е.А.'}
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]));dic5 #Объединение ключей и значений
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Кузьменко Е.А.'}
+
+>>> kort11=(2,6,'sa',True,False,12,1);kort11
+(2, 6, 'sa', True, False, 12, 1)
+>>> spis11=[2,'oo','bb',3,5];spis11
+[2, 'oo', 'bb', 3, 5]
+>>> dic11=dict(zip(kort11,spis11));dic11
+{2: 2, 6: 'oo', 'sa': 'bb', True: 3, False: 5}
+```
+
+В данном случае кортеж - 7 элементов, список - 5 элементов. Однако создаваемый словарь подстроится под наименьшее количество элементов, пока в обоих перечнях присутствуют пары без повторов.
+
+```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={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'};mnoz1
+{'двигатель', 'микропроцессор', 'линия связи', 'датчик'}
+>>> len(mnoz1)
+4
+>>> 'датчик' in mnoz1
+True
+>>> mnoz1.add('реле');mnoz1
+{'двигатель', 'микропроцессор', 'реле', 'линия связи', 'датчик'}
+>>> mnoz1.remove('линия связи');mnoz1
+{'двигатель', 'микропроцессор', 'реле', 'датчик'}
+
+>>> mnoz2={4.12,'rr',True,True,2,2,3.2,'rr','rr',(1,2)};mnoz2
+{True, 2, 3.2, (1, 2), 4.12, 'rr'}
+>>> len(mnoz2)
+6
+>>> 2 in mnoz2
+True
+>>> 3 in mnoz2
+False
+>>> mnoz2.add('oo');mnoz2
+{True, 2, 3.2, (1, 2), 4.12, 'oo', 'rr'}
+>>> mnoz2.remove(3.2);mnoz2
+{True, 2, (1, 2), 4.12, 'oo', 'rr'}
+```
+
+## 9.Завершение работы со средой.

TEMA2/task.md

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

TEMA2/test.md

@@ -0,0 +1,20 @@
+# Общее контрольное задание по Теме 2
+
+Кузьменко Елена, А-02-23
+
+## Задание
+
+7. Напишите инструкцию создания множества с 5 русскоязычными названиями фруктов.
+Напишите инструкцию проверки вхождения фрукта «яблоко» в составе множества.
+
+
+## Решение
+
+```py
+>>>fruits={'яблоко','апельсин','апельсин','киви','яблоко','ананас','яблоко','мандарин'}; fruits
+{'яблоко', 'апельсин', 'ананас', 'киви', 'мандарин'}
+>>>'яблоко' in fruits
+True
+>>>len(fruits)
+5
+```

TEMA3/Pr3.py

@@ -0,0 +1,489 @@
+#Протокол по Теме3
+
+#2
+#2.1
+>>> logiz1=bool(56); logiz1
+True
+>>> logiz2=bool(0); logiz2
+False
+>>> logiz3=bool("Beta");logiz3
+True
+>>> logiz4=bool("");logiz4
+False
+
+#2.2
+>>> 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");tt5
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    tt5=int("98.76");tt5
+ValueError: invalid literal for int() with base 10: '98.76'
+>>> tt5=int(float("98.76"));tt5
+98
+
+#2.3
+>>> hh=123
+>>> dv1=bin(hh);dv1
+'0b1111011'
+>>> vos1=oct(hh);vos1
+'0o173'
+>>> shs1=hex(hh);shs1
+'0x7b'
+>>> pr_dv1=int(dv1);pr_dv1
+>>> pr_dv1=int(dv1,2);pr_dv1
+123
+>>> pr_vos1=int(vos1,8);pr_vos1
+123
+>>> pr_shs1=int(shs1,16);pr_shs1
+123
+
+#3
+#3.1
+>>> 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
+>>> spis1=list("Строка символов");spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+>>> spis2=list((124,236,-15,908));spis2
+[124, 236, -15, 908]
+>>> spis3=list({"A":1,"B":2,"C":9});spis3
+['A', 'B', 'C']
+>>> spis4=list({"A":1,"B":2,"C":9}.values());spis4
+[1, 2, 9]
+
+#3.3
+>>> kort7=tuple('Строка символов');kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8=tuple(spis2);kort8
+(124, 236, -15, 908)
+>>> kort9=tuple({"A":1,"B":2,"C":9});kort9
+('A', 'B', 'C')
+
+#3.4
+>>> del strk5,kort8
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'pr_dv1', 'pr_shs1', 'pr_vos1', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1']
+>>> dir(strk5)
+Traceback (most recent call last):
+  File "<pyshell#36>", line 1, in <module>
+    dir(strk5)
+NameError: name 'strk5' is not defined
+>>> dir(kort8)
+Traceback (most recent call last):
+  File "<pyshell#37>", line 1, in <module>
+    dir(kort8)
+NameError: name 'kort8' is not defined
+
+>>> name="Kuzmenko E.A.";name
+'Kuzmenko E.A.'
+>>> name_list=list(name);name_list
+['K', 'u', 'z', 'm', 'e', 'n', 'k', 'o', ' ', 'E', '.', 'A', '.']
+>>> name_kort=tuple(name_list);name_kort
+('K', 'u', 'z', 'm', 'e', 'n', 'k', 'o', ' ', 'E', '.', 'A', '.')
+>>> name_str=str(name_kort);name_str
+"('K', 'u', 'z', 'm', 'e', 'n', 'k', 'o', ' ', 'E', '.', 'A', '.')"
+>>> print(name_str)
+('K', 'u', 'z', 'm', 'e', 'n', 'k', 'o', ' ', 'E', '.', 'A', '.')
+
+#4
+#4.1
+>>> 12+7+90
+109
+>>> 5.689e-1 - 0.456
+0.11289999999999994
+>>> 23.6+54
+77.6
+>>> 14-56.7+89
+46.3
+
+#4.2
+>>> -6.7*12
+-80.4
+
+#4.3
+>>> -234.5/6
+-39.083333333333336
+>>> a=178/45;type(a)
+<class 'float'>
+>>> a
+3.9555555555555557
+
+#4.4
+>>> b=178//45;b;type(b)
+3
+<class 'int'>
+>>> c=-24.6//12.1;c;type(c)
+-3.0
+<class 'float'>
+>>> b1=178//12.1;b1;type(b1)
+14.0 #без округления 14.710743801652892
+<class 'float'>
+>>> c1=-24.6//45;c1;type(c1)
+-1.0 #без округления -0.5466666666666667
+<class 'float'>
+>>> c2=-24.6/45;c2
+-0.5466666666666667
+
+#4.5
+>>> A=148/33;A1=148%33;A,A1;type(A),type(A1)
+(4.484848484848484, 16)
+(<class 'float'>, <class 'int'>)
+>>> B=12.6/3.8;B1=12.6%3.8;B;B1;type(B);type(B1)
+3.3157894736842106
+1.2000000000000002
+<class 'float'>
+<class 'float'>
+>>> C=148/3.8;C1=148%3.8;C;C1;type(C);type(C1)
+38.94736842105263
+3.6000000000000068
+<class 'float'>
+<class 'float'>
+>>> D=12.6/33;D1=12.6%33;D;D1;type(D);type(D1)
+0.38181818181818183
+12.6
+<class 'float'>
+<class 'float'>
+
+#4.6
+>>> 14**3
+2744
+>>> e=2.7**3.6;e;type(e)
+35.719843790663525
+<class 'float'>
+>>> 14**3.6
+13367.830445904418
+>>> e1=2.7**3;e1;type(e1)
+19.683000000000003
+<class 'float'>
+>>> z=12+13j;z1=9-3j;z;z1;type(z);type(z1)
+(12+13j)
+(9-3j)
+<class 'complex'>
+<class 'complex'>
+>>> z+z1
+(21+10j)
+>>> z-z1
+(3+16j)
+>>> z*z1
+(147+81j)
+>>> z/z1
+(0.7666666666666667+1.7j)
+>>> z//z1
+Traceback (most recent call last):
+  File "<pyshell#80>", line 1, in <module>
+    z//z1
+TypeError: can't take floor of complex number.
+>>> z%z1
+Traceback (most recent call last):
+  File "<pyshell#81>", line 1, in <module>
+    z%z1
+TypeError: can't mod complex numbers.
+>>> z**z1
+(748985013590.2666-1875851778010.0532j)
+
+#5
+#5.1
+>>> dv1=9;dv1
+9
+>>> dv2=~dv1;dv2
+-10
+>>> dv11=3;dv22=~dv11;dv22
+-4
+
+#5.2
+>>> 7&9 #111 и 1001 = 0001
+1
+>>> 7&8 #111 и 1000 = 0000
+0
+>>> 3&7 #0011(бинарное) и 0111(бинарное) = 0011, то есть 3(десятичное)
+3
+
+#5.3
+>>> 7|9 #0111 или 1001
+15 #1111
+>>> 7|8 #111 или 1000
+15 #1111
+>>> 14|5 #1110 или 0101
+15 #1111
+
+#5.4
+>>> 14^5 #1110 искл.или 0101
+11 #1011
+
+#5.5
+>>> h=14;h;g=h<<2;bin(h);g;bin(g)
+14
+'0b1110'
+56
+'0b111000'
+>>> g1=h>>1;g1;bin(g1)
+7
+'0b111'
+>>> g2=h>>2;g2;bin(g2)
+3
+'0b11'
+>>> h1=75;h1;bin(75)
+75
+'0b1001011'
+>>> j1=h1>>4;j1;bin(j1)
+4
+'0b100'
+>>> j2=h1<<-3;j2;bin(j2)
+Traceback (most recent call last):
+  File "<pyshell#107>", line 1, in <module>
+    j2=h1<<-3;j2;bin(j2)
+ValueError: negative shift count
+>>> j2=h1<<3;j2;bin(j2)
+600
+'0b1001011000'
+
+#6
+#6.1
+>>> 'Система '+'регулирования'
+'Система регулирования'
+>>> ['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+
+#6.2
+>>> 'ля-'*5
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+>>> ('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1=[0]*3+[1]*99; signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+>>> signal2=(0,)*3+(1,)*5+(0,)*7;signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+
+#6.3
+>>> stroka='Система автоматического управления'
+>>> 'автомат' in stroka
+True
+>>> 'ку' in ['ку','-']*3
+True
+>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+
+#6.4
+>>> stroka='Температура = %g %s  %g';stroka
+'Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25);stroka
+'Температура = 16  меньше   25'
+'Температура = %g %s  %g'
+>>> stroka1='Температура = %(zn1)g %(sravn)s  %(zn2)g';stroka1
+'Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka1 % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+
+#7
+#7.1
+>>> zz=-12;zz
+-12
+
+#7.2
+>>> zz=-12;zz
+-12
+>>> zz+=5;zz
+-7
+>>> zz-=3;zz
+-10
+>>> stroka2='Система'; stroka2
+'Система'
+>>> stroka2+=' регулирования';stroka2
+'Система регулирования'
+
+#7.3
+>>> zz;zz/=2;zz
+-10
+-5.0
+>>> zz*=5;zz
+-25.0
+>>> stroka2*=3;stroka2
+'Система регулированияСистема регулированияСистема регулирования'
+
+#7.4
+>>> zz;zz//=4;zz
+-25.0
+-7.0
+>>> zz**=2;zz
+49.0
+>>> zz%=5;zz
+4.0
+
+#8
+#8.1
+>>> w=15;v=-10;w;v
+15
+-10
+>>> w==v
+False
+>>> w!=v
+True
+>>> w<v
+False
+>>> w>v
+True
+>>> w>=v
+True
+>>> w<=v
+False
+>>> w1='abcd';v1='aloaloalo'
+>>> w1==v1
+False
+>>> w1>v1
+False
+>>> w1<v1
+True
+
+#8.2
+>>> mnoz1={'pen','book','pen','iPhone','table','book'};mnoz1
+{'iPhone', 'pen', 'book', 'table'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45};dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>> 'Vologda' in dic1
+True
+>>> 'Pskov' in dic1
+False
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']};dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+>>> 'UII' in dct1['Depart']
+True
+>>> dct1['Depart'][1] == 'MM'
+False
+
+#8.3
+>>> a=17;b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+>>> not (a==b) or ('pen' in mnoz1) and ('Depart' in dct1)
+True
+>>> not ('pen' in mnoz1) or not (a<b) and ('Depart' in dct1)
+True
+
+#8.4
+>>> w=v=10
+>>> w;v
+10
+10
+>>> w is v
+True
+>>> w1=['A','B'];v1=['A','B']
+>>> w1 is v1
+False
+
+#9
+>>> stroka='Микропроцессорная система управления';stroka
+'Микропроцессорная система управления'
+>>> dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+
+#9.1
+>>> stroka.find('пр')
+5
+>>> stroka.count('с')
+4
+>>> stroka.replace('у','автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> 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'
+
+#9.2
+>>> spsk=[123,'lala',False,'abc','12'];spsk
+[123, 'lala', False, 'abc', '12']
+>>> spsk.pop(2);spsk
+False
+[123, 'lala', 'abc', '12']
+>>> spsk.append('c');spsk
+[123, 'lala', 'abc', '12', 'c']
+>>> spsk.insert(2,'a');spsk
+[123, 'lala', 'a', 'abc', '12', 'c']
+>>> spsk.count('a');spsk
+1
+[123, 'lala', 'a', 'abc', '12', 'c']
+
+#9.3
+>>> k=(3+3j,'oo',1,'324','hello');k
+((3+3j), 'oo', 1, '324', 'hello')
+>>> k.count(3)
+0
+>>> k.count(1)
+1
+>>> k.index(1)
+2
+>>> len(k)
+5
+>>> k[0]
+(3+3j)
+
+#9.4
+>>> sl={'a':1,'b':2,'c':3,'d':4,'e':5};sl
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
+>>> sl.keys()
+dict_keys(['a', 'b', 'c', 'd', 'e'])
+>>> sl.values()
+dict_values([1, 2, 3, 4, 5])
+>>> sl.get('a')
+1
+>>> sl.update({'e':150});sl
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 150}
+>>> sl.pop('b');sl
+2
+{'a': 1, 'c': 3, 'd': 4, 'e': 150}
+>>> sl.clear();sl
+{}
+>>> mn={1,11,'lo',11,'mnoz','123','mnoz'};mn
+{'123', 1, 'mnoz', 11, 'lo'}
+>>> mn.add(2);mn
+{'123', 1, 2, 'mnoz', 11, 'lo'}
+>>> mn.remove(1);mn
+{'123', 2, 'mnoz', 11, 'lo'}
+>>> mn.pop();mn #удаляет случайный элемент
+'123'
+{2, 'mnoz', 11, 'lo'}
+>>> mn.clear();mn
+set()
+
+#10 Завершение работы со средой

TEMA3/report.md

@@ -0,0 +1,670 @@
+# Отчёт по Теме 3
+
+Кузьменко Елена, А-02-23
+
+## 1. Запустили интерактивную оболочку IDLE.
+
+## 2. Преобразование простых базовых типов объектов.
+
+### 2.1. Логический тип.
+
+```py
+>>> logiz1=bool(56); logiz1
+True
+>>> logiz2=bool(0); logiz2
+False
+>>> logiz3=bool("Beta");logiz3
+True
+>>> logiz4=bool("");logiz4
+False
+```
+
+### 2.2. Целое десятичное число с заданной системой счисления.
+
+```py
+>>> tt1=int(198.6);tt1 #Отбрасывает дробную часть
+198
+>>> tt2=int("-76");tt2
+-76
+>>> tt3=int("B",16);tt3
+11
+>>> tt4=int("71",8);tt4
+57
+>>> tt5=int("98.76");tt5 #Читает строку как целое число(ошибка)
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    tt5=int("98.76");tt5
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+
+Нельзя напрямую преобразовать строку с дробным числом в целое число, так как int() не принимает строки с точкой.
+
+```py
+>>> tt5=int(float("98.76"));tt5
+98
+```
+
+### 2.3. Другие системы счисления.
+
+```py
+>>> hh=123
+>>> dv1=bin(hh);dv1
+'0b1111011'
+>>> vos1=oct(hh);vos1
+'0o173'
+>>> shs1=hex(hh);shs1
+'0x7b'
+>>> pr_dv1=int(dv1);pr_dv1
+```
+
+Проверка:
+
+```py
+>>> pr_dv1=int(dv1,2);pr_dv1
+123
+>>> pr_vos1=int(vos1,8);pr_vos1
+123
+>>> pr_shs1=int(shs1,16);pr_shs1
+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']
+```
+
+В список попали только ключи словаря. Сделаем список со значениями:
+
+```py
+>>> spis4=list({"A":1,"B":2,"C":9}.values());spis4
+[1, 2, 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
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'pr_dv1', 'pr_shs1', 'pr_vos1', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1']
+>>> dir(strk5)
+Traceback (most recent call last):
+  File "<pyshell#36>", line 1, in <module>
+    dir(strk5)
+NameError: name 'strk5' is not defined
+>>> dir(kort8)
+Traceback (most recent call last):
+  File "<pyshell#37>", line 1, in <module>
+    dir(kort8)
+NameError: name 'kort8' is not defined
+```
+
+```py
+>>> name="Kuzmenko E.A.";name
+'Kuzmenko E.A.'
+>>> name_list=list(name);name_list
+['K', 'u', 'z', 'm', 'e', 'n', 'k', 'o', ' ', 'E', '.', 'A', '.']
+>>> name_kort=tuple(name_list);name_kort
+('K', 'u', 'z', 'm', 'e', 'n', 'k', 'o', ' ', 'E', '.', 'A', '.')
+>>> name_str=str(name_kort);name_str
+"('K', 'u', 'z', 'm', 'e', 'n', 'k', 'o', ' ', 'E', '.', 'A', '.')"
+>>> print(name_str)
+('K', 'u', 'z', 'm', 'e', 'n', 'k', 'o', ' ', 'E', '.', 'A', '.')
+```
+
+## 4. Работа с арифметическими операциями
+
+### 4.1. Сложение и вычитание
+
+```py
+>>> 12+7+90
+109
+>>> 5.689e-1 - 0.456
+0.11289999999999994
+>>> 23.6+54
+77.6
+>>> 14-56.7+89
+46.3
+```
+
+### 4.2. Умножение
+
+```py
+>>> -6.7*12
+-80.4
+```
+
+### 4.3. Деление
+
+```py
+>>> -234.5/6
+-39.083333333333336
+>>> a=178/45;type(a)
+<class 'float'>
+>>> a
+3.9555555555555557
+```
+
+### 4.4. Деление с округлением
+
+```py
+>>> b=178//45;b;type(b)
+3
+<class 'int'>
+>>> c=-24.6//12.1;c;type(c)
+-3.0
+<class 'float'>
+>>> b1=178//12.1;b1;type(b1)
+14.0 #без округления 14.710743801652892
+<class 'float'>
+>>> c1=-24.6//45;c1;type(c1)
+-1.0 #без округления -0.5466666666666667
+<class 'float'>
+>>> c2=-24.6/45;c2
+-0.5466666666666667
+```
+
+### 4.5. Остаток от деления
+
+```py
+>>> A=148/33;A1=148%33;A,A1;type(A),type(A1)
+(4.484848484848484, 16)
+(<class 'float'>, <class 'int'>)
+>>> B=12.6/3.8;B1=12.6%3.8;B;B1;type(B);type(B1)
+3.3157894736842106
+1.2000000000000002
+<class 'float'>
+<class 'float'>
+>>> C=148/3.8;C1=148%3.8;C;C1;type(C);type(C1)
+38.94736842105263
+3.6000000000000068
+<class 'float'>
+<class 'float'>
+>>> D=12.6/33;D1=12.6%33;D;D1;type(D);type(D1)
+0.38181818181818183
+12.6
+<class 'float'>
+<class 'float'>
+```
+
+### 4.6. Степень числа
+
+```py
+>>> 14**3
+2744
+>>> e=2.7**3.6;e;type(e)
+35.719843790663525
+<class 'float'>
+>>> 14**3.6
+13367.830445904418
+>>> e1=2.7**3;e1;type(e1)
+19.683000000000003
+<class 'float'>
+```
+
+Операции с комплексными числами:
+
+```py
+>>> z=12+13j;z1=9-3j;z;z1;type(z);type(z1)
+(12+13j)
+(9-3j)
+<class 'complex'>
+<class 'complex'>
+>>> z+z1
+(21+10j)
+>>> z-z1
+(3+16j)
+>>> z*z1
+(147+81j)
+>>> z/z1
+(0.7666666666666667+1.7j)
+>>> z//z1
+Traceback (most recent call last):
+  File "<pyshell#80>", line 1, in <module>
+    z//z1
+TypeError: can't take floor of complex number.
+>>> z%z1
+Traceback (most recent call last):
+  File "<pyshell#81>", line 1, in <module>
+    z%z1
+TypeError: can't mod complex numbers.
+>>> z**z1
+(748985013590.2666-1875851778010.0532j)
+```
+
+Комплексные числа не поддерживают операции // и % потому что они не упорядочены, то есть у них нет понятия больше или меньше, необходимого для округления и вычисления остатка.
+
+## 5. Двоичные представления целых чисел
+
+### 5.1. Инверсия
+
+```py
+>>> dv1=9;dv1
+9
+>>> dv2=~dv1;dv2
+-10
+>>> dv11=3;dv22=~dv11;dv22
+-4
+```
+
+### 5.2. "И"
+
+```py
+>>> 7&9 #111 и 1001 = 0001
+1
+>>> 7&8 #111 и 1000 = 0000
+0
+>>> 3&7 #0011(бинарное) и 0111(бинарное) = 0011, то есть 3(десятичное)
+3
+```
+
+### 5.3. "ИЛИ"
+
+```py
+>>> 7|9 #0111 или 1001
+15 #1111
+>>> 7|8 #111 или 1000
+15 #1111
+>>> 14|5 #1110 или 0101
+15 #1111
+```
+
+### 5.4. Исключающее "ИЛИ"
+
+1 если биты разные, 0 если одинаковые:
+
+```py
+>>> 14^5 #1110 искл.или 0101
+11 #1011
+```
+
+### 5.5. Сдвиг двоичного числа
+
+```py
+>>> h=14;h;g=h<<2;bin(h);g;bin(g)
+14
+'0b1110'
+56
+'0b111000'
+>>> g1=h>>1;g1;bin(g1)
+7
+'0b111'
+>>> g2=h>>2;g2;bin(g2)
+3
+'0b11'
+>>> h1=75;h1;bin(75)
+75
+'0b1001011'
+>>> j1=h1>>4;j1;bin(j1)
+4
+'0b100'
+>>> j2=h1<<3;j2;bin(j2)
+600
+'0b1001011000'
+```
+
+## 6. Работа с последовательностями
+
+### 6.1. Объединение
+
+```py
+>>> 'Система '+'регулирования'
+'Система регулирования'
+>>> ['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+### 6.2. Повторение
+
+```py
+>>> 'ля-'*5
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+>>> ('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1=[0]*3+[1]*99; signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+>>> signal2=(0,)*3+(1,)*5+(0,)*7;signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+
+### 6.3. Наличие заданного подстроки и контекста
+
+```py
+>>> stroka='Система автоматического управления'
+>>> 'автомат' in stroka
+True
+>>> 'ку' in ['ку','-']*3
+True
+>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+```
+
+### 6.4. Подстановка значений
+
+```py
+>>> stroka='Температура = %g %s  %g';stroka
+'Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25);stroka
+'Температура = 16  меньше   25'
+'Температура = %g %s  %g'
+>>> stroka1='Температура = %(zn1)g %(sravn)s  %(zn2)g';stroka1
+'Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka1 % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+## 7. Присваивание
+
+### 7.1. Обычное
+
+```py
+>>> zz=-12;zz
+-12
+```
+
+### 7.2 Увеличение и уменьшение значения
+
+```py
+>>> zz=-12;zz
+-12
+>>> zz+=5;zz
+-7
+>>> zz-=3;zz
+-10
+>>> stroka2='Система'; stroka2
+'Система'
+>>> stroka2+=' регулирования';stroka2
+'Система регулирования'
+```
+### 7.3. Умножение и деление значения
+
+```py
+>>> zz;zz/=2;zz
+-10
+-5.0
+>>> zz*=5;zz
+-25.0
+>>> stroka2*=3;stroka2
+'Система регулированияСистема регулированияСистема регулирования'
+```
+
+### 7.4. Деление с округлением, остаток, степень
+
+```py
+>>> zz;zz//=4;zz
+-25.0
+-7.0
+>>> zz**=2;zz
+49.0
+>>> zz%=5;zz
+4.0
+```
+
+### 7.5. Множественное присваивание
+
+```py
+>>> n1,n2,v3=(11,-3,'all');n1;n2;n3
+11
+-3
+'all'
+>>> n1,n2,n3="11","-3","all";n1;n2;n3
+'11'
+'-3'
+'all'
+>>> n1,n2,n3=[11,-3,'all'];n1;n2;n3
+11
+-3
+'all'
+>>> n1,n2,n3={11:1,-3:2,'all':3};n1;n2;n3
+11
+-3
+'all'
+>>> n1,n2,n3={11,-3,'all',-3,11};n1;n2;n3
+11
+'all'
+-3
+```
+
+## 8. Логические операции
+
+### 8.1. Сравнение
+
+```py
+>>> w=15;v=-10;w;v
+15
+-10
+>>> w==v
+False
+>>> w!=v
+True
+>>> w<v
+False
+>>> w>v
+True
+>>> w>=v
+True
+>>> w<=v
+False
+>>> w1='abcd';v1='aloaloalo'
+>>> w1==v1
+False
+>>> w1>v1
+False
+>>> w1<v1
+True
+```
+
+### 8.2. Наличие элемента
+
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'};mnoz1
+{'iPhone', 'pen', 'book', 'table'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45};dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>> 'Vologda' in dic1
+True
+>>> 'Pskov' in dic1
+False
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']};dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+>>> 'UII' in dct1['Depart']
+True
+>>> dct1['Depart'][1] == 'MM'
+False
+```
+
+### 8.3. Логические выражения
+
+```py
+>>> a=17;b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+>>> not (a==b) or ('pen' in mnoz1) and ('Depart' in dct1)
+True
+>>> not ('pen' in mnoz1) or not (a<b) and ('Depart' in dct1)
+True
+```
+
+### 8.4. Ссылки переменных на тот же объект
+
+```py
+>>> w=v=10
+>>> w;v
+10
+10
+>>> w is v
+True
+>>> w1=['A','B'];v1=['A','B']
+>>> w1 is v1
+False
+```
+
+В первом случае w и v ссылаются на один и тот же объект, поэтому проверка выдаёт True. Для второго случая создаётся два разных списка, каждый из которых занимают свою ячейку памяти(по отдельности друг от друга и без ссылок), поэтому как "разные объекты" результат - False.
+
+## 9. Методы для операций с объектами
+
+```py
+>>> stroka='Микропроцессорная система управления';stroka
+'Микропроцессорная система управления'
+>>> dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+### 9.1. Работа со строками
+
+```py
+>>> stroka.find('пр')
+5
+>>> stroka.count('с')
+4
+>>> stroka.replace('у','автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' ');spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3=" ".join(spis22);stroka3
+'Микропроцессорная система управления'
+>>> stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+```
+
+Метод format:
+
+```py
+>>> 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'
+```
+
+### 9.2. Работа со списками
+
+```py
+>>> spsk=[123,'lala',False,'abc','12'];spsk
+[123, 'lala', False, 'abc', '12']
+>>> dir(spsk)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+>>> spsk.pop(2);spsk
+False
+[123, 'lala', 'abc', '12']
+>>> spsk.append('c');spsk
+[123, 'lala', 'abc', '12', 'c']
+>>> spsk.insert(2,'a');spsk
+[123, 'lala', 'a', 'abc', '12', 'c']
+>>> spsk.count('a');spsk
+1
+[123, 'lala', 'a', 'abc', '12', 'c']
+```
+
+### 9.3. Кортеж
+
+```py
+>>> k=(3+3j,'oo',1,'324','hello');k
+((3+3j), 'oo', 1, '324', 'hello')
+>>> dir(k)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+>>> k.count(3)
+0
+>>> k.count(1)
+1
+>>> k.index(1)
+2
+>>> len(k)
+5
+>>> k[0]
+(3+3j)
+```
+
+### 9.4. Словарь и множество
+
+Словарь
+
+```py
+>>> sl={'a':1,'b':2,'c':3,'d':4,'e':5};sl
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
+>>> dir(sl)
+['__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']
+>>> sl.keys()
+dict_keys(['a', 'b', 'c', 'd', 'e'])
+>>> sl.values()
+dict_values([1, 2, 3, 4, 5])
+>>> sl.get('a')
+1
+>>> sl.update({'e':150});sl
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 150}
+>>> sl.pop('b');sl
+2
+{'a': 1, 'c': 3, 'd': 4, 'e': 150}
+>>> sl.clear();sl
+{}
+```
+Множество 
+
+```py
+>>> mn={1,11,'lo',11,'mnoz','123','mnoz'};mn
+>>> dir(mn)
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+{'123', 1, 'mnoz', 11, 'lo'}
+>>> mn.add(2);mn
+{'123', 1, 2, 'mnoz', 11, 'lo'}
+>>> mn.remove(1);mn
+{'123', 2, 'mnoz', 11, 'lo'}
+>>> mn.pop();mn #удаляет случайный элемент
+'123'
+{2, 'mnoz', 11, 'lo'}
+>>> mn.clear();mn
+set()
+```
+## 10. Сеанс работы с IDLE закончен

TEMA3/task.md

@@ -0,0 +1,79 @@
+## Общее контрольное задание по Теме 3
+
+Кузьменко Елена, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+   1) Преобразовать восьмеричное значение 45 в целое число.
+   2) Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+   3) Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+   4) Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+   5) Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+   6) Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+   7) Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+### 1)Преобразовать восьмеричное значение 45 в целое число.
+
+```py
+>>> vs=int('45',8);vs
+37
+```
+
+### 2)Создание объекта-словаря D
+
+```py
+>>> D={"усиление":23, "запаздывание":12, "постоянная времени":78};D
+{'усиление': 23, 'запаздывание': 12, 'постоянная времени': 78}
+>>> k_list=list(D.keys());v_list=list(D.values());k_list;v_list
+['усиление', 'запаздывание', 'постоянная времени']
+[23, 12, 78]
+```
+
+### 3)Работа с выражение №1
+
+```py
+>>> a=(1768//24.8%3)**2.4;a
+5.278031643091577
+```
+
+### 4)Работа с выражение №2
+
+```py
+>>> b=~((13&27)^14)<<2;b
+-32
+```
+
+### 5)Создание списка с 4 одинаковыми элементами
+
+```py
+>>> sp=['колебат']*4;sp
+['колебат', 'колебат', 'колебат', 'колебат']
+>>> 'аткол' in (sp[1]+sp[2])
+True
+```
+
+### 6)Список методов
+
+```py
+>>> dir(D)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>> D.keys();D.values()
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+dict_values([23, 12, 78])
+```
+
+### 7) Создание объекта-символьная строка
+
+```py
+>>> t="Создать объект - символьную строку с текстом данного предложения.";t
+'Создать объект - символьную строку с текстом данного предложения.'
+>>> w=t.split();w
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+>>> w[w.index('-')]=',';w
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+>>> w.remove('данного');w
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```

TEMA3/test.md

@@ -0,0 +1,75 @@
+# Индивидуальное контрольное задание по Модулю 1
+
+Кузьменко Елена, А-02-23, Вариант 11
+
+## Задание
+
+1)	Для чего предназначено предложение "Окно (Window)" главного меню?
+
+2)	Создайте объект-кортеж с 5 произвольными двоичными элементами. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкцию создания нового кортежа, в который включите два последних элемента ранее созданного кортежа, и два элемента - символы "a" и "b". Отобразите созданный объект на экране.
+
+4)	Преобразуйте кортеж в список. Вставьте в качестве второго элемента списка значение "Автоматизированная система". Отобразите полученный объект. Напишите инструкцию, создающую символьную строку со значением, равным символам из вставленного элемента, начиная с 19-го.
+
+5)	Напишите инструкции, обеспечивающие подсчет суммы числовых элементов кортежа. С использованием формата отобразите результат по шаблону: "Сумма элементов=:".
+
+## Решение
+
+### 1)Предназначения "Окна(Windows)" главного меню
+
+"Window" предназначен для быстрого переключения между открытыми окнами среды. Например, это удобно использовать, если наша работа требует несколько текстовых редакторов, разбросанных по разным файлам, тогда по названию можно быстро переключиться на нужный.
+
+### 2)Объект-кортеж
+
+```py
+>>> n1=bin(2); n2=bin(15); n3=bin(12); n4=bin(43); n5=bin(95)
+>>> n1; n2; n3; n4; n5 
+'0b10'
+'0b1111'
+'0b1100'
+'0b101011'
+'0b1011111'
+>>> type(n1)
+<class 'str'> #str, а не bin. В кортеж добавим двоичные элементы(не строковые)
+>>> k=(0b10,0b1111,0b1100,0b101011,0b1011111); k #Кортеж способен выполнять действия с числами. В данном случае он bin преобразует в int
+(2, 15, 12, 43, 95)
+>>> type(k); dir(k)
+<class 'tuple'>
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+```
+
+### 3)Новый кортеж
+
+```py
+>>> new_k=k[-2:]+('a','b'); new_k 
+(43, 95, 'a', 'b')
+```
+
+### 4)Преобразование в список
+
+```py
+l=list(new_k); l
+[43, 95, 'a', 'b']
+l.insert(1,'Автоматизированная система') # 1 - второй элемент
+l
+[43, 'Автоматизированная система', 95, 'a', 'b']
+new_str=l[1][18:]; new_str # [1] - второй элемент списка, [18:] - начиная с 19 элемента
+' система'
+```
+
+### 5)Подсчет суммы кортежа
+
+```py
+#Так как я знаю, что последние два элемента НЕ числа(они мешают применить инструкцию sum), с помощью среза я избавлюсь от строк для подсчета числовых элементов кортежа(числ эл. - все, за исключением последних двух).
+
+>>> sum1=sum(new_k[:2]); sum1  # 43+95
+138
+
+#Альтернативное решение можно представить с циклом for и if(необходимо, если неизвество на каких местах строки и числа), однако данная тема ещё не была пройдена. В рамках данного задания известно под какими индеками находятся те или иные элементы.
+>>> itog="Сумма элементов=: {}"; itog
+'Сумма элементов=: {}'
+>>> itog.format(sum1)
+'Сумма элементов=: 138'
+```
+

TEMA4/report.md

@@ -0,0 +1,307 @@
+# Отчёт по Теме 4
+
+Кузьменко Елена, А-02-23
+
+## 1. Запустили интерактивную оболочку IDLE.
+
+## 2.Стандартные функции.
+
+### 2.1.Округление числа с заданной точностью.
+
+```py
+>>> a = round(123.456,1); a; type(a)
+123.5
+<class 'float'>
+>>> a1 = round(123.456,0); a1; type(a1)
+123.0
+<class 'float'>
+>>> a2 = round(123.456); a2; type(a2)
+123
+<class 'int'>
+```
+
+### 2.2. Последовательные целые числа.
+
+```py
+>>> gg = range(76,123,9); gg; type(gg) #От 76 до 123 с шагом 9
+range(76, 123, 9)
+<class 'range'>
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> gg1 = range(23); gg1 #Создаёт последовательность от 0 до 23 с шагом 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.Общий объект.
+
+```py
+>>> qq = ["Кузьменко", "Беженарь", "Добровольска", "Криви"]; qq
+['Кузьменко', 'Беженарь', 'Добровольска', 'Криви']
+>>> ff = zip(gg,qq); ff; type(ff)
+<zip object at 0x0000014F96720F40>
+<class 'zip'>
+>>> ff1 = tuple(ff); ff1
+((76, 'Кузьменко'), (85, 'Беженарь'), (94, 'Добровольска'), (103, 'Криви'))
+>>> ff1[0]
+(76, 'Кузьменко')
+
+
+>>> tuple(ff)
+((76, 'Кузьменко'), (85, 'Беженарь'), (94, 'Добровольска'), (103, 'Криви'))
+>>> ff
+<zip object at 0x0000014F94622440>
+>>> ff[0]
+Traceback (most recent call last):
+  File "<pyshell#32>", line 1, in <module>
+    ff[0]
+TypeError: 'zip' object is not subscriptable
+```
+
+### 2.4. Функция eval().
+
+```py
+>>> fff = float(input('коэффициент усиления=')); dan = eval('5*fff-156')
+коэффициент усиления=32
+>>> dan; type(dan)
+4.0
+<class 'float'>
+```
+
+### 2.5. Функция exec().
+
+```py
+>>> exec(input('введите инструкции:'))
+введите инструкции:perem = -123.456; gg = round(abs(perem)+98,3)
+>>> gg
+221.456
+```
+eval() - возвращает результат;
+exec() - выполняет код без возврата значения.
+
+### 2.6. Другие функции.
+
+```py
+>>> abs(-5)
+5
+>>> pow(2,3)
+8
+>>> max(-1,5,3)
+5
+>>> min(-1,5,3)
+-1
+>>> sum([1,2,3])
+6
+>>> divmod(10,3) # частное и остаток от деления
+(3, 1)
+>>> len("sdjalad")
+7
+>>> s=map(str,[1,2,3]); s #Применяет функцию к каждому элементу итерируемого объекта
+<map object at 0x0000014F967EFDF0>
+>>> list(s)
+['1', '2', '3']
+```
+
+## 3.Функции стандартного модулю math
+
+```py
+>>> import math
+>>> dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(x, /)
+    Find x!.
+    
+    Raise a ValueError if x is negative or non-integral.
+
+>>> math.factorial(5)
+120
+>>> math.sin(math.pi)
+1.2246467991473532e-16
+>>> math.acos(0.5)
+1.0471975511965979
+>>> math.degrees(math.pi)
+180.0
+>>> math.radians(180) # градусы в радианы
+3.141592653589793
+>>> math.exp(1)
+2.718281828459045
+>>> math.log(10)
+2.302585092994046
+>>> math.log10(100)
+2.0
+>>> math.sqrt(16)
+4.0
+>>> math.ceil(4.3) # Округление вверх
+5
+>>> math.floor(4.8)
+4
+```
+## 4.Модуль cmath для работы с комплексными числами.
+
+```py
+>>> import cmath
+>>> dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+>>> cmath.sqrt(1.2-0.5j) #квадратный корень
+(1.118033988749895-0.22360679774997896j)
+>>> cmath.phase(1-0.5j) #фаза(угол) - arctan(b/a)
+-0.4636476090008061
+```
+
+## 5.Модуль random для операций с псевдослучайными числами.
+
+```py
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_inst', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>> help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+    
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+    
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+    
+    If *a* is an int, all bits are used.
+    
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+>>> random.seed() #нужен для инициализации генератора псевдослучайных чисел. Воспроизводит последовательность при каждом запуске.
+>>> random.random() #случайное число от 0 до 1, не включая верхнюю границу
+0.08881917055800503
+>>> random.uniform(1,10) #равномерное распределение
+8.672615135853867
+>>> random.gauss(0,1) #нормальное распределение
+-1.571314734927639
+>>> random.randint(1,100) #случайное целое
+91
+>>> random.choice(['1','2','a','b'])
+'b'
+>>> s = [1,2,3,4,5]
+>>> random.shuffle(s); s
+[3, 4, 1, 2, 5]
+>>> random.sample(s,3) #случайная выборка
+[4, 5, 1]
+>>> random.betavariate(2,5) #бета-распределение
+0.22293634372615048
+>>> random.gammavariate(2,1) #гамма-распределение
+3.778718164367487
+```
+
+## 6.Модуль time - работа с календарем и со временем.
+
+```py
+>>> import time
+>>> dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+>>> c1=time.time(); c1
+1760380211.648074
+>>> c2 = time.time()-c1; c2
+30.08062195777893
+>>> dat=time.gmtime(); dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=18, tm_min=32, tm_sec=19, tm_wday=0, tm_yday=286, tm_isdst=0)
+>>> dat.tm_mon
+10
+>>> dat.tm_min
+32
+>>> dat.tm_mday
+13
+>>> time.localtime()
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=21, tm_min=34, tm_sec=31, tm_wday=0, tm_yday=286, tm_isdst=0)
+>>> time.asctime()
+'Mon Oct 13 21:35:28 2025'
+>>> time.ctime(time.time()) #секунды в строку
+'Mon Oct 13 21:35:47 2025'
+>>> time.sleep(2) #задержка выполнения на 2 секунды
+>>> time.mktime(time.localtime()) #преобразование в секунды
+1760380623.0
+```
+
+## 7.Графические функции.
+
+```py
+>>> import pylab
+>>> x = list(range(-3,55,4))
+>>> t = list(range(15))
+>>> pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x0000019FF7371640>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>> pylab.show()
+```
+
+![](Ris1.png)
+
+```py
+>>> X1=[12,6,8,10,7]; X2=[5,7,9,11,13]
+>>> pylab.plot(X1); pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000019FFB0C0C40>]
+[<matplotlib.lines.Line2D object at 0x0000019FFB0C0F40>]
+>>> pylab.show()
+```
+
+![](Ris2.png)
+
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x0000019FFB283E20>, <matplotlib.patches.Wedge object at 0x0000019FFB283EE0>, <matplotlib.patches.Wedge object at 0x0000019FFB2AB100>, <matplotlib.patches.Wedge object at 0x0000019FFB2AB580>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()
+```
+![](Ris3.png)
+
+```py
+>>> X0 = [1,1,2,2,2,3,3,3,4,4,5]
+>>> pylab.hist(X0,5)
+(array([2., 3., 3., 2., 1.]), array([1. , 1.8, 2.6, 3.4, 4.2, 5. ]), <BarContainer object of 5 artists>)
+>>> pylab.show()
+```
+
+![](Ris4.png)
+
+```py
+>>> x0 = ['a','b','c']
+>>> x10 = [123,321,112]
+>>> pylab.bar(x0,x10)
+<BarContainer object of 3 artists>
+>>> pylab.show()
+```
+
+![](Ris5.png)
+
+
+## 8.Модуль statistics.
+
+```py 
+>>> import statistics
+>>> s = [123, 49, 3, 16, 8, 10, 9]
+>>> statistics.mean(s) # среднее
+31.142857142857142
+>>> statistics.median(s) # медиана
+10
+>>> statistics.stdev(s) # стандартное отклонение
+43.30291973000039
+>>> statistics.variance(s) # дисперсия
+1875.1428571428573
+>>> s1 = [123, 49, 3, 3, 3, 16, 8, 8, 10, 9]
+>>> statistics.mode(s1) # мода
+3
+```
+
+## 9.Завершение работы со средой.

TEMA4/task.md

@@ -0,0 +1,80 @@
+## Общее контрольное задание по Теме 4
+
+Кузьменко Елена, А-02-23
+
+## Задание
+
+   1)Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+
+   2)Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+   3)Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+
+   4)Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+   5)Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+   6)Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+   
+
+## Решение
+
+### 1.Исполнение выражения.
+
+```py
+>>> import math
+>>> import cmath
+>>> divmod(math.floor(round(cmath.phase( 0.2+0.8j ), 2)) * 20), 3)
+(8, 2)
+```
+
+### 2.Объект с временными параметрами.
+
+```py
+>>> import time
+>>> t = time.gmtime(time.time() + 3 * 3600); t
+>>> time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=10, tm_min=36, tm_sec=20, tm_wday=0, tm_yday=293, tm_isdst=0)
+>>> print('часов: ' + str(t.tm_hour) + '\nминут: ' + str(t.tm_min))
+>>> часов: 10
+>>> минут: 36
+```
+
+### 3.Список.Случайная выборка.
+
+```py
+>>> import random
+>>> days = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+>>> v = random.sample(days,3); v
+['Понедельник', 'Четверг', 'Пятница']
+```
+
+### 4.Случайный выбор чисел из последовательности.
+
+```py
+>>> r1 = random.choice(list(range(14, 32, 3))); r1
+17
+```
+
+### 5.Нормальное распределение.Список с латинскими буквами.
+
+```py
+>>> n = round(random.gauss(15,4)); n
+10
+>>> alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+>>> l = random.sample(alphabet * n, n); l
+['K', 'I', 'B', 'I', 'L', 'D', 'W', 'O', 'Q', 'X']
+```
+
+### 6.Временной интервал в минутах.
+
+```py
+>>> t2 = time.gmtime(time.time() + 3 * 3600); t2
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=10, tm_min=37, tm_sec=53, tm_wday=0, tm_yday=293, tm_isdst=0)
+>>> t_2 = (t2.tm_hour*3600+t2.tm_min*60+t2.tm_sec); t_2
+38273
+>>> t_1 = (t.tm_hour*3600+t.tm_min*60+t.tm_sec); t_1
+38180
+>>> t_3 = math.floor((t_2 - t_1)/60); t_3
+1
+```
+

TEMA4/test.md

@@ -0,0 +1,45 @@
+# Индивидуальные контрольные задания по Теме 4
+
+Кузьменко Елена, А-02-23
+
+## Задание Вариант 6
+
+1)Создайте переменную с календарными сведениями для текущего момента времени и выведите информацию в виде строки «Текущая дата: <день>-<месяц>-<год>». 
+
+2)Создайте объект со значением 5-2j. 
+
+3)Извлеките из него квадратный корень с записью результата в новый объект. Эту операцию выполните с использованием функции exec.
+
+
+## Решение
+
+### 1)Переменная с календарными сведениями
+
+```py
+import time
+
+>>> t = time.localtime(); t #переменная, хранящая календарные данные
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=11, tm_min=43, tm_sec=7, tm_wday=0, tm_yday=293, tm_isdst=0)
+
+>>> print(f"Текущая дата: {t.tm_mday}-{t.tm_mon}-{t.tm_year}")
+Текущая дата: 20-10-2025
+```
+
+### 2)Создание объекта
+
+```py
+>>> a = 5-2j; a #создаваемый объект
+(5-2j)
+>>> type(a)
+<class 'complex'>
+```
+
+### 3)Квадратный корень с результатом в новый объект(использование exec())
+
+```py
+>>> import cmath
+
+>>> exec("a1 = cmath.sqrt(a)") 
+>>> a1 #новый объект
+(2.27872385417085-0.4388421169022545j)
+```

TEMA5/report.md

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

TEMA5/task.md

@@ -0,0 +1,90 @@
+## Общее контрольное задание по Теме 5
+
+Кузьменко Елена, А-02-23
+
+## Задание
+
+	Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+	
+	1)Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+	
+	2)Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+	
+	3)Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+
+### 1)Определение порядкового номера каждой буквы.
+```py
+>>> str1 = "python"
+>>> alphabet = "abcdefghijklmnopqrstuvwxyz"
+>>> for i in str1:
+	if i in alphabet:
+		num = alphabet.index(i) + 1
+		print('В алфавите буква ',i,' под номером ',num)
+	else: continue
+
+	
+В алфавите буква  p  под номером  16
+В алфавите буква  y  под номером  25
+В алфавите буква  t  под номером  20
+В алфавите буква  h  под номером  8
+В алфавите буква  o  под номером  15
+В алфавите буква  n  под номером  14
+```
+
+### 2)Наличие и отсутствие элемента в списке.
+
+```py
+>>> str2 = """Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом)."""
+>>> spis2 = str2.split(); spis2
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта.', 'Для', 'этого', 'списка', '–', 'определите,', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение,', 'и', 'выведите', 'соответствующее', 'сообщение:', 'либо', 'о', 'нахождении', 'элемента,', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', '(проверить', 'как', 'с', 'имеющимся,', 'так', 'и', 'с', 'отсутствующим', 'словом).']
+>>> words = ["словами","значения"]
+>>> i = 0
+>>> while i < len(words): #i - слово 1 и 2
+	word = words[i]
+	j = 0
+	while j < len(spis2):
+		if spis2[j] == word:
+			print('В списке нашелся элемент \"',word,'\"')
+			break
+		j += 1
+	else:
+		print('В списке элемент \"',word,'\" отсутствует')
+	i += 1 #переход ко второму слову в  words
+
+	
+В списке нашелся элемент " словами "
+В списке элемент " значения " отсутствует
+```
+
+### 3)Инструкция вывода среднего балла по заданной фамилии.
+
+```py
+>>> stud = ['Кузьменко','Криви','Добровольска','Беженарь']
+>>> grade = [4.6, 4.5, 4.7, 4.9]
+>>> stud1 = ['Добровольска','Беженарь','Криви','Кузьменко']
+>>> grade1 = [4.8, 5.0, 4.7, 4.7]
+>>> choice = input('Фамилия студента: ')
+Фамилия студента: Кузьменко
+>>> grade0 = 0
+>>> for i in range(len(stud)):
+	if stud[i] == choice:
+		grade0 = grade[i]
+		break
+
+	
+>>> print('Средний балл летней сессии: ',grade0)
+Средний балл летней сессии:  4.6
+>>> choice1 = input('Фамилия студента: ')
+Фамилия студента: Добровольска
+>>> grade3 = 0
+>>> for j in range(len(stud1)):
+	if stud1[i] == choice1:
+		grade3 = grade1[i]
+		break
+
+	
+>>> print('Средний балл зимней сессии: ',grade3)
+Средний балл зимней сессии:  4.8
+```

TEMA5/test.md

@@ -0,0 +1,44 @@
+# Индивидуальные контрольные задания по Теме 5
+
+Кузьменко Елена, А-02-23
+
+## Задание Вариант 9
+
+    1) Напишите инструкции создания списка с 20 случайными нормально распределенными (математическое ожидание равно -50, дисперсия равна 64) числами. 
+    2) Из этого списка перепишите в другой список только те элементы, которые не превышают среднего значения.
+
+
+## Решение
+
+### 1)Создание списка
+
+```py
+>>> import random
+>>> spis = []
+>>> summ = 0
+>>> for i in range(20):
+...     x = random.gauss(-50,8) #мат.ожидание и СКО
+...     spis.append(x)
+...     summ = summ + x # сразу подсчитываем сумму для следующей части задания
+... 
+...     
+>>> spis
+[-29.24990883377405, -66.00956281807862, -37.69197663256578, -41.91527682163312, -47.21737152973387, -58.786326814361516, -48.845960766508654, -55.84484894086587, -56.503043081539516, -44.59534499265938, -54.60842719739839, -58.778230407514954, -55.850279016898185, -61.0993191141376, -51.74459946755947, -49.20286936852757, -41.115164755690316, -33.58366320198999, -47.0982943955007, -45.86096806160354]
+>>> summ
+-985.6014362185412
+```
+
+### 2)Новый список(с условием: элементы не превышают среднее значение)
+
+```py
+>>> sred = summ / len(spis); sred
+-49.280071810927055 # среднее значение
+>>> spis2 = []
+>>> for el in spis:
+...     if el <= sred:
+...         spis2.append(el)
+... 
+...              
+>>> spis2 # новый список
+[-66.00956281807862, -58.786326814361516, -55.84484894086587, -56.503043081539516, -54.60842719739839, -58.778230407514954, -55.850279016898185, -61.0993191141376, -51.74459946755947]
+```

TEMA6/report.md

@@ -0,0 +1,553 @@
+# Отчёт по Теме 6
+
+Кузьменко Елена, А-02-23
+
+## 1. Запустили интерактивную оболочку IDLE.
+
+## 2. Вывод данных на экран дисплея.
+
+### 2.1. Вывод в командной строке.
+
+```py
+>>> stroka = 'Автоматизированная система управления'; stroka # эхо-вывод
+'Автоматизированная система управления' 
+```
+
+### 2.2. Вывод с использованием функции print().
+
+Обычный вывод:
+
+```py
+>>> fff = 234.5; gg = 'Значение температуры = '
+>>> print(gg, fff)
+Значение температуры =  234.5
+```
+
+Помимо пробела разделителем могут служить другие знаки, используя команду sep:
+
+```py
+>>> print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+
+Если курсор надо оставить в той же строке(не переходить на след. строку), потребуется использовать ещё один аргумент. Например, с помощью end укажем конец строки(какими символами она должна заканчиваться) или можно указать пустую строку:
+
+```py
+>>> print(gg, fff, sep = '/', end = '***'); print('____')
+Значение температуры = /234.5***____
+```
+
+С помощью print() можно перейти на новую строку:
+
+```py
+>>> print(gg, fff, sep = '/', end = '***'); print(); print(gg)
+Значение температуры = /234.5***
+Значение температуры = 
+```
+
+Оператор вывода на нескольких строках:
+
+```py
+>>> print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+```
+
+Или
+
+```py
+>>> print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+Тройные кавычки оставляют перенос строки(выводит текст в несколько строк), когда как несколько аргументов print() записываются в одну строку через разделитель.
+
+### 2.3. Использование метода write объекта sys.stdout.
+
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы выводят символьное представление данных.
+
+```py
+>>> import sys
+>>> sys.stdout.write('Функция write')
+Функция write13
+```
+
+Метод sys.stdout.write() выводит строку без автоматического перевода на новую строку (в отличие от print()), из чего следует добавить один или несколько символов "\n":
+
+```py
+>>> sys.stdout.write('Функция write\n')
+Функция write
+14
+``` 
+
+Также можно заметить, что при вызове sys.stdout.write() печатается не только аргумент функции, но и некоторое число, отвечающее за количество успешно записанных символов.
+
+## 3. Ввод данных с клавиатуры.
+
+Для ввода используется функция input:
+
+```py
+>>> psw = input('Введите пароль:')
+Введите пароль:gugugaga
+>>> psw
+'gugugaga'
+>>> type(psw)
+<class 'str'>
+```
+
+#### Пример 1.Ввод и контроль контроль значения в цикле while.
+
+```py
+>>> while True:
+	znach = float(input('Задайте коэф.усиления = '))
+	if znach < 17.5 or znach > 23.8:
+		print('Ошибка!')
+	else:
+		break
+
+	
+Задайте коэф.усиления = 10.1
+Ошибка!
+Задайте коэф.усиления = 31.0
+Ошибка!
+Задайте коэф.усиления = 18.9
+>>> 
+```
+
+#### Пример 2.Ввод и обрабтка выражения eval().
+
+```py
+>>> import math
+>>> print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## 4.Ввод-вывод при работе с файлами.
+
+### 4.1.Функция для работы с путём файла.
+
+Чтобы узнать текущий рабочий каталог используется функция os.getcwd (cwd = current working directory)
+
+```py
+>>> import os
+>>> os.getcwd() # пути разделяются двойными обратными слэшами \\
+'C:\\Users\\Admin\\AppData\\Local\\Programs\\Python\\Python39'
+>>> os1 = os.getcwd(); print(os1) # пути разделются \
+C:\Users\Admin\AppData\Local\Programs\Python\Python39
+```
+
+Смена рабочего каталога:
+
+```py
+>>> os.chdir('C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6')
+>>> os.getcwd()
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6'
+```
+
+#### Самостоятельно:
+
+os.mkdir() - создание нового каталога:
+
+```py
+>>> os.mkdir('help')
+>>> os.chdir('help'); os.getcwd()
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\help'
+```
+
+os.listdir() - список каталогов и файлов в текущем рабочем каталоге.
+
+```py
+>>> os.chdir('../'); os.getcwd()
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6'
+>>> os.listdir()
+['.gitkeep', 'help', 'report.md', 'task.md']
+```
+
+os.rmdir() - удаление каталога.
+
+```py
+>>> os.rmdir('help'); os.listdir()
+['.gitkeep', 'report.md', 'task.md']
+```
+
+os.path.isdir() - проверка наличия каталога.
+
+```py
+>>> os.mkdir('test'); os.listdir()
+['.gitkeep', 'report.md', 'task.md', 'test']
+>>> os.path.isdir('tast.md')
+False # не является каталогом
+>>> os.path.isdir('help')
+False # отсутствие каталога
+>>> os.path.isdir('test')
+True
+```
+
+Путь до файла report.md с помощью функции os.path.abspath():
+
+```py
+>>> fil = os.path.abspath("report.md"); fil
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\report.md'
+```
+
+Пусть в каталоге есть файла oplata.dbf:
+
+```py
+>>> fil = os.path.abspath("oplata.dbf"); fil
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\oplata.dbf'
+```
+
+Извлечем путь каталога из "абсолютного" пути с помощью функции os.path.dirname():
+
+```py
+>>> drkt = os.path.dirname(fil); drkt
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6'
+```
+
+Наоборот, отобразим название файла из абсолютного пути с помощью функции os.path.basename():
+
+```py
+>>> bsn = os.path.basename(fil); bsn
+'oplata.dbf'
+```
+
+os.path.split() позволяет работать с директорией и именем файла в пути, создавая кортеж:
+
+```py
+>>> os.path.split(fil)
+('C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6', 'oplata.dbf')
+```
+
+os.path.exists(fil) проверяет наличие объекта с известным расположением:
+
+```py
+os.path.exists(fil)       
+True
+fil1=drkt + '\\katalog1'; print(fil1)        
+C:\Users\Admin\Desktop\python-labs\TEMA6\katalog1
+os.path.exists(fil1)       
+False
+
+```
+Провека наличия файла с известным расположением с помощью функции os.path.isfile():
+
+```py
+>>> fil
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\oplata.dbf'
+>>> os.path.isfile(fil)
+False
+```
+
+### 4.2. Общая схема работы с файлом.
+
+Для обмена данными с файлом необходимо выполнить следующие операции:
+	• Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+	• Выполнение одной или нескольких операций обмена данными с файлом;
+	• Закрытие файла.
+
+### 4.3. Функция open() - открытия файла.
+
+Откроем файл zapis1.txt для записи данных с помощью функции open():
+
+```py
+>>> fp = open(file = drkt + '\\zapis1.txt', mode=  'w')
+>>> fp
+<_io.TextIOWrapper name='C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
+>>> type(fp); dir(fp)
+<class '_io.TextIOWrapper'> # для работы с текстовыми данными
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+```
+
+fp – это файловый объект, который в других языках программирования обычно называют файловой переменной. Он сохраняет ссылку на открываемый файл и позволяет в дальнейшем ссылаться на файл, не указывая путь и имя открытого файла.
+
+В аргумент mode записывается операция, используемая с файлом:
+
+	1) r – только чтение (это значение - по умолчанию)
+	2) w – запись с созданием нового файла или перезапись существующего файла
+	3) a - запись в конец существующего файла или, если его нет, запись с созданием файла,
+
+Существуют комбинированные операции: 
+
+	1) r+ - чтение и/или запись в существующий файл
+	2) w+ - чтение и запись/перезапись файла
+	3) a+ - то же, что и в «a», но с возможностью чтения из файла
+
+Если имя файла на месте первого аргумента, а операция на втором, то можно записывать без имён:
+
+```py
+>>> fp = open('zapis1.txt','w'); fp
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
+>>> fp = open(drkt + '\\zapis1.txt', 'w'); fp
+<_io.TextIOWrapper name='C:\\Users\\Admin\\Desktop\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
+```
+
+Файлы могут быть бинарными или символьными. При открытии бинарного файла к аргументу-цели добавляется "b":
+
+```py
+>>> fp1 = open(drkt + '\\zapis2.bin', mode = 'wb+')
+```
+
+В символьный файл можно записывать только объекты типа str, для других типов обозначается "t".
+
+### 4.4. Закрытие файла. Метод close().
+
+Сохранность файла после завершения работы с ним обеспечивается, например, с помощью метода close():
+
+```py
+>>> fp.close()
+```
+
+### 4.5. Запись информации в файл. Метод write().
+
+```py
+>>> sps = list(range(1,13))
+>>> fp2 = open('zapis3.txt','w')
+>>> fp2.write(str(sps[:4])+'\n')
+13 # количество записанных символов 12 "[1, 2, 3, 4]" + 1 перенос "\n"
+>>> fp2.write(str(sps[4:8])+'\n')
+13
+>>> fp2.write(str(sps[8:])+'\n')
+16
+>>> fp2.close()
+```
+
+Содержимое файла zapis3.txt:
+
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+#### Пример со списком.
+
+```py
+>>> sps3 = [['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]; sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+
+Попытка первая:
+
+```py
+>>> fp3 = open('zapis4.txt', 'w')
+for i in range(len(sps3)):
+	stroka4=sps3[i][0]+' '+str(sps3[i][1])
+	fp3.write(stroka4)
+>>> for i in range(len(sps3)):
+	stroka4=sps3[i][0]+' '+str(sps3[i][1])
+	fp3.write(stroka4)
+
+	
+11
+11
+12
+>>> fp3.close()
+```
+
+Содержимое файла zapis3.txt:
+
+```py
+Иванов И. 1Петров П. 2Сидоров С. 3
+```
+
+Вторая попытка с добавлением переноса строки:
+
+```py
+>>> gh = open('zapis5.txt', 'w')
+>>> for r in sps3:
+		gh.write(r[0]+' '+str(r[1])+'\n')
+
+		
+12
+12
+13
+>>> gh.close()
+```
+
+Содержимое файла zapis5.txt:
+
+```py
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+
+Запись в одной строке:
+
+```py
+>>> gh1 = open('zapis6.txt','w')
+>>> for r in sps3: gh1.write(r[0] + ' ' + str(r[1]) + '\n')
+
+12
+12
+13
+>>> gh1.close()
+```
+
+Содержимое файла zapis6.txt:
+
+```py
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+
+### 4.6. Первый способ чтения информации из текстового файла.
+
+```py
+>>> sps1 = []
+>>> fp = open('zapis3.txt')
+>>> for stroka in fp:
+	stroka=stroka.rstrip('\n') # rstrip() - удаляется символ конца строки
+	stroka=stroka.replace('[','')
+	stroka=stroka.replace(']','')
+	sps1=sps1+stroka.split(',')
+
+	
+>>> fp.close()
+>>> sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+>>> sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+Список sps1 содержит элементы строкового типа, а в sps целочисленного. Преобразуем:
+
+```py
+>>> sps3 = list(map(int,sps1)); sps3
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+### 4.7. Чтение информации из файла. Метод read().
+
+Содержание файла zapis3.txt:
+
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+```py
+>>> fp = open('zapis3.txt')
+>>> stroka1 = fp.read(12) # читает первые 12 элементов, маркер на 13-м
+>>> stroka2 = fp.read() # считывает оставшиеся
+>>> stroka1; stroka2
+'[1, 2, 3, 4]'
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+>>> fp.close()
+```
+
+### 4.8. Методы readline и readlines.
+
+```py
+>>> fp = open('zapis3.txt')
+>>> st1 = fp.readline() # прочитает одну строку символов(или совокупность байт для бинарного)
+>>> st2 = fp.readlines() # прочитает все строки(все байты)
+>>> fp.close()
+>>> st1; st2
+'[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()
+```
+
+Содержимое файла zapis6.mnz:
+
+	Ђ•#       Џ”(Њtable”Њpen”ЊiPhone”Њbook”ђ.
+
+Прочтение файла выводит такой же результат, какой был при записывании:
+
+```py
+>>> fp = open('zapis6.mnz','rb')
+>>> mnoz2 = pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+>>> fp.close()
+>>> mnoz2
+{'table', 'pen', 'iPhone', 'book'}
+>>> mnoz1 == mnoz2
+True
+```
+
+При считываении файла объекты извлекаются в той в же последовательности, в которой были записаны в файл:
+
+```py
+>>> fp = open('zapis7.2ob','wb')
+>>> pickle.dump(mnoz1,fp)
+>>> pickle.dump(sps3,fp)
+>>> fp.close()
+>>> 
+>>> fp = open('zapis7.2ob','rb')
+>>> obj1 = pickle.load(fp)  # первое обращение к load читает первый объект
+>>> obj2 = pickle.load(fp)  # второе – читает второй
+>>> fp.close()
+>>> obj1; obj2
+{'table', 'pen', 'iPhone', 'book'}
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+>>> obj1 == mnoz1; obj2 == sps3
+True
+True
+```
+
+## 5. Перенаправление протоколов вода и вывода данных.
+
+```py
+>>> import sys
+>>> vr_out = sys.stdout # запоминаем текущий поток вывода
+>>> fc = open('Stroka.txt','w')
+>>> sys.stdout = fc # перенаправляем стандартный поток вывода на файл
+>>> print('запись строки в файл') # вывод в файл
+>>> sys.stdout = vr_out # восстановление текущего потока
+>>> print('запись строки на экран')
+запись строки на экран
+>>> fc.close()
+```
+
+Содержимое файла Stroka.txt:
+
+	запись строки в файл
+
+Таким же образом организуем поток ввода:
+
+```py
+>>> tmp_in = sys.stdin
+>>> fd = open("Stroka.txt", "r")
+>>> sys.stdin = fd
+>>> sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+>>> while True:
+	try:
+		line = input() # считываем из файла строку
+		print(line)  # отображаем считанное
+	except EOFError: # когда файл закончился - выходим
+		break
+
+	
+запись строки в файл
+>>> fd.close()
+>>> sys.stdin=tmp_in # возвращаем стандартное назначение для потока ввода
+```
+
+## 6. Завершение сеанса работы с IDLE.
+
+
+
+
+
+
+

TEMA6/task.md

@@ -0,0 +1,113 @@
+## Общее контрольное задание по Теме 6
+
+Кузьменко Елена, А-02-23
+
+## Задание
+
+	Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+
+	1) Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+	2) Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+	3) Записывается кортеж в бинарный файл.
+	4) Записывается в этот же файл список и закрывается файл.
+	5) Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+	6) Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+	7) Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Решение
+
+### 1.Объект-кортеж
+
+```py
+>>> import random
+>>> k = []
+>>> for i in range(125):
+    k.append(str(random.randint(6, 56)))
+
+    
+>>> k1 = tuple(k); k1
+('48', '24', '44', '42', '31', '43', '29', '34', '27', '36', '8', '27', '26', '47', '55', '30', '19', '38', '40', '36', '39', '37', '44', '31', '50', '38', '17', '6', '49', '42', '8', '28', '38', '22', '18', '37', '12', '7', '9', '8', '32', '28', '47', '13', '24', '7', '41', '54', '17', '11', '18', '26', '54', '34', '50', '7', '24', '39', '53', '14', '23', '54', '28', '56', '43', '27', '8', '44', '21', '50', '36', '12', '14', '55', '19', '48', '13', '43', '6', '21', '54', '12', '38', '38', '8', '35', '14', '25', '38', '56', '42', '17', '46', '15', '31', '14', '36', '12', '30', '35', '53', '27', '45', '28', '6', '25', '55', '51', '15', '46', '45', '24', '49', '53', '27', '22', '34', '23', '45', '34', '24', '24', '36', '42', '50')
+>>> len(k1)
+125
+```
+
+### 2.Объект-список с фамилиями
+
+```py
+>>> spis = ['Кузьменко','Беженарь','Добровольска','Криви']; spis
+['Кузьменко', 'Беженарь', 'Добровольска', 'Криви']
+```
+
+### 3-4.Кортеж и список в бинарный файл 
+
+```py
+>>> import pickle
+>>> fp = open('task1.mnz','wb')
+>>> pickle.dump(k1, fp)
+>>> pickle.dump(spis, fp)
+>>> fp.close()
+```
+
+Содержимое файла task.mnz:
+
+	Ђ•i      (Њ48”Њ24”Њ44”Њ42”Њ31”Њ43”Њ29”Њ34”Њ27”Њ36”Њ
8”Њ27”Њ26”Њ47”Њ55”Њ30”Њ19”Њ38”Њ40”Њ36”Њ39”Њ37”Њ44”Њ31”Њ50”Њ38”Њ17”Њ
6”Њ49”Њ42”Њ
8”Њ28”Њ38”Њ22”Њ18”Њ37”Њ12”Њ
7”Њ
9”Њ
8”Њ32”Њ28”Њ47”Њ13”Њ24”Њ
7”Њ41”Њ54”Њ17”Њ11”Њ18”Њ26”Њ54”Њ34”Њ50”Њ
7”Њ24”Њ39”Њ53”Њ14”Њ23”Њ54”Њ28”Њ56”Њ43”Њ27”Њ
8”Њ44”Њ21”Њ50”Њ36”Њ12”Њ14”Њ55”Њ19”Њ48”Њ13”Њ43”Њ
6”Њ21”Њ54”Њ12”Њ38”Њ38”Њ
8”Њ35”Њ14”Њ25”Њ38”Њ56”Њ42”Њ17”Њ46”Њ15”Њ31”Њ14”Њ36”Њ12”Њ30”Њ35”Њ53”Њ27”Њ45”Њ28”Њ
6”Њ25”Њ55”Њ51”Њ15”Њ46”Њ45”Њ24”Њ49”Њ53”Њ27”Њ22”Њ34”Њ23”Њ45”Њ34”Њ24”Њ24”Њ36”Њ42”Њ50”t”.Ђ•U       ]”(ЊКузьменко”ЊБеженарь”ЊДобровольска”Њ
+РљСЂРёРІРё”e.
+
+### 5.Считывание данных в 2 новых объекта
+
+```py
+>>> fp = open('task1.mnz','rb')
+>>> k2 = pickle.load(fp)
+>>> spis2 = pickle.load(fp)
+>>> fp.close()
+>>> k2; spis2
+('48', '24', '44', '42', '31', '43', '29', '34', '27', '36', '8', '27', '26', '47', '55', '30', '19', '38', '40', '36', '39', '37', '44', '31', '50', '38', '17', '6', '49', '42', '8', '28', '38', '22', '18', '37', '12', '7', '9', '8', '32', '28', '47', '13', '24', '7', '41', '54', '17', '11', '18', '26', '54', '34', '50', '7', '24', '39', '53', '14', '23', '54', '28', '56', '43', '27', '8', '44', '21', '50', '36', '12', '14', '55', '19', '48', '13', '43', '6', '21', '54', '12', '38', '38', '8', '35', '14', '25', '38', '56', '42', '17', '46', '15', '31', '14', '36', '12', '30', '35', '53', '27', '45', '28', '6', '25', '55', '51', '15', '46', '45', '24', '49', '53', '27', '22', '34', '23', '45', '34', '24', '24', '36', '42', '50')
+['Кузьменко', 'Беженарь', 'Добровольска', 'Криви']
+```
+
+### 6.Проверка на совпадение
+
+```py
+>>> print('Кортежи совпадают') if k1 == k2 else print('Кортежи не совпадают')
+Кортежи совпадают
+>>> print('Списки совпадают') if spis == spis2 else print('Списки не совпадают')
+Списки совпадают
+```
+
+### 7.Кортеж на совокупности
+
+```py
+>>> for i in range(0, len(k1), 5): # 0, 5, 10, ... , 120
+	exec(f'spis{i//5} = list(k1[i:i + 5])') # индексы 0,1, ..., 24 и срез 5 эл-в: 0-4, 5-9,...
+
+	
+>>> for i in range(len(k1) // 5): # 25
+	exec(f'print("spis" + str(i) + ":", spis{i})')
+
+	
+spis0: ['48', '24', '44', '42', '31']
+spis1: ['43', '29', '34', '27', '36']
+spis2: ['8', '27', '26', '47', '55']
+spis3: ['30', '19', '38', '40', '36']
+spis4: ['39', '37', '44', '31', '50']
+spis5: ['38', '17', '6', '49', '42']
+spis6: ['8', '28', '38', '22', '18']
+spis7: ['37', '12', '7', '9', '8']
+spis8: ['32', '28', '47', '13', '24']
+spis9: ['7', '41', '54', '17', '11']
+spis10: ['18', '26', '54', '34', '50']
+spis11: ['7', '24', '39', '53', '14']
+spis12: ['23', '54', '28', '56', '43']
+spis13: ['27', '8', '44', '21', '50']
+spis14: ['36', '12', '14', '55', '19']
+spis15: ['48', '13', '43', '6', '21']
+spis16: ['54', '12', '38', '38', '8']
+spis17: ['35', '14', '25', '38', '56']
+spis18: ['42', '17', '46', '15', '31']
+spis19: ['14', '36', '12', '30', '35']
+spis20: ['53', '27', '45', '28', '6']
+spis21: ['25', '55', '51', '15', '46']
+spis22: ['45', '24', '49', '53', '27']
+spis23: ['22', '34', '23', '45', '34']
+spis24: ['24', '24', '36', '42', '50']
+```

TEMA6/test.md

@@ -0,0 +1,112 @@
+# Индивидуальное контрольное задание по Модулю 2
+
+Кузьменко Елена, А-02-23, Вариант 8
+
+## Задание
+
+    1)	Создайте множество с 40 элементами - случайными  числами, равномерно распределенными на интервале от -20 до +10. Числа должны быть округлены до двух знаков после точки.
+    2)	Запросите у пользователя и введите имя бинарного файла для сохранения множества. Если во введенном имени есть пробелы, замените их на пустые строки.
+    3)	Запишите множество в бинарный файл с указанным именем.
+    4)	Удалите из памяти созданное множество.
+    5)	Прочитайте множество из файла и рассчитайте по его элементам среднее значение. Отобразите его на экране по шаблону: " По <число элементов> среднее = <рассчитанное значение>". Выводимое среднее округлить до двух знаков после точки.
+
+## Решение
+
+### 1) Создание множества с 40 элементами.
+
+```py
+>>> import random
+>>> import pickle
+>>> import os
+
+>>> os.chdir('C:\\Users\\u522-15\\Desktop\\TestModule2')
+>>> os.getcwd()
+'C:\\Users\\u522-15\\Desktop\\TestModule2'
+
+>>> mnoz = set()
+>>> while True: # проверка, что элементы множества = 40(из-за особенности удалять повторения)
+...     mnoz.clear()
+...     for i in range(40):
+...         s = round(random.uniform(-20, 10), 2)
+...         mnoz.add(s)
+...     if len(mnoz) == 40:
+...         break  
+...
+...      
+>>> mnoz
+{-0.71, 1.68, 2.38, 2.86, 4.56, 5.13, 6.64, 3.27, 6.79, 1.46, 2.3, 4.81, 5.11, 6.63, -3.58, -19.31, -5.56, -5.11, -5.3, -0.15, -11.07, -19.83, -18.65, -17.23, -17.11, -16.6, -14.61, -16.77, -13.11, -12.84, -10.52, -9.94, -10.63, -7.34, -10.91, -5.93, -4.67, -3.36, -2.28, -10.71}
+>>> len(mnoz)
+40
+>>> type(mnoz)
+<class 'set'>
+```
+
+### 2) Запрос на введения имени бинарного файла. Замена пробелов.
+
+```py
+>>> filename = input('Введите имя бинарного файла: ').replace(" ", "")
+Введите имя бинарного файла: binn n.mnz
+>>> filename
+'binnn.mnz'
+```
+
+
+### 3) Запись множества в бинарный файл.
+
+```py
+>>> fp = open(filename, 'wb')
+>>> pickle.dump(mnoz, fp)
+>>> fp.close()
+```
+
+#### Содержимое файла binnn.mnz:
+
+    Ђ•m
      Џ”(GїжёQл…ёG?ъбG®zбG@
+    =pЈЧ
+    G@бG®zбG@=pЈЧ
+    =G@…ёQл…G@Џ\(хВЏG@
+    (хВЏ\)G@(хВЏ\)G?ч\(хВЏ\G@ffffffG@=pЈЧ
+    =G@pЈЧ
+    =qG@…ёQл…GАЈЧ
+    =p¤GА3O\(хВЏGА=pЈЧ
+    =GАpЈЧ
+    =qGА333333GїГ333333GА&#Ч
+    =p¤GА3ФzбG®GА2¦fffffGА1:бG®{GА1(хВЏ\GА0™™™™™љGА-8Qл…ёGА0ЕёQл…GА*8Qл…ёGА)®zбG®GА%
+    =pЈЧ
+    GА#бG®zбGА%BЏ\(хГGА\(хВЏ\GА%Сл…ёRGАёQл…ёGА®zбG®GА
+    бG®zбGА=pЈЧ
+    =GА%k…ёQмђ.
+
+
+### 4) Удаление созданного множества из памяти.
+
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'filename', 'fp', 'i', 'mnoz', 'num', 'os', 'pickle', 'random', 'x']
+>>> del mnoz
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'filename', 'fp', 'i', 'num', 'os', 'pickle', 'random', 'x']
+>>> mnoz
+Traceback (most recent call last):
+  File "<pyshell#101>", line 1, in <module>
+    mnoz
+NameError: name 'mnoz' is not defined
+```
+
+
+### 5) Чтение множества и расчет среднего значения.
+
+```py
+>>> fp = open(filename, 'rb')
+>>> l = pickle.load(fp)
+>>> fp.close()
+>>> l
+{-0.71, 1.68, 2.38, 2.86, 4.56, 5.13, 6.64, 3.27, 6.79, 1.46, 2.3, 4.81, 5.11, 6.63, -5.3, -5.56, -0.15, -3.36, -9.94, -7.34, -5.93, -19.31, -19.83, -18.65, -17.23, -17.11, -16.6, -14.61, -16.77, -11.07, -13.11, -12.84, -10.52, -10.63, -10.91, -5.11, -4.67, -3.58, -2.28, -10.71}
+>>> type(l)
+<class 'set'>
+
+>>> sred = round((sum(l) / len(l)),2); sred
+-5.51
+>>> print(f"По {len(l)} элементам среднее = {sred}")
+По 40 элементам среднее = -5.51
+```

TEMA7/report.md

@@ -0,0 +1,626 @@
+# Отчёт по Теме 7
+
+Кузьменко Елена, А-02-23
+
+## 1. Запустили интерактивную оболочку IDLE. 
+
+Задали рабочий каталог:
+
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\Admin\\Desktop\\python-labs\\TEMA7')
+>>> os.getcwd()
+'C:\\Users\\Admin\\Desktop\\python-labs\\TEMA7'
+```
+
+## 2. Пользовательская функция.
+
+	Создание функции предполагает выполнение трех операций: формирование функции, ее сохранение и использование. 
+	В общем виде функция в языке Python представляется так:
+	def  <Имя функции>([<Список аргументов >]):
+	[<отступы>"""<Комментарий по назначению функции>"""]
+	<отступы><Блок инструкций – тело функции>
+	[<отступы>return <Значение или вычисляемое выражение>]
+
+### 2.1. Функция без аргументов.
+
+```py
+>>> def uspeh():
+	"""Подтверждение успеха операции"""
+	print('Выполнено успешно!')
+
+	
+>>> uspeh()
+Выполнено успешно!
+
+>>> type(uspeh)
+<class 'function'>
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+```
+Помощь по созданной функции:
+
+```py
+>>> help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+	__main__ — функция создана в основном выполняемом скрипте(модуль main).
+
+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
+```
+
+Функцию можно выполнить с аргументами - символьными строками: 
+
+```py
+>>> sravnenie("abc", "ABC")
+abc  больше  ABC
+```
+
+	Здесь сравниваются первые символы 'a' и 'A', которые читаются в соответсвие с кодами символов в Unicode/ASCII - 97 и 65(97>65)
+
+### 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
+```
+
+	Функция return позволяет возвращать определенные значения.
+
+### 2.4. Сложение для разных типов аргументов.
+
+```py
+>>> def slozh(a1,a2,a3,a4):
+	""" Сложение значений четырех аргументов"""
+	return a1+a2+a3+a4
+
+>>> slozh(1,2,3,4)   # Сложение чисел
+10
+>>> slozh('1','2','3','4')  # Сложение строк
+'1234'
+>>> b1 = [1,2]; b2 = [-1,-2]; b3 = [0,2]; b4 = [-1,-1]
+>>> q = slozh(b1,b2,b3,b4)  #Сложение списков
+>>> q
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+Применение функции slozh() для сложения кортежей, словарей и множеств:
+
+```py
+>>> slozh((1,2),(4,5),(0,3),(1,1)) # Сложение кортежей
+(1, 2, 4, 5, 0, 3, 1, 1)
+
+>>> slozh({"A": 1, "A1": 2}, {"B": 3, "B1": 4}, {"C": 5, "C1": 6}, {"D": 7, "D1": 8}) # Сложение словарей
+Traceback (most recent call last):
+  File "<pyshell#31>", line 1, in <module>
+    slozh({"A": 1, "A1": 2}, {"B": 3, "B1": 4}, {"C": 5, "C1": 6}, {"D": 7, "D1": 8})
+  File "<pyshell#18>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+
+>>> slozh({1,2,3},{0,1,2},{4,6,7},{10,11,12}) # Сложение множеств
+Traceback (most recent call last):
+  File "<pyshell#32>", line 1, in <module>
+    slozh({1,2,3},{0,1,2},{4,6,7},{10,11,12})
+  File "<pyshell#18>", 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)	
+
+>>> spsy
+[0.0, 0.047619047619047616, 0.09297052154195011, ..., 0.9923955100021263]
+```
+
+Выходной сигнал в виде графика:
+
+```py
+>>> import pylab
+>>> pylab.plot(spsy)
+[<matplotlib.lines.Line2D object at 0x000001A068319850>]
+>>> pylab.xlabel("Время, T")
+Text(0.5, 0, 'Время, T')
+>>> pylab.ylabel("Выходной сигнал, y")
+Text(0, 0.5, 'Выходной сигнал, y')
+>>> pylab.grid(True)
+>>> pylab.show()
+```
+
+![](1.PNG)
+
+## 3. Функции как объекты.
+
+### 3.1. Атрибуты объекта-функции.
+
+```py
+>>> dir(inerz) # Список атрибутов
+['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
+
+>>> inerz.__doc__ # Возвращает строку документации(то что в тройных скобочках)
+' Модель устройства с памятью:\n\tx- текущее значение вх.сигнала,\n\tT -постоянная времени,\n\typred - предыдущее значение выхода устройства'
+
+>>> 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. Альтернативное определение функции в программе.
+
+```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.3363755443363323
+```
+
+### 4.3. Произвольное расположение аргументов функции.
+
+```py
+>>> logistfun(b = 0.5,a = 0.8)  # Ссылки на аргументы поменялись местами
+0.34498724056380625
+>>> logistfun(0.8, 0.5)
+0.34498724056380625
+```
+
+### 4.4. Аргументы функции, содержащиеся в списке или кортеже.
+
+```py
+>>> b1234 = [b1, b2, b3, b4]  # Список списков из п.2.4
+>>> slozh(b1, b2, b3, b4)
+[1, 2, -1, -2, 0, 2, -1, -1]
+>>> 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
+```
+
+Подобным образом можно использовать словарь в списке аргументов:
+
+```py
+>>> def func4(a,b = 7,**dic7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+	"""Словрь - сборка аргументов - должен быть последним!"""
+	smm = 0
+	for elt in dic7.values():
+		smm += elt
+	return a * smm + b
+
+>>> func4(-1, 2, **{"x1" : 0, "x2" : 3, "x3" : 6})
+-7
+```
+
+### 4.9. Изменение значений объектов.
+
+```py
+>>> a = 90    # Числовой объект – неизменяемый тип
+>>> def func3(b):
+	b = 5 * b + 67
+
+	
+>>> func3(a)
+>>> a # Число осталось неизменным
+90
+```
+
+Пример со списком:
+
+```py
+>>> sps1 = [1,2,3,4]  #Список – изменяемый тип объекта
+>>> def func2(sps):
+	sps[1] = 99
+
+	
+>>> func2(sps1)
+>>> print(sps1) # Список поменял значение на втором элементе
+[1, 99, 3, 4]
+```
+
+Кортеж:
+
+```py
+>>> kort = (1,2,3,4)   #Кортеж – неизменяемый тип объекта
+>>> func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#118>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#114>", line 2, in func2
+    sps[1] = 99
+TypeError: 'tuple' object does not support item assignment
+>>> kort
+(1, 2, 3, 4)
+```
+
+## 5. Специальные типы функций.
+
+### 5.1. Анонимные функции.
+
+	Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени (поэтому их и называют анонимными), определяемые по следующей схеме:
+	lambda [<Аргумент1>[,<Аргумент2>,…]]:<Возвращаемое значение или выражение>
+	Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
+
+```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. Функции-генераторы.
+
+	Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. Для этого в функцию включают инструкцию yield приостанавливающую её выполнение и возвращающую очередное значение.
+
+```py
+>>> def func5(diap, shag):
+	""" Итератор, возвращающий значения
+	из диапазона от 1 до diap с шагом shag"""
+	for j in range(1, diap + 1, shag):
+		yield j
+
+		
+>>> for mm in func5(7, 3):
+	print(mm)
+
+	
+1
+4
+7
+```
+
+	Часто используют метод __next__, активирующий очередную итерацию выполнения функции.
+
+```py
+>>> 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#141>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+## 6. Локализация объектов в функциях.
+
+	Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  
+	
+	Глобальные – это те объекты, значения которых заданы вне функции. Они определены в пространствах имен вне функции.
+	
+	Локализация может быть переопределена путем прямого объявления объектов как глобальных с помощью дескриптора global.
+
+### 6.1. Примеры на локализацию объектов.
+
+#### Пример 1. Одноименные локальный и глобальный объекты.
+
+```py
+>>> glb = 10
+>>> def func7(arg):
+	loc1 = 15
+	glb = 8
+	return loc1*arg
+
+>>> res = func7(glb); res
+150
+>>> glb
+10 # Глобальная переменная сохранила свое значение, в функции действия производились с локальной переменной glb
+```
+
+#### Пример 2. Ошибка в использовании локального объекта.
+
+```py
+>>> def func8(arg):
+	loc1 = 15
+	print(glb) # Локальный объект ещё не был задействован  
+	glb = 8
+	return loc1*arg
+
+>>> res = func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#149>", line 1, in <module>
+    res = func8(glb)
+  File "<pyshell#148>", line 3, in func8
+    print(glb)
+UnboundLocalError: local variable 'glb' referenced before assignment
+```
+
+#### Пример 3. Переопределение локализации объекта.
+
+```py
+>>> glb = 11
+>>> def func7(arg):
+	loc1 = 15
+	global glb # Переопределение с помощью дескриптора global
+	print(glb)
+	glb = 8
+	return loc1*arg
+
+>>> res = func7(glb)
+11
+>>> glb
+8 # Как итог: значение изменилось
+```
+
+### 6.2. Выявлеие локализации объекта с помощью функций locals() и globals() из builtins().
+
+```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', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'b12345', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+>>> locals().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', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'b12345', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+```
+
+	Различий в перечнях нет, потому что при выполнении действий в командной строке объекты globals() и locals() находятся в одном и том же модуле(main).
+
+```py
+>>> def func8(arg):
+	loc1 = 15
+	glb = 8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+	return loc1*arg
+
+>>> hh = func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'b12345', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb']) # locals() применялся в функции(не основная программа), отчего вывелось только три аргументы, ей принадлежащие
+>>> hh
+120
+>>> '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
+	loc1 = 5
+	glb = func9_1(loc1)
+	print('loc_func9:',locals().keys())
+	print('glob_func9:',globals().keys())
+	return arg2 + arg3 * glb
+
+>>> kk = func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'b12345', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9', 'loc1'])
+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', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'b12345', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9', 'loc1'])
+>>> kk
+85
+```
+
+	Внутри функциии func9_1locals(): ['arg1', 'loc1', 'glb1'] — локальные переменные вложенной функции.
+	Внутри функции func9: locals(): ['arg2', 'arg3', 'func9_1', 'loc1', 'glb'] — локальные переменные и вложенная функция.
+
+### 6.4. Задача с несколькими функциями.
+
+#### Запросили и ввели параметры задачи:
+
+```py
+>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=1.5, 2, 0.8, 0.3, 1, 10, 50
+>>> 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]) # время подачи сигнала(число тактов)
+```
+
+#### Создали реализацию входного сигнала
+
+```py
+>>> vhod = []
+>>> for i in range(N):
+		vhod.append(A * math.sin((2 * i * math.pi) / F))
+
+	
+>>> vhod
+[0.0, 0.5877852522924731, 0.9510565162951535, 0.9510565162951536, 0.5877852522924732, 1.2246467991473532e-16, -0.587785252292473, -0.9510565162951535, -0.9510565162951536, -0.5877852522924734, -2.4492935982947064e-16, 0.5877852522924722, 0.9510565162951535, 0.9510565162951536, 0.5877852522924734, 3.6739403974420594e-16, -0.5877852522924728, -0.9510565162951534, -0.9510565162951538, -0.5877852522924735, -4.898587196589413e-16, 0.5877852522924727, 0.9510565162951529, 0.9510565162951538, 0.5877852522924736, 6.123233995736766e-16, -0.5877852522924726, -0.9510565162951534, -0.9510565162951538, -0.5877852522924737, -7.347880794884119e-16, 0.5877852522924725, 0.9510565162951533, 0.9510565162951539, 0.5877852522924738, 8.572527594031472e-16, -0.5877852522924724, -0.9510565162951533, -0.9510565162951539, -0.5877852522924739, -9.797174393178826e-16, 0.5877852522924695, 0.9510565162951533, 0.9510565162951539, 0.5877852522924769, 1.102182119232618e-15, -0.5877852522924722, -0.9510565162951543, -0.951056516295154, -0.587785252292477]		
+```
+
+#### Создание функций, реализующих компоненты системы.
+
+```py
+>>> def realdvig(xtt,kk1,TT,yti1,ytin1):
+		#Модель реального двигателя
+		yp = kk1 * xtt  #усилитель
+		yti1 = yp + yti1  #Интегратор
+		ytin1 = (yti1 + TT * ytin1) / (TT + 1)
+		return [yti1, ytin1]
+
+	
+>>> def tahogen(xtt,kk2,yti2):
+		#Модель тахогенератора
+		yp = kk2 * xtt   #усилитель
+		yti2 = yp + yti2 #интегратор
+		return yti2
+
+	
+>>> def nechus(xtt,gran):
+	#зона нечувствит
+	if xtt < gran and xtt > (-gran):	
+		ytt = 0
+	elif xtt >= gran:
+		ytt = xtt - gran
+	elif xtt <= (-gran):
+		ytt = xtt + gran
+	return ytt
+
+```
+
+#### Реализация соединения компонент.
+
+```py
+>>> yi1 = 0; yin1 = 0; yi2 = 0
+>>> vyhod = []
+>>> for xt in vhod:
+		xt1 = xt - yi2   #отрицательная обратная связь
+		[yi1, yin1] = realdvig(xt1, k1, T, yi1, yin1)
+		yi2 = tahogen(yin1, k2, yi2)
+		yt = nechus(yin1, Xm)
+		vyhod.append(yt)
+
+		
+>>> print('y=', vyhod)
+y= [0, 0, 0.5477922512661431, 0.9359129751953723, 0.5375136095846609, -0.414130552366112, -2.7428449837433844, -4.554103899908976, -4.078750912636524, -0.145853992682759, 5.964306438944555, 12.314145928922647, 13.559748718233541, 5.858627553139554, -9.852062901481515, -28.135533681340938, -36.65387049830246, -24.06220543934573, 11.74767637929479, 59.39893445134125, 90.95876220460141, 75.58135748964305, -0.6584429013168669, -118.08979658241776, -215.4079027893135, -213.32790885716003, -59.82524391558922, 217.89433029982746, 492.1474452445438, 566.8922448763104, 282.0484956417324, -354.5664584676218, -1084.5673301411105, -1442.4785481342442, -975.400213385445, 431.05734925267456, 2291.930898156458, 3538.274443009433, 2959.5015412914295, -19.154639025131353, -4590.657256837865, -8386.980704286756, -8311.424120813046, -2329.924535065716, 8520.178563924977, 19208.53202021511, 22104.825680659345, 10964.180902643911, -13919.615195402203, -42398.36445967588]
+```
+
+## 7. Завершение сеанса работы IDLE.
+
+
+
+
+

TEMA7/task.md

@@ -0,0 +1,74 @@
+## Общее контрольное задание по Теме 7
+
+Кузьменко Елена, А-02-23
+
+## Задание
+
+	1) Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+	2) Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+	3) Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+	   Y=b1+b2*X и имеющую аргументы b1, b2 и X.
+
+## Решение
+
+### 1) Функция, реализующая расчет выходного сигнала для устройства задержки.
+
+```py
+>>> def delay(signal, T):
+	"""Расчет выходного сигнала y(t) для устройства задержки"""
+	return [0] * T + signal
+
+>>> x_t = [10,9,8,15,8,5]; x_t # входной сигнал
+[10, 9, 8, 15, 8, 5]
+>>> y_t = delay(x_t,3); y_t # выходной сигнал с задержкой
+[0, 0, 0, 10, 9, 8, 15, 8, 5]
+
+```
+
+### 2) Функция, реализующая расчет гистограммы
+
+```py
+>>> def hist(spis, inv):
+    """Расчет гистограммы в виде таблицы"""
+    min_x = min(spis); max_x = max(spis)
+    shir = (max_x - min_x) / inv # ширина одного интервала
+    gran = []
+    for i in range(inv + 1):
+        gran.append(min_x + i * shir)
+    res = []
+    for j in range(inv):
+        c = 0
+        for x in spis:
+            if gran[j] <= x < gran[j+1]: 
+                c += 1
+            elif x == max_x and j == inv - 1:
+                c += 1
+        res.append(c)
+    print("[Левая Правая] Кол-во эл-в") # Левая и правая границы интервала
+    for w in range(inv):
+        print(f"{gran[w]:.2f}   {gran[w+1]:.2f}   {res[w]}")
+    return res
+
+>>> chisl = [random.gauss(50, 10) for i in range(20)]
+>>> N = [random.gauss(50, 10) for i in range(20)]
+>>> res1 = hist(N,5)
+[Левая Правая] Кол-во эл-в
+36.67   44.38   5
+44.38   52.09   6
+52.09   59.80   6
+59.80   67.51   2
+67.51   75.22   1
+
+>>> print(res1) # кол-во чисел в каждом интервале
+[5, 6, 6, 2, 1] 
+```
+
+### 3) Анонимная функция линейной регрессии
+
+```py
+>>> reg = lambda b1, b2, X: b1+b2*X
+>>> Y = reg(10,20,5)
+>>> Y
+110
+```
+

TEMA7/test.md

@@ -0,0 +1,80 @@
+# Индивидуальное контрольное задание по Теме 7
+
+Кузьменко Елена, А-02-23, Вариант 13
+
+## Задание
+
+    Разработайте функцию с 3 аргументами, которая на основе заданной целочисленной последовательности (список или кортеж) – аргумент функции - формирует два текстовых файла с заданными именами (аргументы функции), причем в первый файл записывает из исходной последовательности четные значения, а во второй – нечетные. Проверьте функцию на примере кортежа с 40 случайными целыми числами.
+
+## Решение 
+
+### 1) Разработка функции
+
+```py
+>>> def files(N, f_chet, f_nchet):
+    fp1 = open(f_chet, 'w')
+    fp2 = open(f_nchet, 'w')
+    for i in N:
+        s = str(i) + '\n'
+        if i % 2 == 0:
+            fp1.write(s)
+        else:
+            fp2.write(s)
+    fp1.close()
+    fp2.close()
+```
+
+### 2) Проверка на примере кортежа
+
+```py
+>>> import random
+>>> test = tuple(random.randint(1,100) for j in range(40))
+>>> files(test, 'f_chet.txt', 'f_nchet.txt')
+```
+
+#### Содержание файла 'f_chet.txt':
+
+    24
+    44
+    18
+    72
+    12
+    22
+    100
+    92
+    92
+    20
+    72
+    58
+    26
+    6
+    36
+    42
+    36
+
+#### Содержание файла 'f_nchet.txt':
+
+    29
+    17
+    25
+    95
+    61
+    13
+    83
+    95
+    73
+    71
+    19
+    89
+    1   
+    7
+    87
+    49
+    37
+    95
+    11
+    65
+    63
+    23
+    81
+

TEMA8/report.md

@@ -0,0 +1,398 @@
+# Отчёт по Теме 8
+
+Кузьменко Елена, А-02-23
+
+## 1. Запустили интерактивную оболочку IDLE. 
+
+```py
+import os, sys, importlib
+os.chdir(r"C:\Users\vaffl\Desktop\Учеба\ПОАС\TEMA8")
+os.getcwd()
+'C:\\Users\\vaffl\\Desktop\\Учеба\\ПОАС\\TEMA8'
+```
+
+## 2. Создание и использование модулей в среде Python.
+
+	Модуль в Python — это отдельный файл с расширением .py, содержащий код на языке Python, который может быть повторно использован в других программах через import.
+
+### 2.1. Запуск модуля через import
+
+Mod1.py
+```py
+perm1 = input('Mod1:Введите значение = ')
+print('Mod1:Значение perm1=', perm1)
+
+```
+
+main.py
+```py
+>>> import sys, os
+>>> import Mod1
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+>>> type(Mod1)
+<class 'module'>
+>>> dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+```
+
+Повторное обращение к Mod1 в main:
+```py
+>>> import Mod1 # требуется перезагрузить
+>>> importlib.reload(Mod1)
+Mod1:Введите значение = 6
+Mod1:Значение perm1= 6
+<module 'Mod1' from 'C:\\Users\\vaffl\\Desktop\\Учеба\\ПОАС\\TEMA8\\Mod1.py'>
+>>> Mod1.perm1
+'6'
+```
+
+### 2.2. Импортируемые модули в словаре.
+
+Импортированные модули заносятся в словарь – значение атрибута sys.modules.
+
+```py
+>>> print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', . . ., 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+
+```
+	print(sorted(sys.modules.keys())) выводит отсортированный по алфавиту список всех модулей, загруженных в память Python на данный момент.
+
+Удаление Mod1 из словаря:
+
+```py
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\vaffl\\Desktop\\Учеба\\ПОАС\\TEMA8\\Mod1.py'>
+>>> print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', …, 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+
+### 2.3. Запуск модуля на выполнение с помощью exec().
+
+	Функция exec действует так, как будто на месте обращения к ней в программу вставлен код из объекта-аргумента функции. Объект-модуль при этом не создается. Созданные при выполнении модуля объекты становятся объектами главной программы.
+
+```py
+>>> exec(open('Mod1.py').read()) # читает как бинарный файл
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>>> exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+>>> print(sorted(sys.modules.keys())) # Объект-модуль не появится
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', ...,'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> perm1
+'3'
+```
+
+### 2.4. Инструкция from … import …
+
+	Можно осуществлять импорт модуля не целиком, а только часть содержащихся в нем объектов.
+
+#### Пример 1
+
+```py
+>>> from Mod1 import perm1
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+>>> "perm1" in dir()
+True
+>>> "Mod1" in dir()
+False
+>>> perm1 # Теперь переменная главной программы
+'1'
+```
+
+#### Пример 2
+
+Содержимое нового модуля Mod2:
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+main.py
+```py
+>>> from Mod2 import beta # импортирует beta из модуля
+>>> g = beta(2); g
+535.4916555247646
+```
+
+Случай обращения к переменной без её импорта:
+```py
+>>> alpha()
+Traceback (most recent call last):
+  File "<pyshell#41>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+```
+
+Импорт функции из модуля с псевдонимом:
+```py
+>>> from Mod2 import alpha as al
+>>> al()
+****ALPHA****
+Значение t=54
+'54'
+```
+
+```py
+>>> del al,beta
+>>> dir()
+['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'g', 'importlib', 'os', 'perm1', 'sys']
+>>> from Mod2 import * # импорт всего содержимого
+>>> tt=alpha()
+****ALPHA****
+Значение t=0.12
+>>> uu = beta(float(tt))
+>>> uu
+1.4578913609506803
+```
+
+## 3. Многомодульные программы.
+
+### 3.1. Пример простой многомодульной программы.
+
+Содержимое модуля Mod0:
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+```
+
+main.py
+```py
+>>> import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+****ALPHA****
+Значение t=0.1
+tt= 0.1
+qq= 1.369107770624847
+>>> Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
+'0.1'
+1.369107770624847
+'10'
+```
+
+### 3.2. Многомодульная программа(Тема7)
+
+MM1.py
+```py
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+    #Модель реального двигателя
+    yp=kk1*xtt  #усилитель
+    yti1=yp+yti1  #Интегратор
+    ytin1=(yti1+TT*ytin1)/(TT+1)
+    return [yti1,ytin1]
+
+def tahogen(xtt,kk2,yti2):
+    #Модель тахогенератора
+    yp=kk2*xtt   #усилитель
+    yti2=yp+yti2 #интегратор
+    return yti2
+
+def nechus(xtt,gran):
+    #зона нечувствит
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt
+```
+
+MM2.py
+```py
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1=float(znach[0])
+T=float(znach[1])
+k2=float(znach[2])
+Xm=float(znach[3])
+A=float(znach[4])
+F=float(znach[5])
+N=int(znach[6])
+
+import math
+vhod=[]
+for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+import MM1 as mod
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+	xt1=xt-yi2   #отрицательная обратная связь
+	[yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
+	yi2=mod.tahogen(yin1,k2,yi2)
+	yt=mod.nechus(yin1,Xm)
+	vyhod.append(yt)
+```
+
+MM0.py
+```py
+import MM2
+print("y =", MM2.vyhod)
+```
+
+main.py
+```py
+>>> import MM0
+k1,T,k2,Xm,A,F,N=5,4,3,10,13,40,20
+y = [0, 0, 0, 0, 0, 2.477949838924891, 0, -20.53441412153191, 17.715970981372855, 60.985241346827166, -100.52605254589719, -130.44369177973613, 361.76845433684196, 191.5984158258393, -1110.3384817523201, 0, 3063.4072561608186, -1492.2961077606046, -7685.482903314702, 7891.808692887814]
+```
+
+
+### 3.3. Области действия объектов в модулях.
+
+#### Пример 1
+
+	Попробуйте вставить в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
+
+Mod2.py
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    print('Результат beta(2) из alpha:', beta(2))
+    return t
+
+def beta(q):
+    import math
+    print('Результат alpha() из beta:', alpha())
+    expi=q*math.pi
+    return math.exp(expi)
+```
+	Одновременно нельзя функциям обращаться друг к другу, так как возникает рекурсия(обращение функции к самой себе) - происходит зацикливание вывода(пока не прервать)
+
+В отдельных случаях:
+main.py
+```py
+>>> Mod2.alpha()
+****ALPHA****
+Значение t=10
+Результат beta(2) из alpha: 535.4916555247646
+'10'
+```
+
+```py
+>>> Mod2.beta(3)
+****ALPHA****
+Значение t=10
+Результат alpha() из beta: 10
+12391.647807916694
+```
+
+#### Пример 2
+
+	Попробуйте отобразить на экране в модуле Mod0 значения объектов t и expi.
+
+Mod2.py
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq =',qq)
+print('t =',t)
+print('expi =',expi)
+```
+
+main.py
+```py
+>>> import Mod0
+Mod1:Введите значение = 2
+Mod1:Значение perm1= 2
+perm1= 2
+****ALPHA****
+Значение t=1
+tt= 1
+qq = 23.140692632779267
+Traceback (most recent call last):
+  File "<pyshell#96>", line 1, in <module>
+    import Mod0
+  File "C:\Users\vaffl\Desktop\Учеба\ПОАС\TEMA8\Mod0.py", line 10, in <module>
+    print('t =',t)
+NameError: name 't' is not defined. Did you mean: 'tt'
+```
+	Переменные t и expi -локальные, они не существуют в Mod0(только во время выполнения функций alpha() и beta())
+
+#### Пример 3
+
+	Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+
+Mod0.py
+```py
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq =',qq)
+Mod1.perm1 *= 3 # с указанием модуля
+print("perm1 = ", Mod1.perm1)
+```
+
+main.py
+```py
+>>> import Mod0
+perm1= 2
+****ALPHA****
+Значение t=10
+tt= 10
+qq = 44031505860631.98
+perm1 =  222
+```
+
+#### Пример 4
+
+	Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq.
+
+```py
+>>> import Mod0
+perm1= 222
+****ALPHA****
+Значение t=1
+tt= 1
+qq = 23.140692632779267
+perm1 =  222222222
+>>> perm1*2
+Traceback (most recent call last):
+  File "<pyshell#112>", line 1, in <module>
+    perm1
+NameError: name 'perm1' is not defined
+>>> tt*2
+Traceback (most recent call last):
+  File "<pyshell#113>", line 1, in <module>
+    tt
+NameError: name 'tt' is not defined
+>>> qq*2
+Traceback (most recent call last):
+  File "<pyshell#114>", line 1, in <module>
+    qq*2
+NameError: name 'qq' is not defined
+```
+	perm1,tt,qq - локальные объекты, к ним можно обращаться только в модулях, где они были заданы изначально.
+
+## 4. Завершение сеанса работы с IDLE.

TEMA8/task.md

@@ -0,0 +1,89 @@
+## Общее контрольное задание по Теме 8
+
+Кузьменко Елена, А-02-23
+
+## Задание
+
+	Разработайте программу, состоящую из трех модулей:
+	1) Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+	2) Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+	3) Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+    Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+## Решение
+
+### 1) Модуль 1
+
+```py
+# Модуль 1 OKZ1.py
+def file(filename):
+    num = []
+    file = open(filename, 'r')
+    lines = file.readlines()
+    file.close()
+    
+    for line in lines:
+        line = line.strip()  # удаляем пробелы и переносы в начале и конце строки
+        if line:  # проверяем, что строка не пустая
+            parts = line.split()
+            for part in parts:
+                num.append(float(part))  # преобразуем часть в число и добавляем в список
+    
+    return num
+```
+
+### 2) Модуль 2
+
+```py
+# Модуль 2 OKZ2.py
+def corr(list1, list2):
+    n = len(list1) if len(list1) < len(list2) else len(list2)
+    if n < 2:
+        return 0.0
+    sred1 = sum(list1[:n]) / n
+    sred2 = sum(list2[:n]) / n
+    s1 = s2 = s3 = 0.0
+    for i in range(n):
+        d1 = list1[i] - sred1  # отклонение от среднего для первого списка
+        d2 = list2[i] - sred2  # отклонение от среднего для второго списка
+        s1 += d1 * d2    # сумма произведений отклонений
+        s2 += d1 * d1    # сумма квадратов отклонений первого
+        s3 += d2 * d2    # сумма квадратов отклонений второго
+    if s2 == 0 or s3 == 0:
+        return 0.0
+    return s1 / ((s2 * s3) ** 0.5)
+```
+
+### 3) Модуль 3
+
+```py
+# Модуль 3 OKZ3.py
+import OKZ1, OKZ2
+print("Введите имя первого файла:")
+file1 = input()
+print("Введите имя второго файла:")
+file2 = input()
+num1 = OKZ1.file(file1)
+num2 = OKZ1.file(file2)
+corr0 = OKZ2.corr(num1, num2)
+corr0 = round(corr0, 3)
+print("Коэффициент корреляции:", corr0)
+```
+
+### Проверка 
+
+Содержимое файла task_test1.txt:
+	112 45 102 8 -23 6 12.2 9 -9.2
+
+Содержимое файла task_test2.txt:
+	32 -0.5 12.3 9 10 98 8 12
+
+Запуск Модуля 3:
+```py
+=========== RESTART: C:/Users/vaffl/Desktop/Учеба/ПОАС/TEMA8/OKZ3.py ===========
+Введите имя первого файла:
+task_test1.txt
+Введите имя второго файла:
+task_test2.txt
+Коэффициент корреляции: -0.062
+```

TEMA8/test.md

@@ -0,0 +1,71 @@
+# Индивидуальное контрольное задание по Теме 8
+
+Кузьменко Елена, А-02-23, Вариант 6
+
+## Задание
+
+    По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+    Тема 7. Вариант 6:
+
+    1)Разработайте функцию с 3 аргументами: x, А и В, реализующую преобразование входного сигнала x по формуле: y=B, если x>A;  y= 2B*x/A-B*x^2 /A^2 , если 0≤ x ≤ А;  y= 2B * x/A +B*x^2 /A^2 , если -A≤ x <0; y=-B, если x< -A. 
+    2)Создайте список со 100 значениями входного сигнала х – случайными, равномерно распределенными числами в диапазоне значений от -5 до 12. Для элементов списка с помощью функции рассчитайте список со значениями выходного сигнала y при трех разных парах значений А и В. Записать результаты в текстовый файл в виде двух столбцов: хi, yi.
+
+
+## Решение 
+
+### 1)Модуль с функцией. Mod1
+
+```py
+# Модуль 1 Mod1
+def signal(x, A, B):
+      if x > A: 
+         return B
+      elif 0 <= x <= A:
+         return (2 * B * x / A - B *(x ** 2 / A ** 2))
+      elif -A <= x < 0:
+         return (2 * B * x / A + B * (x ** 2 / A ** 2))
+      else: return -B
+
+```
+
+### 2)Модуль с вызовом функцией. Mod2
+
+```py
+#Модуль 2 Mod2
+import Mod1
+import random
+
+list1 = [random.uniform(-5, 12) for i in range(100)
+
+with open('res1.txt', 'w') as f:
+    for x in list1:
+        y = Mod1.signal(x, 2, 3)
+        f.write(f'{x},{y}\n')
+    print('Записано в файл res1.txt')
+
+with open('res2.txt', 'w') as f:
+    for x in list1:
+        y = Mod1.signal(x, 5, 10)
+        f.write(f'{x},{y}\n')
+    print('Записано в файл res2.txt')
+
+with open('res3.txt', 'w') as f:
+    for x in list1:
+        y = Mod1.signal(x, 14, 2)
+        f.write(f'{x},{y}\n')
+    print('Записано в файл res3.txt')
+```
+
+### Проверка:
+```py
+>>> import Mod2
+Записано в файл res1.txt
+Записано в файл res2.txt
+Записано в файл res3.txt
+```
+
+### Содержание файлов:
+
+![](ris.PNG)
+

TEMA9/Mod3.py

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

TEMA9/SAU.py

@@ -0,0 +1,22 @@
+# Модуль SAU
+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/report.md

@@ -0,0 +1,334 @@
+# Отчёт по Теме 9
+
+Кузьменко Елена, А-02-23
+
+## 1. Запустили интерактивную оболочку IDLE. 
+
+```py
+>>> import os, sys, importlib
+>>> os.chdir(r"C:\Users\vaffl\Desktop\Учеба\ПОАС\TEMA9")
+>>> os.getcwd()
+'C:\\Users\\vaffl\\Desktop\\Учеба\\ПОАС\\TEMA9'
+```
+	Классы – это основные инструменты объектно-ориентированного программирования (ООП) в языке Python. Они представляют собой шаблоны, образцы, по которым может быть создано множество объектов-экземпляров класса. У каждого класса есть уникальное имя и некоторый набор специфических для него атрибутов: полей (данных) и методов (функций), которые могут использоваться при работе с экземплярами класса.
+
+## 2. Классы и их наследники.
+
+	Классы — это шаблоны для создания объектов с общими атрибутами и методами
+
+### 2.1. Автономный класс.
+
+	Автономный класс - это класс, который не наследуется от какого-либо другого пользовательского класса.
+```py
+>>> class Class1:
+...     def zad_zn(self, znach): # метод для установки значения
+...         self.data = znach # .data - аргумент/переменная, хранящая значения, self - ссылка на экземпляр класса
+...     def otobrazh(self): # метод для отображения значения
+...         print(self.data)
+... 
+...         
+>>> z1 = Class1() # создаём 1-й экземпляр класса
+>>> z2 = Class1() # создаём 2-й экземпляр класса
+>>> z1.zad_zn('экз.класса 1')
+>>> z2.zad_zn(-632.453)
+>>> z1.otobrazh()
+экз.класса 1
+>>> z2.otobrazh()
+-632.453
+>>> z1.data = 'Новое значение атрибута у экз.1' # внесли новые данные
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+>>> dir(z1)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'otobrazh', 'zad_zn'] # появление пользовательских атрибутов/методов
+```
+	Мы создали класс как шаблон, сделали по нему два объекта, положили в них разные данные и показали, что они работают независимо друг от друга.
+
+### 2.2. Класс-наследник.
+
+	Класс-наследник — это класс, который получает всё от другого класса (родителя) и может это дополнять или изменять.
+	В объявлении класса после его имени в скобках перечисляются его «родительские классы»
+
+```py
+>>> class Class2(Class1):  # Class2 - наследник класса Class1
+...     def otobrazh(self): # Метод  класса Class2 – переопределяет метод родителя
+...         print('значение=',self.data) # Отображение данных экземпляра
+... 
+...         
+>>> z3 = Class2()
+>>> dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+>>> z3.zad_zn('Совсем новое')
+>>> z3.otobrazh()
+значение= Совсем новое
+>>> z1.otobrazh() # # z1 и z3 — независимые объекты. Работа с z3 не влияет на z1
+Новое значение атрибута у экз.1
+>>> del z1, z2, z3
+>>> dir()
+['Class1', 'Class2', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'importlib', 'os', 'sys']
+```
+
+	У второго класса Class2 был изменен формат вывода для метода отображения, но на родительский класс Class1 не повлияло. 
+
+
+## 3. Классы в модулях. 
+
+Создание модуля Mod3:
+
+```py
+# Mod3
+class Class1:
+	def zad_zn(self, znach): 
+		self.data = znach
+	def otobrazh(self): 
+		print(self.data)
+class Class2(Class1):
+	def otobrazh(self):
+		print('значение =',self.data)
+def otobrazh(objekt):  # Объявление самостоятельной функции
+    print('значение объекта =',objekt)
+```
+
+main.py:
+
+```py
+>>> from Mod3 import Class1
+>>> z4 = Class1()
+>>> z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#36>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\vaffl\Desktop\Учеба\ПОАС\TEMA9\Mod3.py", line 6, in otobrazh
+    print(self.data)
+AttributeError: 'Class1' object has no attribute 'data'
+```
+	Ошибка возникает потому, что у объекта z4 не существует атрибута data в момент вызова метода otobrazh() - он пытается обратиться к self.data. (.data задается только в методе zad_zn - нечего отображать, пока не были внесены значения)
+
+Можно задать значение напрямую(избежать ошибку):
+
+```py
+>>> z4.data = 'значение данного data у экз.4'
+>>> z4.otobrazh()
+значение данного data у экз.4
+```
+
+Попробуем следующее: 
+
+```py
+>>> del z4
+>>> import Mod3
+>>> z4 = Mod3.Class2()
+>>> z4.zad_zn('Класс из модуля')
+>>> z4.otobrazh()
+значение = Класс из модуля
+>>> Mod3.otobrazh('Объект')
+значение объекта = Объект
+```
+	Метод z4.otobrazh() выводит значение атрибута объекта в формате Class2(Обращение к классу).
+	Mod3.otobrazh() — независимая/самостоятельная функция, выводящая переданный ей аргумент.
+
+## 4.Специальные методы. 
+
+	Имена специальных методов предваряются одним или двумя подчерками и имеют вид: __<имя специального метода>__
+	Специальные методы вызываются автоматически при определенных операциях, они позволяют настраивать поведение объектов.
+
+```py
+>>> class Class3(Class2):  # Наследник класса Class2, а через него – и класса Class1
+...     def __init__(self, znach): #Конструктор позволяет сразу задать данные
+...         self.data = znach
+...     def __add__(self, drug_zn):  #Вызывается, когда экземпляр участвует в операции «+». Определяет "как именно" сложить объекты(разрешает складывать обычным плюсом).
+...         return Class3(self.data + drug_zn)
+...     def zad_dr_zn(self, povtor):  # обычный метод
+...         self.data *= povtor
+... 
+...         
+>>> z5 = Class3('abc') # При создании экземпляра срабатывает конструктор
+>>> z5.otobrazh()
+значение= abc
+>>> z6 = z5 + 'def' # без метода __add__ произошла бы ошибка
+>>> z6.otobrazh()
+значение= abcdef
+>>> z6.zad_dr_zn(3)
+>>> z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+
+## 5.Присоединение атрибутов к классу.
+
+```py
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> Class3.fio = 'Кузьменко Е.А.'
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> z7 = Class3(123)
+>>> dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+dir(z7) == dir(Class3)
+False
+```
+
+	Мы получили "False", так как при создании экземпляра помимо доступа к атрибутам класса вызывается и конструктор __init__, который создает атрибут data у экземпляра.
+	Поэтому в dir(z7) появляется атрибут 'data', которого нет в списке атрибутов класса. Коротко: data это атрибут экземпляра, а не класса.
+
+```py
+>>> z7.fio
+'Кузьменко Е.А.'
+>>> Class3.fio
+'Кузьменко Е.А.'
+```
+	Class3.fio = 'Кузьменко Е.А.' - после добавления атрибута классу все экземпляры этого класса, включая z7, получили доступ к этому значению.
+
+```py
+>>> z7.rozden = '2005' # создали атрибут *только* у объекта z7
+>>> z7.rozden
+'2005'
+>>> dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+	Класс — это шаблон, а объект — конкретная часть шаблона, добавив атрибут объекту, мы не сможем изменить шаблон. Поэтому у Class3 не появился атрибут rozden.
+
+## 6.Выявление родительских классов.
+
+	Такое выявление делается с помощью специального атрибута __bases__
+
+```py
+>>> Class3.__bases__
+(<class '__main__.Class2'>,) # наследует от Class2
+>>> Class2.__bases__
+(<class '__main__.Class1'>,) # наследует от Class1
+>>> Class1.__bases__
+(<class 'object'>,) # наследует от object - родительский класс 
+```
+
+	Для получения всей цепочки наследования используется атрибут __mro__
+
+```py
+>>> Class3.__mro__
+(<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
+```
+
+Цепочка наследования для встроенного класса "деления на ноль":
+
+```py
+>>> ZeroDivisionError.__mro__
+(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+
+	Конкретная ошибка деления на ноль -> арифметическая ошибка ->  все ошибки -> всё -> родительский класс
+
+## 7. Свойства класса.
+
+	Свойство (property) класса – это особый атрибут класса, с которым можно производить операции чтения или задания его значения, а также удаление значения этого атрибута.
+
+```py
+>>> class Class4:
+...     def __init__(sam, znach): 
+...         sam.__prm = znach # __prm — приватный атрибут, можно обращаться к переменным только через методы
+...     def chten(sam): # чтение
+...         return sam.__prm
+...     def zapis(sam, znch): # запись
+...         sam.prm = znch
+...     def stiran(sam): # удаление
+...         del sam.__prm
+...     svojstvo = property(chten, zapis, stiran) # создание свойства. оно даёт доступ к __prm
+... 
+...     
+>>> exempl = Class4(12)
+>>> exempl.svojstvo
+12
+>>> exempl.svojstvo = 45
+>>> print(exempl.svojstvo)
+12
+>>> del exempl.svojstvo
+>>> exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#95>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#89>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+
+	Ошибка возникает так как метод stiran() уже удалил приватный атрибут __prm, а метод chten() пытается прочитать несуществующий объект.
+
+## 8. Пример
+
+Модуль SAU.py:
+```py
+# Модуль SAU
+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])
+```
+
+SAU_main.py:
+```py
+# SAU_main
+prm = [2.5, 4, 1.3, 0.8]
+from SAU import *
+xx = [0] + [1] * 20 # Входной сигнал – «ступенька»
+SAUe = SAU(prm)   # Создаём экземпляр класса
+yt = []
+for xt in xx:
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+import pylab
+pylab.plot(yt)
+pylab.xlabel("Время    ")
+pylab.ylabel("Выходной сигнал   ")
+pylab.title("График выходного сигнала")
+pylab.grid(True)
+pylab.show()
+```
+
+Проверка:
+
+```py
+y = 0.0
+y = 0.2173913043478261
+y = 0.4763705103969754
+y = 0.686594887811293
+y = 0.8199324616478645
+y = 0.8837201137353929
+y = 0.8994188484874774
+y = 0.8892777072047301
+y = 0.870097963179993
+y = 0.8518346102696789
+y = 0.8387499784485772
+y = 0.8314204114211459
+y = 0.8286051955249649
+y = 0.8285656555914835
+y = 0.8297915186846528
+y = 0.8312697736438287
+y = 0.8324765218921963
+y = 0.8332456979978418
+y = 0.8336163607592184
+y = 0.8337101315489143
+y = 0.833654237067147
+```
+
+![](ris.png)
+
+## 9. Завершение сеанса работы с IDLE.

TEMA9/task.md

@@ -0,0 +1,140 @@
+## Общее контрольное задание по Теме 9
+
+Кузьменко Елена, А-02-23
+
+## Задание
+
+	Создайте и запишите в модуль класс, содержащий следующие компоненты:
+	- конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+
+	- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+
+	- метод для обеспечения перевода сотрудника из одного отдела в другой;
+
+	- метод для изменения должности сотрудника;
+
+	- свойство, содержащее перечень (список) поощрений сотрудника.
+
+	Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+## Решение
+
+### Модуль task_mod.py представляет из себя:
+
+#### 1) Конструктор, задающий атрибутам начальные значения.
+
+```py
+# Модуль task_mod.py
+class Rabotnik:
+def __init__(self, fio, otdel, dolzhnost, oklad):
+self.fio = fio
+self.otdel = otdel
+self.dolzhnost = dolzhnost
+self.oklad = oklad
+self.__pooshreniya = [] # приватный атрибут для хранения поощрений
+```
+
+#### 2) Метод для повышения оклада.
+
+```py
+def povysit_oklad(self, summa):
+            if summa > 0:
+                self.oklad += summa
+                return f"Оклад повышен на {summa}"
+            return "Не повышен"
+```
+
+#### 3) Метод для перевода между отделами.
+
+```py
+def perevod_v_otdel(self, noviy_otdel):
+       self.otdel = noviy_otdel
+```
+
+#### 4) Метод для изменения должности.
+
+```py
+def izm_dolzhnost(self, new_dolzhnost):
+           self.dolzhnost = new_dolzhnost
+```
+
+#### 5) Свойство, содержащее перечень поощрений сотрудника.
+
+```py
+def chten_pooshreniy(self):
+       return self.__pooshreniya
+
+def zapis_pooshreniy(self, pooshrenie):
+       self.__pooshreniya.append(pooshrenie)
+
+def udalenie_pooshreniy(self):
+       self.__pooshreniya.clear()
+
+pooshreniya = property(chten_pooshreniy, zapis_pooshreniy, udalenie_pooshreniy)
+```
+
+#### 6) Отображение(дополнительный метод)
+
+```py
+def __str__(self):  # автоматически вызывается при print()
+        poosh = ', '.join(self.pooshreniya) if self.pooshreniya else 'нет'
+        return f"{self.fio}, {self.dolzhnost}, {self.otdel}, оклад: {self.oklad}, поощрения: {poosh}"
+```
+
+### Проверка
+
+#### 1)Создание двух экземпляров и отображение значений:
+
+```py
+>>> import task_mod
+>>> from task_mod import Rabotnik
+>>> z1 = Rabotnik("Иванов И.И.", "IT", "Программист", 170000)
+>>> z2 = Rabotnik("Петров П.П.", "Бухгалтерия", "Бухгалтер", 155000)
+>>> print(z1)
+Иванов И.И., Программист, IT, оклад: 170000, поощрения: нет
+>>> print(z2)
+Петров П.П., Бухгалтер, Бухгалтерия, оклад: 155000, поощрения: нет
+```
+#### 2)Операции перевода из отдела в отдел:
+
+```py
+>>> z1.perevod_v_otdel("Разработка программного обеспечения")
+>>> z2.perevod_v_otdel("Финансовый отдел")
+>>> print(z1)
+Иванов И.И., Программист, Разработка программного обеспечения, оклад: 170000, поощрения: нет
+>>> print(z2)
+Петров П.П., Бухгалтер, Финансовый отдел, оклад: 155000, поощрения: нет
+```
+
+#### 3) Изменение должности и оклада:
+
+```py
+>>> z1.izm_dolzhnost("Старший программист")
+>>> z2.izm_dolzhnost("Главный бухгалтер")
+>>> print(z1.povysit_oklad(15000))
+Оклад повышен на 15000
+>>> print(z2.povysit_oklad(30000))
+Оклад повышен на 30000
+>>> print(z1)
+Иванов И.И., Старший программист, Разработка программного обеспечения, оклад: 185000, поощрения: нет
+>>> print(z2)
+Петров П.П., Главный бухгалтер, Финансовый отдел, оклад: 185000, поощрения: нет
+```
+
+#### 4) Объявление благодарности:
+
+```py
+>>> z1.zapis_pooshreniy("Благодарность за успешный проект")
+>>> z1.zapis_pooshreniy("Премия")
+>>> z2.zapis_pooshreniy("Грамота")
+>>> print(f"{z1.pooshreniya}") # чтение через свойство
+['Благодарность за успешный проект', 'Премия']
+>>> print(f"{z2.chten_pooshreniy()}") # чтение через метод
+['Грамота']
+>>> print(z2)
+Петров П.П., Главный бухгалтер, Финансовый отдел, оклад: 185000, поощрения: Грамота
+>>> print(z2)
+Петров П.П., Главный бухгалтер, Финансовый отдел, оклад: 185000, поощрения: Грамота
+>>> z1.udalenie_pooshreniy() # удаление поощрений
+>>> print(z1)
+```

TEMA9/task_mod.py

@@ -0,0 +1,35 @@
+# Модуль task_mod.py
+class Rabotnik:
+    def __init__(self, fio, otdel, dolzhnost, oklad):
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+        self.__pooshreniya = [] # приватный атрибут для хранения поощрений
+
+    def povysit_oklad(self, summa):
+            if summa > 0:
+                self.oklad += summa
+                return f"Оклад повышен на {summa}"
+            return "Не повышен"
+
+    def perevod_v_otdel(self, noviy_otdel):
+           self.otdel = noviy_otdel
+
+    def izm_dolzhnost(self, new_dolzhnost):
+           self.dolzhnost = new_dolzhnost
+
+    def chten_pooshreniy(self):
+           return self.__pooshreniya
+
+    def zapis_pooshreniy(self, pooshrenie):
+           self.__pooshreniya.append(pooshrenie)
+
+    def udalenie_pooshreniy(self):
+           self.__pooshreniya.clear()
+
+    pooshreniya = property(chten_pooshreniy, zapis_pooshreniy, udalenie_pooshreniy)
+
+    def __str__(self):  # автоматически вызывается при print()
+        poosh = ', '.join(self.pooshreniya) if self.pooshreniya else 'нет'
+        return f"{self.fio}, {self.dolzhnost}, {self.otdel}, оклад: {self.oklad}, поощрения: {poosh}"

TEMA9/test.md

@@ -0,0 +1,221 @@
+# Индивидуальное контрольное задание по Модулю 3
+
+Кузьменко Елена, А-02-23, Вариант 3
+
+## Задание
+
+    M3_3
+    1) Создайте модуль М1, содержащий две функции: 
+
+    - функция 1: аргументы - имя текстового файла, содержащего некоторое число отсчетов  сигнала, целочисленный параметр TAU и числовой параметр К; в функции считывается сигнал из файла в список SPS1 и формируется второй список SPS2, элементы которого определяются по правилу: первые (TAU-1) элементов равны 0, а последующие определяются по формуле: SPS2[i]=K*SPS1[i-TAU]; оба списка возвращаются в качестве результатов работы функции;
+
+    - функция 2: аргументы - два числовых списка SS1 и SS2, а также целочисленный параметр ТТ; в функции рассчитывается и возвращается значение
+
+    D= (SS1[TT]-SR1)*(SS2[0] - SR2)+ (SS1[TT+1]-SR1)*(SS2[1] - SR2)+:+
+
+    (SS1[i]-SR1)*(SS2[i-TT] - SR2)+:+ (SS1[N]-SR1)*(SS2[N-TT] - SR2),
+
+    где N - длина списка SS1, SR1, SR2 - средние значения соответствующих списков.
+
+    2) Создайте еще один модуль М2, в котором должны выполняться операции: 
+
+    - запрашивается и вводится имя текстового файла с данными; проверяется наличие файла и при отсутствии - повторение запроса;
+
+    - запрашивается значение параметра TAU и проверяется TAU >=0;
+
+    - вызывается функция 1 с указанными именем файла и параметром TAU, и случайным значением К из диапазона значений от 2 до 7; отображаются рассчитанные списки;
+
+    - вызывается функция 2 в цикле со значениями TT от 0 до TAU+5; результаты записываются в список SS3;
+
+    - список SS3 записывается в текстовый файл с именем Res11.bin.
+
+    3) Создайте модуль М0 - главную программу, которая вызывает М2 и отображает в виде графика  список SPS3.
+
+    4) Подготовьте  файл с исходными данными - 50 отсчетов случайного нормально распределенного с некоторыми параметрами сигнала. Проведите по программе расчеты  со значениями TAU, равными 0, 5 и 10.
+
+## Решение
+
+### 1) Модуль 1, содержащий две функции:
+
+```py
+#M1
+import random
+
+def func1(filename, TAU, K):
+    with open(filename, 'r') as f:
+        SPS1 = []
+        for line in f: SPS1.extend([float(x) for x in line.split()])
+    SPS2 = []
+    for i in range(TAU - 1):
+        SPS2.append(0)
+    for i in range(TAU - 1, len(SPS1)):
+        SPS2.append(K * SPS1[i - TAU])
+    return SPS1,SPS2
+
+def func2(SS1, SS2, TT):
+    if not SS1 or not SS2:
+        return 0
+    N = len(SS1)
+    SR1 = sum(SS1) / N
+    SR2 = sum(SS2) / N
+    D = 0
+    for i in range(TT, N):
+        if i - TT < len(SS2):
+            D += (SS1[i] - SR1) * (SS2[i - TT] - SR2)
+    return D
+```
+
+### 2) Модуль 2, выполняющий некоторые операции
+
+```py
+#M2
+
+import os, random
+from M1 import func1, func2
+
+while True:
+    filename = input("Файл: ")
+    if os.path.exists(filename):
+        break
+    else:
+        print("Файл не существует")
+
+while True:
+    TAU = int(input("TAU( >= 0): "))
+    if TAU >= 0:
+        break
+    else:
+        print("TAU >= 0 !!!")
+
+K = random.uniform(2, 7)
+SPS1, SPS2 = func1(filename, TAU, K)
+print(f"\nK = {K}")
+print(f"\nSPS1: {SPS1}")
+print(f"\nSPS2: {SPS2}")
+
+SS3 = []
+for TT in range(TAU + 6): # от 0 до TAU + 5
+    D = func2(SPS1, SPS2, TT)
+    SS3.append(D)
+with open("Res11.bin", 'w') as f:
+    for k in SS3:
+        f.write(f"{k}\n")
+```
+
+
+### 3) Модуль 0 - главная программа с отображением графика.
+
+```py
+import pylab
+import M2
+
+pylab.plot(M2.SS3)
+pylab.grid(True)
+pylab.title(f"График для TAU = {M2.TAU}")
+pylab.xlabel('TT')
+pylab.ylabel('D')
+pylab.show()
+```
+
+### 4) Подготовленный файл:
+
+```py
+import random
+with open('Module3.txt', 'w') as f:
+    for i in range(50):
+        x = random.gauss(0, 1)
+        f.write(f"{x} ")
+        if (i - 1) % 10 == 0:
+            f.write("\n")
+```
+
+#### Содержание файла:
+
+    0.8064899853503322 -0.7999172485456333 
+    0.663208239796933 0.31899452302272113 0.5035876315855168 -0.3406706136571314 1.6496754816989918 -0.1791351099272276 -0.10827443776686824 -2.658812292611897 -1.9909104100966244 -1.9688616617573687 
+    -1.01566469054407 0.41960123511862973 0.6253115359133461 -0.019552871718773835 -1.604390760043458 . . .
+
+### 5) Проверка программы.
+
+#### TAU = 0
+```py
+>>> import M0
+Файл: Module3.txt
+TAU( >= 0): 0
+
+K = 4.215502795233094
+
+SPS1: [-0.5014613246795419, -0.18870490479490082, -0.13626806920529586, 0.2261511688847735, 0.7592506218693422, 1.6743041964480039, 1.8071253642769052, -1.108127833798599, -1.5496935067426554, -0.21247741721223165, 0.3407805659376554, 2.1362311913147174, 0.7156055184882569, 2.7037350954655435, 0.7813669773259138, -0.773139567601898, -0.18829541770516456, 0.39275646367826605, -1.455517924364738, -0.947923033482155, 0.5337189005586409, -1.0949801541626745, 1.017332251419648, 1.5376809668965432, -0.49332423350979526, -0.11677704415558252, -1.724756294166204, -0.7485252939132131, -0.6987963135966981, 0.29822166543747597, -0.39840197681828055, 0.061299498326972866, 0.6771851019911601, 0.08726317013839653, 0.022523513105582402, 1.169638996828948, 2.1049705414301845, 1.4668480157506334, -1.4681977682876417, -1.2913984251492696, 0.2621474192558423, -1.2335305314285219, 1.2856514835931687, 0.2828802116923358, -0.6011169106816681, -1.9948231688056435, -0.49119859892321777, -0.6617548797215154, 0.7341159094871207, 0.9673252497663668]
+
+SPS2: [4.077762294289671, -2.1139116158878988, -0.7954860536370993, -0.5744384266359415, 0.9533408845789942, 3.2006231187726772, 7.05803402019706, 7.6179420244459175, -4.671315980853588, -6.5327373094282395, -0.8956991461820709, 1.436561428271302, 9.005288558251314, 3.016637063471475, 11.397602852504816, 3.2938546770202235, -3.259172008331107, -0.7937598596657043, 1.655665970481596, -6.135739878671425, -3.9959721973098583, 2.2498935171736845, -4.615891900597519, 4.288566949540303, 6.482098414129105, -2.0796096853167656, -0.4922739560569166, -7.270714979153506, -3.155410468793823, -2.945777813265463, 1.2571542642507487, -1.679464646903852, 0.2584082065437405, 2.8546756903339436, 0.3678581376393117, 0.09494793245505186, 4.930616460546062, 8.873509201282262, 6.183501910578913, -6.189191796171545, -5.443893670976362, 1.105083178636145, -5.199951403242299, 5.419667422782577, 1.1924823231051709, -2.534010017240454, -8.409182644095928, -2.0706490667754043, -2.7896295452251882, 3.0946676684680425, 4.077762294289671]
+```
+Содержание файла Res11.bin:
+    70.51602901426054
+    -10.646810897306677
+    -49.126695096564546
+    -74.14206506030918
+    -43.0932652150505
+    22.753094848963002
+
+![](ris_mod1.PNG)
+
+#### TAU = 5
+```py
+>>> import M0
+Файл: Module3.txt
+TAU( >= 0): 5
+
+K = 2.2102531022548
+
+SPS1: [1.013730859996645, 1.1622920644177825, 1.273646442808633, 0.21248586687379428, -1.1523479581850355, -1.360616118775768, 0.6524990997608467, 1.0573791084769346, 1.6392203056166974, 0.10772213728812277, 0.6181963059257979, 0.1945573917027522, 0.6888279764146823, -0.3326205381187334, -0.4522744459567869, -0.16826145088067945, 0.8325962782411906, 0.9102286183531867, 0.7101191479987133, -1.1359571874176229, -0.8402059962355454, 1.8084747627951145, 0.10629509815718377, -1.19463701949163, 0.22088254388926362, -0.12362028165790014, 2.1956771204119256, -2.5064708981455897, 0.5176854451628432, 0.9676355683721376, -0.44939615792932314, -0.02858757809420117, -0.6853145249358178, -0.6293072773615062, 0.002320599144324781, -1.846775887488841, -1.458084841773266, -0.32698341639668227, -1.1952981442450172, -0.21492653663929723, 1.191057170307932, -0.5726353697396429, -0.06521701240008655, -3.4296706580246337, -1.1402574039309377, 0.15466174828191878, -2.0255059170841925, -0.19957611416804957, 0.4307987726537539, 0.26646772839606614]
+
+SPS2: [0, 0, 0, 0, 0.5889611233381946, 2.240601778159011, 2.5689596411055398, 2.8150810013935716, 0.46964754644310425, -2.546980649455459, -3.0073059975020264, 1.4421881594648758, 2.3370754547705594, 3.6230917657683666, 0.2380931881225908, 1.366370302974952, 0.43002107857761035, 1.5224841717904478, -0.7351755762505914, -0.9996409972465591, -0.37190039379891543, 1.8402485069083923, 2.0118356274762315, 1.5695430498346916, -2.5107528975184383, -1.857067909712699, 3.9971869548174155, 0.2349390704563939, -2.6404501783998033, 0.4882063278651769, -0.27323211103598594, 4.853002166940344, -5.539935078337664, 1.1442158611633313, 2.1387195168466038, -0.9932792522046745, -0.0631857831686595, -1.5147185547596658, -1.3909283620597908, 0.005129111457833681, -4.0818421344915725, -3.22273654488006, -0.72271611047664, -2.641911431436955, -0.47504204436388664, 2.6325378056359305, -1.2656691024278701, -0.14414610397708105, -7.580440211611208, -2.5202574644073596]
+```
+Содержание файла Res11.bin:
+    23.45737243744806
+    10.172485818686237
+    4.857513581645703
+    50.38548475177254
+    13.61230247565784
+    12.849079271984197
+    16.20015952823841
+    -8.850984375289894
+    -1.6704003233050906
+    7.732952544085946
+    -6.588587800007123
+
+![](ris_mod2.PNG)
+
+#### TAU = 10
+
+```py
+>>> import M0
+Файл: Module3.txt
+TAU( >= 0): 10
+
+K = 2.5784299913700917
+
+SPS1: [-0.5014613246795419, -0.18870490479490082, -0.13626806920529586, 0.2261511688847735, 0.7592506218693422, 1.6743041964480039, 1.8071253642769052, -1.108127833798599, -1.5496935067426554, -0.21247741721223165, 0.3407805659376554, 2.1362311913147174, 0.7156055184882569, 2.7037350954655435, 0.7813669773259138, -0.773139567601898, -0.18829541770516456, 0.39275646367826605, -1.455517924364738, -0.947923033482155, 0.5337189005586409, -1.0949801541626745, 1.017332251419648, 1.5376809668965432, -0.49332423350979526, -0.11677704415558252, -1.724756294166204, -0.7485252939132131, -0.6987963135966981, 0.29822166543747597, -0.39840197681828055, 0.061299498326972866, 0.6771851019911601, 0.08726317013839653, 0.022523513105582402, 1.169638996828948, 2.1049705414301845, 1.4668480157506334, -1.4681977682876417, -1.2913984251492696, 0.2621474192558423, -1.2335305314285219, 1.2856514835931687, 0.2828802116923358, -0.6011169106816681, -1.9948231688056435, -0.49119859892321777, -0.6617548797215154, 0.7341159094871207, 0.9673252497663668]
+
+SPS2: [0, 0, 0, 0, 0, 0, 0, 0, 0, 2.494180435407165, -1.292982919065906, -0.48656238604181007, -0.35135767650503, 0.5831149564359026, 1.9576745743943047, 4.317076154798335, 4.6595462374171746, -2.85723004093828, -3.995776215216752, -0.5478581450288739, 0.8786788316897237, 5.508122572186127, 1.8451387308600662, 6.971391658868235, 2.0147000486033306, -1.993486248619638, -0.48550655224855527, 1.0126950452524992, -3.7529510691587853, -2.444153179040904, 1.3761568201614713, -2.8233296694480865, 2.6231199882484786, 3.964802722205008, -1.2720019991513185, -0.3011014329543034, -4.447163356682477, -1.9300200671249415, -1.8017973728365861, 0.7689436862403255, -1.0272516056493866, 0.1580564649422076, 1.7460743766830216, 0.2250019750268726, 0.05807530170245098, 3.015832268499787, 5.427519174974128, 3.7821649165931417, -3.785645159015492, -3.329780430212981]
+```
+Содержание файла Res11.bin:
+    -16.11211884532821
+    0.3568522559384131
+    16.283760887924394
+    -5.701608122186913
+    -3.5559996081982232
+    -28.22012710792737
+    -27.61707232499191
+    5.833577836951397
+    9.948552363454644
+    18.74098231999325
+    13.736862756449407
+    -9.615379698407144
+    -14.780903931442744
+    13.695993840662723
+    13.229683934983361
+    -0.027848109072340366
+
+![](ris_mod3.PNG)
+