test

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+ #Программа по Теме 1 <Зеленкина КМ>
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r'C:\\Users\\user\\python-labs\\TEMA1')

TEMA1/protocol.py

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

TEMA1/report.md

@@ -0,0 +1,156 @@
+# Отчёт по теме 1
+Зеленкина Катерина, А-02-23
+
+## Пункты 1-2. Запуск программы
+Запустила программу-интерпретатор IDLE  
+![Скриншот иконки программы](image1.png)
+
+## Пункты 3-5. Изучение диалогового окна
+
+Ввела инструкции вывода и ввода, а затем завершила работу интерпретатора:
+
+```py
+>>> print('Hello')
+Hello
+>>> h=input('Your name=')
+Your name=Katerina
+>>> exit()
+```
+
+	
+## Пункты 6-8. Интерактивная графическая оболочка IDLE среды Python
+Запустила обратно ярлык «IDLE (Python 3.Х GUI )» и изучила устройство главного командного окна среды
+
+Настроила рабочий каталог:
+
+```py
+>>> import os
+>>> os.chdir(r'C:\Users\user\python-labs\TEMA1')
+```
+
+## Пункт 9. Изучение предложений главного и выпадающих меню  
+
+Нажала "Options/Configure IDLE": 
+1) Нажала "Fonts",установила шрифт типа Arial CYR размером 11
+![Скриншот параметров шрифта](image3.png)
+
+2) Нажала "Windows", установила размер начального окна - высота 50, ширина 100
+![Скриншот начального окна](image4.png)
+
+3) Изменила подкраску комментариев: перешла в раздел "Highlights", нажала "#Click selects item/Choose color for/*Выбрала коричневый цвет*/OK"
+![Скриншот комментариев] (image5.png)
+
+## Пункт 10. Текстовый редактор
+Нажала "Файл/Новый файл". Вставила инструкции из п. п. 3,4 и 8. Сохранила как Pr0.py
+
+![Скриншот текстового редактора](image6.png)
+
+Запустила модуль "Run/Run Modul", или с помощью "import Pr0", или F5
+
+Результат:
+```py
+========================== RESTART: C:\Users\user\python-labs\TEMA1\Pr0.py =========================
+Hello
+Your name=Katerina
+>>> import Pr0
+Hello
+Your name=Katerina
+```
+
+## Пункт 11. Запуск файла prb1
+Запустила файл prb1.py 
+
+```py
+>>> import prb1
+Как Вас зовут? Katerina
+Привет, Katerina
+```
+
+## Пункт 12-13. Изучение каталога pycache
+
+Открыла файл Pr0.cpython-313.рус в текстовом редакторе
+
+![Cкриншот кода](image7.png)
+
+Вывод: Код представлен в двоичном коде. Компиляция перевела программу с языка программирования, понятный человеку, на машинный код понятный процессору.
+
+## Пункт 14. Раздел "HELP"
+
+Я спросила про функцию"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.
+```
+
+Также для обращения к оперативной помощи можно использовать F1 или нажать "Help/Python Docs"
+
+## Пункт 15. Перемещение между окнами
+## 15.1. Открытие и запуск файла prb1
+Открыла файл prb1.py в среде питон и запустила его:
+![Скриншот prb1](image8.png)
+
+Результат:
+```py
+============================================================== RESTART: C:\Users\user\python-labs\TEMA1\prb1.py =============================================================
+Как Вас зовут?  Katerina
+Привет,  Katerina
+```
+
+## 15.2. Запуск файла tdemo_chaos
+Запустила файл tdemo_chaos, результат:
+![Скриншот графика](image9.png)
+
+## 15.3. Turtle Demo
+Нажала на "Help/Turtle Demo/Examples/ Clock/Start"
+![Скриншот часов](image10.png)
+
+Также посмотрела примеры других программ. Пример:
+![Скриншот дерева](image11.png)
+
+## Пункт 16. Выход из среды
+
+
+

TEMA1/vopros.md

@@ -0,0 +1,9 @@
+# Индивидуальное контрольное задание по Теме 1
+Зеленкина Катерина, А-02-23
+
+## Вопрос
+12) Если требуется повторить с небольшим изменением ранее введенную инструкцию, работая в командном окне IDLE, как это лучше сделать?
+
+## Ответ
+
+Перейти на строку с инструкцией, которую нужно повторить, нажать "Enter" (тогда скопируется инструкция) и внести нужные изменения

TEMA2/report.md

@@ -0,0 +1,810 @@
+# Отчёт по теме 2
+Зеленкина Катерина, А-02-23
+
+## Пункт 1. Запуск оболочки IDLE
+
+Установим рабочий каталог:
+
+```py
+>>> import os
+>>> os.chdir(r'C:\Users\user\python-labs\TEMA2')
+```
+## Пункт 2. Простые объекты
+Рассмотрела операции присваивания:
+
+```py
+f1=16; f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+```
+
+Просмотрела уже существующие объекты в данный момент в среде Python:
+
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+
+Просмотрела список атрибутов объекта f1:
+
+```py
+>>> dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+```
+
+Определила классовую принадлежность объекта f2:
+
+```py
+>>> type(f2)
+<class 'int'>
+```
+
+Удалила объекты f1 и f2:
+
+```py
+>>> del f1,f2
+>>> f1;f2
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    f1;f2
+NameError: name 'f1' is not defined
+```
+
+## Пункт 3. Правила именования объектов в Python.
+
+Выполнила следующие предложенные операции. Последние две из них имели недопустимые имена:
+
+```py
+>>> gg1=1.6
+>>> gg1
+1.6
+>>> hh1='Строка'
+>>> hh1
+'Строка'
+>>> 73sr=3 - неправильное именование
+SyntaxError: invalid decimal literal
+>>> and=7 - неправильное именование
+SyntaxError: invalid syntax
+```
+
+## Пункты 4-5. Список ключевых слов и встроенных идентификаторов 
+
+Вывела список ключевых слов и сохранила его в переменную
+
+```py
+>>> import keyword
+>>> keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> a = keyword.kwlist
+>>> a
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+Вывела список встроенных идентификаторов:
+
+```py
+>>> import builtins
+>>> dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+
+### Функция abs()
+
+```py
+>>> help (abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+
+>>> abs(-1)
+1
+```
+
+### Функция len()
+
+```py
+>>> help (len)
+Help on built-in function len in module builtins:
+
+len(obj, /)
+    Return the number of items in a container.
+
+>>> b=[0,1,2,3,4,5,6,7,8,9,10]
+>>> b
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+>>> len(b)
+11
+```
+
+### Функции max()/min()
+
+```py
+>>> 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 positional arguments, return the largest argument.
+
+>>> 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 positional arguments, return the smallest argument.
+
+>>> max(b)
+10
+>>> min(b)
+0
+```
+
+### Функция pow()
+
+```py
+>>> 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(6,2)
+36
+```
+
+### Функция round()
+
+```py
+>>> help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+>>> round(3.8)
+4
+```
+
+### Функция sorted()
+
+```py
+>>> help(sorted)
+Help on built-in function sorted in module builtins:
+
+sorted(iterable, /, *, key=None, reverse=False)
+    Return a new list containing all items from the iterable in ascending order.
+
+    A custom key function can be supplied to customize the sort order, and the
+    reverse flag can be set to request the result in descending order.
+
+>>> c=[10, 4, 9, 1, 23]
+>>> c
+[10, 4, 9, 1, 23]
+>>> sorted(c)
+[1, 4, 9, 10, 23]
+```
+
+### Функция sum()
+
+```py
+>>> help(sum)
+Help on built-in function sum in module builtins:
+
+sum(iterable, /, start=0)
+    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+
+    When the iterable is empty, return the start value.
+    This function is intended specifically for use with numeric values and may
+    reject non-numeric types.
+
+>>> sum(c)
+47
+```
+
+### Функция zip()
+
+```py
+>>> help(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(*iterables, strict=False)
+ |
+ |  The zip object yields n-length tuples, where n is the number of iterables
+ |  passed as positional arguments to zip().  The i-th element in every tuple
+ |  comes from the i-th iterable argument to zip().  This continues until the
+ |  shortest argument is exhausted.
+ |
+ |  If strict is true and one of the arguments is exhausted before the others,
+ |  raise a ValueError.
+ |
+ |     >>> list(zip('abcdefg', range(3), range(4)))
+ |     [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+ |
+ |  Methods defined here:
+ |
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |
+ |  __next__(self, /)
+ |      Implement next(self).
+ |
+ |  __reduce__(self, /)
+ |      Return state information for pickling.
+ |
+ |  __setstate__(self, object, /)
+ |      Set state information for unpickling.
+ |
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |
+ |  __new__(*args, **kwargs)
+ |      Create and return a new object.  See help(type) for accurate signature.
+
+>>> c
+[10, 4, 9, 1, 23]
+>>> d=[1,2,3,4,5]
+>>> d
+[1, 2, 3, 4, 5]
+>>> h=zip(c,d)
+>>> h
+<zip object at 0x0000021067B5EC80>
+>>> list(h)
+[(10, 1), (4, 2), (9, 3), (1, 4), (23, 5)]
+```
+
+## Пункт 6. Регистр букв
+Проверила влияние больших и малых букв в имени переменных
+
+```py
+>>> Gg1=45
+>>> gg1
+1.6
+>>> Gg1
+45
+```
+
+## Пункт 7. Простые базовые типы объектов
+### 7.1 Логический тип (bool)
+
+```py
+>>> bb1=True; bb2=False
+>>> bb1;bb2
+True
+False
+>>> type(bb1)
+<class 'bool'>
+```
+
+### 7.2 Другие простые типы
+
+```py
+>>> ii1=-1234567890
+>>> type(ii1)
+<class 'int'>
+
+>>> ff1=-8.9876e-12
+>>> type(ff1)
+<class 'float'>
+
+>>> dv1=0b1101010 #Двоичное число
+>>> type(dv1)
+<class 'int'>
+```
+Двоичное число сохранено в объекте класса int
+
+```py
+>>> vsm1=0o52765 #Восьмеричное число
+>>> type(vsm1)
+<class 'int'>
+
+>>> shest1=0x7109af6 #Шестнадцатеричное число
+>>> type(shest1)
+<class 'int'>
+
+cc1=2-3j
+type(cc1)
+<class 'complex'>
+```
+
+Создание комплексного числа:
+
+```py
+a=3.67; b=-0.45
+cc2=complex(a,b)
+type(cc2)
+<class 'complex'>
+```
+
+### 7.3 Строка символов
+
+Строки выделяются апострофами:
+```py
+>>> ss1='Это - строка символов'
+>>> ss1
+'Это - строка символов'
+```
+
+Строки выделяются двойными кавычками:
+```py
+>>> ss1="Это - строка символов"
+>>> ss1
+'Это - строка символов'
+```
+
+Попробовала экранированные последовательности:
+
+```py
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+```
+
+Создала строку по шаблону:
+
+```py
+>>> ss1b= 'Меня зовут: \n Зеленкина К. М.'
+>>> print(ss1b)
+Меня зовут: 
+ Зеленкина К. М.
+```
+Многострочные строки:
+
+```py
+>>> mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Обратилась к частям строки с помощью индексов:
+
+```py
+>>> ss1[0]
+'Э'
+>>> ss1[8]
+'р'
+>>> ss1[-2]
+'о'
+```
+
+Выполнила операцию «разрезания»/«создания среза»:
+```py
+>>> ss1[6:9]
+'стр'
+>>> ss1[13:]
+'символов'
+>>> ss1[:13]
+'Это - строка '
+>>> ss1[5:-8]
+' строка '
+>>> ss1[3:17:2]
+'  тоасм'
+```
+
+При отрицательном значении шага перечислились элементы с индексами от 3 до 17 в обратном порядке:
+```py
+>>> ss1[17:3:-2]
+'омсаот '
+```
+
+Заменив 17 на -4, мы получим тот-же результат, т. к. символ под индексом 17 и  -4 один и тот же:
+
+```py
+>>> ss1[-4:3:-2]
+'омсаот '
+```
+
+Строка является неизменяемым объектом, поэтому нам выдаст ошибку при попытке внести изменения:
+
+```py
+ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#11>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+```
+
+```py
+>>> sk1=ss1b[:4]+' именовать'+ss1b[12:]; print(sk1)
+Меня именовать
+ Зеленкина К. М.
+```
+Самостоятельно придумала значения и создала объекты разных типов:
+
+```py
+>>> flag = True
+>>> type(flag)
+<class 'bool'> 
+
+>>> n=16
+>>> type(n)
+<class 'int'>
+
+>>> k = 'Привет'
+>>> type(k)
+<class 'str'>
+```
+
+## Пункт 8. Сложные типы объектов
+### 8.1 Списки
+
+__Список__ — это упорядоченная коллекция элементов произвольных типов (числа, строки, другие объекты).
+
+Список с элементами разных типов:
+
+```py
+>>> spis1=[111, 'Spisok' ,5-9j]
+>>> spis1
+[111, 'Spisok', (5-9j)]
+```
+
+Вводить элементы в списках можно на разных строках до закрытия квадратной скобкой:
+
+```py
+>>> stup=[0,0,1,1,1,1,1,1,1]; stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+>>> spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+В списках тоже можно обращаться к элементам по индексам:
+
+```py
+>>> spis1[-1]
+(5-9j)
+
+>>> stup[-8::2]
+[0, 1, 1, 1] 
+```
+
+Пояснение: Вошло 4 элемента. Элемент под индексом '-8' есть элемент с индексом 1, срез произойдёт до последнего элемента с шагом 2
+
+Заменила второй элемент в spis1:
+
+```py
+>>> spis1[1]='Список'
+>>> spis1
+[111, 'Список', (5-9j)]
+>>> len(spis1)
+3
+```
+
+Добавление элементов в список:
+
+
+```py
+>>> help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+>>> spis1.append('New item')
+spis1
+[111, 'Список', (5-9j), 'New item']
+
+
+>>> spis1.append(ss1b)
+>>> spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.']
+>>> spis1.pop(1)
+'Список'
+>>> spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.']
+```
+
+### Другие методы:
+__insert__ - вставляет элемент в нужную позицию
+
+```py
+>>> spis1.insert(0, 24); spis1
+[24, 111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.']
+```
+__remove__ - удалит элемент, указанный в скобках
+
+```py
+>>> spis1.remove(24); spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.']
+```
+
+__extend__ - добавляет каждый элемент аргумента
+
+```py
+>>> spis1.extend('24'); spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.', '2', '4']
+```
+
+__clear__ - удаляет всё из списка
+
+```py
+>>> spis1.clear(); spis1
+[]
+```
+
+__sort__ - сортирует элементы в списке по возрастанию, а буквы по алфавиту
+
+```py
+>>> spis1=[20, 4, 63, 2, 1, 0, 13, 7]; spis1
+[20, 4, 63, 2, 1, 0, 13, 7]
+>>> spis1.sort()
+>>> spis1
+[0, 1, 2, 4, 7, 13, 20, 63]
+
+>>> spis2 = ['д', 'с','г','а','ш']
+>>> spis2.sort()
+>>> spis2
+['а', 'г', 'д', 'с', 'ш']
+```
+
+__reverse__ - сортирует элементы в обратном порядке
+
+```py
+>>> spis1.reverse(); spis1
+[63, 20, 13, 7, 4, 2, 1, 0]
+
+>>> spis2.reverse();spis2
+['ш', 'с', 'д', 'г', 'а']
+```
+
+__copy__ - копирует список
+
+```py
+>>> vv=spis1.copy(); vv
+[63, 20, 13, 7, 4, 2, 1, 0]
+```
+
+__count__ - cчитает количество заданного аргумента в скобках в списке
+
+```py
+>>> spis2.count('д')
+1
+```
+
+__index__ - выдаёт индекс элемента
+
+```py
+>>> spis1.index(20)
+1
+```
+
+#### Вложенные списки
+
+```py
+>>> spis2=[spis1,[4,5,6,7]]; spis2
+[[63, 20, 13, 7, 4, 2, 1, 0], [4, 5, 6, 7]]
+>>> spis2[0][1] #обращение к элементу списка spis1
+20
+>>> spis2[0][1]=78; spis2 #Замена значения элемента на 78
+[[63, 78, 13, 7, 4, 2, 1, 0], [4, 5, 6, 7]]
+
+>>> spis1
+[63, 78, 13, 7, 4, 2, 1, 0]
+```
+
+Пояснение: Список spis1 отличается от первоначального, потому что он лежит в другом списке, в котором мы и поменяли значение
+
+Создала список с разными типами данных
+
+```py
+>>>spisok = [89, 'дом', True, ['яблоко', 'помидор', 'хлеб']]; spisok
+          
+[89, 'дом', True, ['яблоко', 'помидор', 'хлеб']]
+>>> type(spisok)
+          
+<class 'list'>
+```
+
+### 8.2 Кортежи
+
+__Кортеж__ – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки.
+
+```py
+>>> kort1=(222,'Kortezh',77+8j); kort1
+          
+(222, 'Kortezh', (77+8j))
+```
+
+Переопределим кортеж:
+
+1. Добавим элементы
+
+```py
+>>> kort1= kort1+(1,2)          
+>>> kort1         
+(222, 'Kortezh', (77+8j), 1, 2)
+
+>>> kort1= kort1+(ss1b,); kort1        
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Зеленкина К. М.')
+```
+
+2. Удалим элементы:
+
+```py
+>>> kort2=kort1[:2]+kort1[3:]; kort2      
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n Зеленкина К. М.')
+```
+
+Узнала индекс заданного элемента:
+
+```py
+>>> kort1.index(2)         
+4
+```
+
+Подсчитала количество вхождений заданного элемента в кортеже:
+
+```py
+>>> kort1.count(222)         
+1
+```
+
+Т. к. кортежи неизменяемы, то у них отсутствуют методы append и pop.
+Попробуем заменить элемент в кортеже (выдаст ошибку):
+
+```py
+>>> kort1[2]=90          
+Traceback (most recent call last):
+  File "<pyshell#161>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+
+### Создаю объект-кортеж с разными типами данных:
+
+```py
+>>> kort2=(23, 'Тыква', [4, 5, 6, 7], (4, 6, 8, 10))   
+kort2         
+(23, 'Тыква', [4, 5, 6, 7], (4, 6, 8, 10))
+type(kort2)
+          
+<class 'tuple'>
+```
+
+## 8.3 Словарь
+__Словарь__ - совокупность пар: «ключ (key)»:«значение (value)».
+
+Создадим словарь:
+
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}; dic1         
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+```
+В словарях обращение к элементам происходит по ключам:
+
+```py
+>>> dic1['Orel']         
+56
+```
+Изменение словаря, добавление элемента:
+
+```py
+ >>> dic1['Pskov']=78
+ >>> dic1
+{'Saratov': 120, 'Vologda': 45, 'Pskov': 78, 'Orel': 56}
+```
+Отобразим сортированный словарь с помощью функции sorted (Отображает, но не сортирует):
+
+```py
+>>> sorted(dic1.keys())        
+['Orel', 'Saratov', 'Vologda']
+>>> sorted(dic1.values())        
+[45, 56, 145]
+```
+
+Элементы словаря могут быть любого типа, даже словарём:
+
+```py
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}         
+>>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']} 
+>>> dic3        
+{'statistics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']}  
+    
+>>> dic3['statistics'][2]         
+'standart deviation'
+```
+
+Создадим более сложный словарь: 
+
+```py
+>>> dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)]); dic4      
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Зеленкина К. М.'}
+
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b])); dic5         
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Зеленкина К. М.'}
+```
+
+Создадим свой объект-кортеж и объект-список:
+
+```py
+>>> spisok01=(1, 5, 7, 9, 3, 0,10); spisok01         
+(1, 5, 7, 9, 3, 0, 10)
+>>> spisok02=[22,10,7,45,100]; spisok02             
+[22, 10, 7, 45, 100]
+>>>spisok03=dict(zip(spisok01,spisok02)); spisok03             
+{1: 22, 5: 10, 7: 7, 9: 45, 3: 100}
+
+>>> len(spisok03)           
+5 #Элементов 5, потому что в spisok02 всего пять элементов
+```
+
+Пример словаря с описанием состава студентов, обучающихся на АВТИ:
+
+```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             
+{'датчик', 'двигатель', 'реле', 'микропроцессор'}
+```
+
+Создадим своё множество:
+
+```py
+>>> mnoz2={5, 'яблоко', False, (10, 6, 0)}; mnoz2             
+{False, 5, (10, 6, 0), 'яблоко'}
+
+>>> mnoz2.add(100); mnoz2            
+{False, 100, 5, (10, 6, 0), 'яблоко'}
+
+>>> mnoz2.remove('яблоко'); mnoz2             
+{False, 100, 5, (10, 6, 0)}
+
+>>>False in mnoz2            
+True
+```
+
+## 9. Конец сеанса
+

TEMA2/task.md

@@ -0,0 +1,40 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-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, в котором ключами являются русские названия типов перемен-ных, использованных в предыдущих операторах, а значениями – ранее созданные перемен-ные, соответствующие этим типам.
+
+
+## Решение
+
+```py
+>>> familia = 'Zelenkina'
+>>> b = familia[0]; b
+'Z'
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> sp_kw.remove('nonlocal'); sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> sp_kw.count('nonlocal')
+0
+>>> kort_nam = ('Kate', 'Ksenia', 'Nasty', 'Liza')
+>>> type(kort_nam)
+<class 'tuple'>
+>>> kort_nam=kort_nam+('Dana', 'Dima'); kort_nam
+('Kate', 'Ksenia', 'Nasty', 'Liza', 'Dana', 'Dima')
+>>> kort_nam.count('Dima')
+1
+>>> a=['Строка', 'Список', 'Кортеж']
+>>> c = [familia, sp_kw, kort_nam]
+>>> dict_bas = dict(zip(a, c)); dict_bas
+{'Строка': 'Zelenkina', 'Список': ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'], 'Кортеж': ('Kate', 'Ksenia', 'Nasty', 'Liza', 'Dana', 'Dima')}
+```

TEMA2/task.py

@@ -0,0 +1,14 @@
+familia = 'Zelenkina'
+b = familia[0]; b
+import keyword
+sp_kw = keyword.kwlist
+sp_kw.remove('nonlocal')
+print(sp_kw)
+sp_kw.count('nonlocal')
+kort_nam = ('Kate', 'Ksenia', 'Nasty', 'Liza')
+type(kort_nam)
+kort_nam=kort_nam+('Dana', 'Dima'); kort_nam
+kort_nam.count('Dima')
+a=['Строка', 'Список', 'Кортеж']
+c = [familia, sp_kw, kort_nam]
+dict_bas = dict(zip(a, c)); dict_bas

TEMA2/test.md

@@ -0,0 +1,33 @@
+# Индивидуальное контрольное задание по теме 2
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+
+Предполагается выполнить следующие инструкции:
+```py 
+s=(1,2,3,4,5)
+d=[11,22,33,44,55]
+sd=(s,d)
+```
+Объекты каких классов будут созданы в результате их выполнения? Какое значение будет выведено по инструкции: print(sd[1][3])
+
+## Решение
+
+```py
+s=(1,2,3,4,5)
+d=[11,22,33,44,55]
+sd=(s,d);sd
+((1, 2, 3, 4, 5), [11, 22, 33, 44, 55])
+```
+Будут созданы два кортежа(s,sd) и один список (d):
+
+```py
+type(s), type(d), type(sd)
+(<class 'tuple'>, <class 'list'>, <class 'tuple'>)
+```
+По инструкции "print(sd[1][3])" будет выведено значение "44":
+```py
+print(sd[1][3])
+44
+```

TEMA3/report.md

@@ -0,0 +1,697 @@
+# Отчёт по теме 3
+Зеленкина Катерина Михайловна, А-02-23
+
+## Пункт 1. Запуск оболочки IDLE
+
+Установим рабочий каталог:
+
+```py
+import os
+os.chdir(r'C:\Users\user\python-labs\TEMA3')
+```
+
+## Пункт 2. Простые базовые типы объектов.
+### Пункт 2.1. Логический тип bool.
+
+Воспользумеся функцией __bool__:
+
+```py
+>>> logiz1=bool(56); logiz1
+True
+>>> logiz2=bool(0); logiz2
+False
+>>> logiz3=bool("Beta"); logiz3
+True
+>>> logiz4=bool(""); logiz4
+False
+```
+
+### Пункт 2.2. Преобразование в целое десятичное число.
+Преобразуем с помощью функции __int__:
+
+```py
+>>> tt1=int(198.6); tt1 #Отбрасывается дробная часть
+198
+>>> tt2=int("-76"); tt2 #Число – в строке символов, система по умолчанию - десятичная
+-76
+>>> tt3=int("B",16); tt3
+11
+>>> tt4=int("71",8); tt4
+57
+tt5=int("98.76"); tt5
+Traceback (most recent call last):
+  File "<pyshell#11>", line 1, in <module>
+    tt5=int("98.76"); tt5
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+__Пояснение__: Последняя функция выдаёт ошибку, потому что функция int() работает только с целочисленными строками. Для чисел с плавающей точкой нужно сначала использовать float(), а потом преобразовать в целое число.
+
+#### Функция float
+
+Примеры преобразований:
+
+```py
+>>> flt1=float(789); flt1
+789.0
+>>> flt2=float(-6.78e2); flt2
+-678.0
+>>> flt3=float("Infinity"); flt3
+inf
+>>> flt4=float("-inf"); flt4
+-inf
+```
+
+## Пункт 2.3. Преобразование в другие системы счисления.
+
+```py
+>>> hh=123
+>>> dv1=bin(hh); dv1
+'0b1111011'
+>>> vos1=oct(hh); vos1
+'0o173'
+>>> shs1=hex(hh); shs1
+'0x7b'
+```
+
+Для проверки выполним обратные преобразования:
+
+```py
+>>> int(dv1,2)
+123
+>>> int(vos1,8)
+123
+>>> int(shs1,16)
+123
+```
+
+## Более сложные базовые типы объектов.
+### Пункт 3.1. Преобразование в строку.
+
+Воспользуемся функцией __str__:
+
+```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. Преобразование в список.
+
+Воспользуемся функцией __list__:
+
+```py
+>>> spis1=list("Строка символов"); spis1 #Строка разделяется на символы
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+
+>>> spis2=list((124,236,-15,908)); spis2 #Преобразование кортежа в список
+[124, 236, -15, 908]
+
+>>> spis3=list({"A":1,"B":2,"C":9}); spis3 #Преобразование словаря в список
+['A', 'B', 'C']
+```
+
+### Пункт 3.3. Преобразование в кортеж.
+
+Воспользуемся функцие __tuple__:
+```py
+kort7=tuple('Строка символов'); kort7 #Преобразование строки символов в кортеж
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8=tuple(spis2); kort8 #Преобразование списка в кортеж 
+(124, 236, -15, 908)
+kort9=tuple({"A":1,"B":2,"C":9}); kort9 #Преобразование словаря в кортеж
+('A', 'B', 'C')
+```
+
+### Пункт 3.4 Удаление объектов.
+
+Воспользуемся функцией __del__:
+
+```py
+>>> del strk5, kort8
+>>> strk5
+Traceback (most recent call last):
+  File "<pyshell#37>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+>>> kort8
+Traceback (most recent call last):
+  File "<pyshell#38>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+```
+#### Создание своей строки.
+
+```py
+>>> a = 'Zelenkina K.M.'
+>>> spisok = list(a); spisok, type(spisok) #Преобразование в список
+(['Z', 'e', 'l', 'e', 'n', 'k', 'i', 'n', 'a', ' ', 'K', '.', 'M', '.'], <class 'list'>)
+>>> kort = tuple(spisok); kort; type(kort) #Преобразование в кортеж
+('Z', 'e', 'l', 'e', 'n', 'k', 'i', 'n', 'a', ' ', 'K', '.', 'M', '.')
+<class 'tuple'>
+>>> str0 = str(kort); str0; type(str0) #Преобразование в строку
+"('Z', 'e', 'l', 'e', 'n', 'k', 'i', 'n', 'a', ' ', 'K', '.', 'M', '.')"
+<class 'str'>
+```
+
+## Пункт4. Арифметические операции.
+### Пункт 4.1. Сложение и вычитание.
+
+```py
+>>> 12+7+90 # Сложение целых чисел
+109
+>>> 5.689e-1 - 0.456 #Вычитание вещественных чисел
+0.11289999999999994
+>>> 23.6+54 #Сложение вещественного и целого чисел
+77.6
+>>> 14-56.7+89 # Сложение и вычитание целых и вещественных чисел
+46.3
+```
+
+### Пункт 4.2. Умножение.
+Умножение вещественного числа на целое число:
+```py
+>>> -6.7*12
+-80.4
+```
+
+### Пункт 4.3. Деление.
+
+Результатом деления всегда будет __вещественное число__!
+```py
+>>> -234.5/6 #Деление вещественного числа на целое
+-39.083333333333336
+
+>>> a=178/45; a; type(a)  #Деление двух целых чисел
+3.9555555555555557
+<class 'float'>
+```
+
+### Пункт 4.4. Деление с округлением вниз.
+
+```py
+>>> b=178//45; b; type(b) #Деление двух целых чисел
+3
+<class 'int'>
+>>> c=-24.6//12.1; c; type(c) #Деление двух вещественных чисел
+-3.0
+<class 'float'>
+
+>>> f = 100//20.5; f; type(f)
+4.0
+<class 'float'>
+>>> p= 25.3//9; p; type(p)
+2.0
+<class 'float'>
+```
+
+## Пункт 4.5. Остаток от деления.
+
+```py
+>>> 148%33
+16
+>>> 12.6%3.8
+1.2000000000000002
+
+>>> 45.3%9
+0.29999999999999716
+>>> 70%10.5
+7.0
+```
+
+## Пункт 4.6. Возведение в степень.
+
+```py
+>>> 14**3
+2744
+>>> e=2.7**3.6; e
+35.719843790663525
+
+>>> 2.7**3
+19.683000000000003
+>>> 3**2.7
+19.419023519771343
+```
+
+### Операции с комплексными числами.
+
+```py
+>>> k=1+2j
+>>> n=3+4j
+>>> k+n
+(4+6j)
+>>> k-n
+(-2-2j)
+>>> k*n
+(-5+10j)
+>>> k/n
+(0.44+0.08j)
+>>> k//n
+Traceback (most recent call last):
+  File "<pyshell#75>", line 1, in <module>
+    k//n
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+>>> k%n
+Traceback (most recent call last):
+  File "<pyshell#76>", line 1, in <module>
+    k%n
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+```
+__Вывод:__ к комплексным числа нельзя применять деление с округлением вниз и определения остатка
+
+
+## Пункт 5. Операции с двоичными представлениями целых чисел. 
+### Пункт 5.1. Двоичная инверсия.
+
+Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+
+```py
+>>> dv1=9
+>>> dv2=~dv1; dv2
+-10
+```
+
+### Пункт 5.2. Двоичное «И»
+
+```py
+>>> 7&9
+1
+>>> 7&8
+0
+```
+
+### Пункт 5.3. Двоичное «ИЛИ»
+
+```py
+>>> 7|9
+15
+>>> 7|8
+15
+>>> 14|5
+15
+```
+
+### Пункт 5.4. Двоичное «исключающее ИЛИ»
+
+```py
+>>> 14^5
+11
+>>> bin(11)
+'0b1011' - двоичное
+```
+
+В десятичном представлении получилось число «11»
+
+### Пункт 5.5. Сдвиг двоичного представления
+
+```py
+>>> h=14
+>>> bin(h)
+'0b1110'
+>>> g=h<<2; g; bin(g)
+56
+'0b111000'
+>>> g1=h>>1; g1; bin(g1)
+7
+'0b111'
+>>> g2=h>>2; g2; bin(g2)
+3
+'0b11'
+```
+
+Придумала свои два двоичных знака:
+
+```py
+>>> a = 0b11011011
+>>> b = 0b01101101
+>>> bin(~a); bin(~b)
+'-0b11011100'
+'-0b1101110'
+>>> bin(a&b)
+'0b1001001'
+>>> bin(a|b)
+'0b11111111'
+>>> bin(a^b)
+'0b10110110'
+>>> n=a<<2; n; bin(n)
+876
+'0b1101101100'
+>>> n1=b>>3;n1;bin(n1)
+13
+'0b1101'
+```
+
+## Пункт 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
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+```
+
+Пример. Создание списка со 100 отсчетами сигнала-ступеньки:
+
+```py
+>>> 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. Подстановка значений в строку.
+__Пример1__
+
+```py
+>>> stroka='Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+```
+__Пример 2.__ Вставка с использованием данных из словаря.
+
+```py
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+## Пункт 7.Оператор присваивания
+### Пункт 7.1. Обычное присваивание значения переменной (=)
+
+```py
+>>> zz=-12; zz
+-12
+```
+
+### Пункт 7.2. Увеличение (+=) или уменьшение (-=)
+```py
+>>> zz+=5; zz
+-7
+>>> zz-=3;zz
+-10
+```
+Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
+
+```py
+>>> stroka='Система'
+>>> stroka+=' регулирования'; stroka
+'Система регулирования'
+```
+
+### Пункт 7.3. Умножение (*=) или деление (/=)
+
+```py
+>>> zz/=2; zz
+-5.0
+>>> zz*=5; zz
+-25.0
+```
+Для строк операция (*=) означает повторение текущего значения объекта заданное число раз:
+
+```py
+>>> stroka='Арбуз'
+>>> stroka*=4; stroka
+'АрбузАрбузАрбузАрбуз'
+```
+### Пункт 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) 
+
+```py
+>>> zz=10
+>>> zz//=4; zz #округление вниз
+2
+>>> zz%=6; zz #остаток от деления
+2
+>>> zz**=2;zz #возведение в степень
+4
+```
+
+### Пункт 7.5. Множественное присваивание
+
+```py
+>>> w=v=10; w; v
+10
+10
+>>> n1,n2,n3=(11,-3,'all'); n1;n2;n3
+11
+-3
+'all'
+```
+
+```py
+>>> n1,n2,n3='yes'; n1;n2;n3
+'y'
+'e'
+'s'
+
+>>> n1,n2,n3=[11,-3,'all']; n1;n2;n3
+11
+-3
+'all'
+
+>>> n1,n2,n3 = {'a1': 11, 'a2': -3, 'stroke': 'all'}; n1; n2; n3 #берутся ключи
+'a1'
+'a2'
+'stroke'
+
+>>> n = {'a1': 11, 'a2': -3, 'a3': 'all'}
+>>> n1,n2,n3=n.values(); n1;n2;n3
+11
+-3
+'all'
+
+>>> n1,n2,n3 = {11, -3, 'all'}; n1;n2;n3
+11
+'all'
+-3
+```
+
+## Пункт 8. Логические операции 
+### Пункт 8.1. Операции сравнение
+
+```py
+>>> w
+10
+>>> v
+10
+>>> w==v
+True
+>>> z=8
+>>> w!=z
+True
+>>> v<z
+False
+>>> w>z
+True
+>>> v<=z
+False
+>>> w>=z
+True
+```
+
+### Пунтк 8.2. Проверка наличия заданного элемента
+Операции с множеством:
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+```
+
+Операции со словарем:
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>>'Vologda' in dic1
+True
+>>> 'Pskov' in dic1
+False
+>>> 56 in dic1.values()
+True
+```
+
+Ещё пример работы со словарем:
+```py
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>> 'UII' in dct1['Depart']
+True
+>>> dct1['Depart'][1] == 'MM'
+False
+```
+
+### Пункт 8.3. Большие логические выражения
+
+```py
+>>> a=17
+>>> b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+```
+Придумала ещё 2 примера:
+```py
+>>> (a>b) and ('Piter' in dic1) and not ('pen' in mnoz1)
+False
+>>> not (a==b) and ('table' in mnoz1) and (b<a)
+True
+```
+
+### Пункт 8.4. Проверка ссылок 
+
+```py
+>>> w=v=10 
+>>> w is v
+True
+>>> w1=['A','B']
+>>> v1=['A','B']
+>>> w1 is v1
+False 
+```
+
+## Пункт 9. Операции с объектами с помощью методов
+
+```py
+>>> stroka='Микропроцессорная система управления' #получение полного списка атрибутов
+>>> dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+### Пункт 9.1. Методы для работы со строками
+
+```py
+>>> stroka.find('пр') 
+5
+>>> stroka.count("с")
+4
+>>> stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' '); spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3=" ".join(spis22); stroka3
+'Микропроцессорная система управления'
+>>> stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с")  
+('Микропроцессорная си', 'с', 'тема управления')
+```
+#### Метод format
+```py
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+>>> strk3='Момент времени {num}, значение = {znch}'
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+
+### 9.2. Методы для работы со списками
+
+```py
+>>> spsk=[1,10,'bob',['a','b','c'],'hehe']; spsk
+[1, 10, 'bob', ['a', 'b', 'c'], 'hehe']
+>>> spsk.pop(2)
+'bob'
+>>> spsk
+[1, 10, ['a', 'b', 'c'], 'hehe']
+>>> spsk.append('c'); spsk
+[1, 10, ['a', 'b', 'c'], 'hehe', 'c']
+>>> spsk.insert(2,'a'); spsk
+[1, 10, 'a', ['a', 'b', 'c'], 'hehe', 'c']
+>>> spsk.count('a')
+1
+```
+
+### 9.3. Методы с кортежами
+
+```py
+>>> kor = ('sweets', 56, 'hehe', [3,2,1], 120); kor; type(kor)
+('sweets', 56, 'hehe', [3, 2, 1], 120)
+<class 'tuple'>
+>>> dir(kor)
+['__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']
+>>> kor.count('hehe')
+1
+>>> kor.index(56)
+1
+>>> kor +=(10, 'home'); kor
+('sweets', 56, 'hehe', [3, 2, 1], 120, 10, 'home')
+>>>type(kor)
+<class 'tuple'>
+```
+
+### 9.4. Методы со словарями и множествами
+#### 9.4.1. Методы со словарями
+
+```py
+sl = {'Gorod':'Moscow', 'Name': 'Katy', 'Age':19}; type(sl)
+<class 'dict'>
+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.pop('Gorod')
+'Moscow'
+sl
+{'Name': 'Katy', 'Age': 19}
+sl.keys()
+dict_keys(['Name', 'Age'])
+sl.items()
+dict_items([('Name', 'Katy'), ('Age', 19)])
+sl.update({'Like': 'eat', 'Money':2000}); sl
+{'Name': 'Katy', 'Age': 19, 'Like': 'eat', 'Money': 2000}
+sl.values()
+dict_values(['Katy', 19, 'eat', 2000])
+```
+#### 9.4.2. Методы со множествами
+
+```py
+>>> mnoch={1,2,3,4,5,'a'}
+>>> type(mnoch)
+<class 'set'>
+>>> mnoch.add('hehe'); mnoch
+{1, 2, 3, 4, 5, 'a', 'hehe'}
+>>> mnoch.remove(1);mnoch
+{2, 3, 4, 5, 'a', 'hehe'}
+>>> mnoch1={'l','k',60}
+>>> mnoch2=mnoch.union(mnoch1);mnoch2
+{2, 3, 4, 5, 'a', 'k', 'hehe', 60, 'l'}
+```
+
+## Пункт 10. Закончила сеанс работы с IDLE

TEMA3/task.md

@@ -0,0 +1,58 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-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. Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+
+```py
+>>> a='45'
+>>> int(a,8)
+37
+
+>>> D = {"усиление":23, "запаздывание":12, "постоянная вре-мени":78}
+>>> keys = list(D.keys());keys
+['усиление', 'запаздывание', 'постоянная вре-мени']
+>>> values = list(D.values()); values
+[23, 12, 78]
+
+>>> M= tuple(keys + values); M
+('усиление', 'запаздывание', 'постоянная вре-мени', 23, 12, 78)
+
+>>> ((1768 // 24.8) % 3) ** 2.4
+5.278031643091577
+
+>>> ((~(13 & 27)) ^ 14) << 2
+-32
+
+>>> sp = ['колебат'] * 4; sp
+['колебат', 'колебат', 'колебат', 'колебат']
+>>> 'аткол' in sp[1]+sp[2]
+True
+
+>>> D.keys()
+dict_keys(['усиление', 'запаздывание', 'постоянная вре-мени'])
+>>> D.values()
+dict_values([23, 12, 78])
+
+>>> s='Создать объект - символьную строку с текстом данного предложения'
+>>> s1=s.split();s1
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+
+>>> s1[s1.index('-')]=','; s1
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+
+>>> s1.remove('данного');s1
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA3/task.py

@@ -0,0 +1,17 @@
+a='45'
+print(int(a,8))
+D = {"усиление":23, "запаздывание":12, "постоянная вре-мени":78}
+keys = list(D.keys())
+print(keys)
+values = list(D.values()); print(values)
+M= tuple(keys + values); print(M)
+print(((1768 // 24.8) % 3) ** 2.4)
+print(((13 & 27) ^ 14) << 2)
+sp = ['колебат'] * 4; print(sp)
+print('аткол' in sp[1]+sp[2])
+print(D.keys())
+print(D.values())
+s='Создать объект - символьную строку с текстом данного предложения'
+s1=s.split(); print(s1)
+s1[s1.index('-')]=','; print(s1)
+s1.remove('данного'); print(s1)

TEMA3/test.md

@@ -0,0 +1,53 @@
+# Индивидуальное контрольное задание по теме 2
+
+Зеленкина Катерина, А-02-23
+Вариант 8
+
+## Задание
+
+1. При каких условиях можно создавать программы для среды Python с помощью других текстовых редакторов? Назовите примеры таких редакторов.
+2. Создайте объект, содержащий текст задания данного пункта. Создайте новый объект, в который включите из первого объекта только слова, находящиеся на четных позициях. Напишите инструкции определения класса созданного объекта и списка его атрибутов.
+3. Создайте кортеж, содержащий слова из итогового созданного объекта в п.2. Напишите инструкции подсчета числа слов и отобразите с использованием формата результат на экране по шаблону: "в кортеже ХХ элементов".
+4. Напишите инструкции создания словаря, в котором ключами будут порядковые номера, а значениями - слова из кортежа, созданного в п.3.
+5. Преобразуйте значения из словаря во множество. Подсчитайте и выведите на экран число элементов этого множества. 
+
+## Решение
+#### Пункт 1.
+1. Программы для среды Python можно создавать в любых текстовых редакторах при условии сохранения файла с расширением .py. Например: Блокнот, Notepad++ и др.
+
+```py
+#Пункт 2.
+
+>>> text = "Создайте объект, содержащий текст задания данного пункта. Создайте новый объект, в который включите из первого объекта только слова, находящиеся на четных позициях. Напишите инструкции определения класса созданного объекта и списка его атрибутов."
+
+>> slova = text.split(); slova
+['Создайте', 'объект,', 'содержащий', 'текст', 'задания', 'данного', 'пункта.', 'Создайте', 'новый', 'объект,', 'в', 'который', 'включите', 'из', 'первого', 'объекта', 'только', 'слова,', 'находящиеся', 'на', 'четных', 'позициях.', 'Напишите', 'инструкции', 'определения', 'класса', 'созданного', 'объекта', 'и', 'списка', 'его', 'атрибутов.']
+>>> p = slova[1::2]
+['объект,', 'текст', 'данного', 'Создайте', 'объект,', 'который', 'из', 'объекта', 'слова,', 'на', 'позициях.', 'инструкции', 'класса', 'объекта', 'списка', 'атрибутов.']
+>>> text1 = ' '.join(p); text1
+'объект, текст данного Создайте объект, который из объекта слова, на позициях. инструкции класса объекта списка атрибутов.'
+
+>>> type(text1)
+<class 'str'>
+>>> dir(text1)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+
+
+#Пункт 3.
+>>> cort=tuple(slova); cort
+('Создайте', 'объект,', 'содержащий', 'текст', 'задания', 'данного', 'пункта.', 'Создайте', 'новый', 'объект,', 'в', 'который', 'включите', 'из', 'первого', 'объекта', 'только', 'слова,', 'находящиеся', 'на', 'четных', 'позициях.', 'Напишите', 'инструкции', 'определения', 'класса', 'созданного', 'объекта', 'и', 'списка', 'его', 'атрибутов.')
+>> len(cort)
+32
+>>> "в кортеже {} элемента".format(len(cort))
+'в кортеже 32 элемента'
+
+# Пункт 4. 
+slovar = dict(zip(range(1, len(cort)+1), cort)); slovar
+{1: 'Создайте', 2: 'объект,', 3: 'содержащий', 4: 'текст', 5: 'задания', 6: 'данного', 7: 'пункта.', 8: 'Создайте', 9: 'новый', 10: 'объект,', 11: 'в', 12: 'который', 13: 'включите', 14: 'из', 15: 'первого', 16: 'объекта', 17: 'только', 18: 'слова,', 19: 'находящиеся', 20: 'на', 21: 'четных', 22: 'позициях.', 23: 'Напишите', 24: 'инструкции', 25: 'определения', 26: 'класса', 27: 'созданного', 28: 'объекта', 29: 'и', 30: 'списка', 31: 'его', 32: 'атрибутов.'}
+
+# Пункт 5.
+>>> mnoz = set(slovar.values()); mnoz
+{'находящиеся', 'позициях.', 'на', 'и', 'его', 'текст', 'созданного', 'слова,', 'инструкции', 'объекта', 'в', 'определения', 'задания', 'списка', 'из', 'первого', 'пункта.', 'содержащий', 'включите', 'данного', 'новый', 'который', 'Создайте', 'только', 'четных', 'атрибутов.', 'Напишите', 'объект,', 'класса'}
+>>> len(mnoz)
+29
+```

TEMA3/test.py

@@ -0,0 +1,12 @@
+text = "Создайте объект, содержащий текст задания данного пункта. Создайте новый объект, в который включите из первого объекта только слова, находящиеся на четных позициях. Напишите инструкции определения класса созданного объекта и списка его атрибутов."
+slova = text.split(); print(slova)
+p = slova[1::2]
+text1 = ' '.join(p); print(text1)
+print(type(text1))
+print(dir(text1))
+cort=tuple(slova); print(cort)
+print(len(cort))
+print("в кортеже {} элемента".format(len(cort))) 
+slovar = dict(zip(range(1, len(cort)+1), cort)); print(slovar)
+mnoz = set(slovar.values()); print(mnoz)
+print(len(mnoz))

TEMA4/report.md

@@ -0,0 +1,378 @@
+# Отчёт по теме 4
+Зеленкина Катерина Михайловна, А-02-23
+
+## Пункт 1. Запуск IDLE
+## Пункт 2. Стандартные функции
+### Пункт 2.1. Функция round 
+__round__ - округление числа с заданной точностью. 
+
+```py
+>>> help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+>>> a=round(123.456,1); a; type(a)
+123.5
+<class 'float'>
+>>> b=round(123.456,0); b; type(b)
+123.0
+<class 'float'>
+```
+__Пояснение:__ Разница только в количестве знаков после запятой в результате (в первом - до 1 десятичного знака, во-втором - до 0), но тип данных одинаковый
+
+```py
+>>> c=round(123.456); c; type(c)
+123
+<class 'int'>
+```
+__Пояснение:__ Произошло округление до целого, и сохранился в "int"
+
+## Пункт 2.2. Функция range 
+__range__ - создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+
+```py
+>>> gg=range(76,123,9); gg #генерирует числа с 76 до 123 (пока не будет больше/равно) с шагом 9
+range(76, 123, 9)
+>>> type(gg)
+<class 'range'>
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> range(23) #Будет последовательность от 0 до 22 включительно с шагом 1
+range(0, 23)
+```
+
+## Пункт 2.3. Функция zip 
+__zip__ - создание общего объекта, элементами которого являются кортежи, составленные из  элементов двух или более объектов-последовательностей
+
+```py
+>>> qq=["Зеленкина", "Криви", "Цветкова", "Коломейцев"]
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> ff=zip(gg,qq); ff
+<zip object at 0x0000020E046D74C0>
+>>> type(ff)
+<class 'zip'>
+>>> tuple(ff)
+((76, 'Зеленкина'), (85, 'Криви'), (94, 'Цветкова'), (103, 'Коломейцев'))
+>>> ff[0]
+Traceback (most recent call last):
+  File "<pyshell#175>", line 1, in <module>
+    ff[0]
+TypeError: 'zip' object is not subscriptable
+>>> ff_list= list(zip(gg, qq)); ff_list[0]
+(76, 'Зеленкина')
+```
+
+### Пункт 2.4. Функция eval 
+__eval__ - вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки
+
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=20
+>>> dan
+-56.0
+```
+
+### Пункт 2.5. Функция exec
+
+__exec__ - чтение и выполнение объекта-аргумента функции.
+
+```py
+exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+```
+
+### Пункт 2.6. Самостоятельное применение функций
+
+```py
+>>> abs(-100)
+100
+
+>>> pow(5,2)
+25
+
+>>> max(1,2,3,4,199, 13)
+199
+
+>>> min(4,5,-10,-3,2)
+-10
+
+>>> sum([4,8,3])
+15
+
+>>> divmod(8,2)
+(4, 0)
+
+>>> len('Привет, друг!')
+13
+
+>>> n=[10,20,30,45]
+>>> map(str,n)
+<map object at 0x0000020E046CB100>
+>>> list(map(str,n))
+['10', '20', '30', '45']
+```
+## Пункт 3. Функции из стандартного модуля math 
+
+```py
+>>> import math
+>>> dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+    Raise a ValueError if x is negative or non-integral.
+
+>>> math.factorial(5)
+120
+```
+Функции модуля: sin, acos, degrees, radians, exp, log, log10, sqrt, ceil, floor, pi:
+
+```py
+>>> math.sin(45)
+0.8509035245341184
+>>> math.acos(0.8509035245341184)
+0.553093477052002
+>>> math.degrees(180)
+10313.240312354817
+>>> math.exp(1)
+2.718281828459045
+>>> math.log(10)
+2.302585092994046
+>>> math.log(4,2)
+2.0
+>>> math.log10(10)
+1.0
+>>> math.sqrt(16)
+4.0
+>>> math.ceil(10.8)
+11
+>>> math.ceil(-10.8)
+-10
+>>> math.floor(5.5)
+5
+>>> math.pi
+3.141592653589793
+```
+
+## Пункт 4. Функции из модуля cmath 
+Cовокупность функций для работы с комплексными числами.
+
+```py
+>>> import cmath
+>>> dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+>>> cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+>>> cmath.phase(1-0.5j)
+-0.4636476090008061
+```
+
+## Пункт 5. Стандартный модуль random
+Cовокупность функций для выполнения операций с псевдослучайными числами и выборками.
+
+```py
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>> help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+    If *a* is an int, all bits are used.
+
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+>>> random.seed()
+
+>>> random.seed(52)
+>>> random.random()
+0.9783548583709967
+>>> random.uniform(1, 5)
+1.2180906200418296
+>>> random.randint(1, 10)
+9
+>>> random.gauss(0, 2)
+-4.744196627534718
+>>> a=[15,6,8,10]
+>>> random.shuffle(a); a
+[8, 6, 15, 10]
+>>> random.sample(range(10), 2)
+[7, 0]
+>>> random.sample(range(10), 3)
+[0, 8, 6]
+>>> random.betavariate(3, 2)
+0.7782580563898469
+>>> random.gammavariate(3, 2)
+7.541042451721967
+```
+
+Создайте список с 4 случайными значениями^
+
+```py
+>>> r = [random.uniform(0, 20), random.gauss(13, 33),
+random.betavariate(5, 15), random.gammavariate(9, 2)]; r
+[9.981907966137051, 20.964805026393023, 0.13659209100569777, 10.30243231589178]
+```
+## Пункт 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
+1759666696.7083006
+>>> c2=time.time()-c1; c2
+15.599524736404419
+
+>>> dat=time.gmtime(); dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=5, tm_hour=12, tm_min=20, tm_sec=10, tm_wday=6, tm_yday=278, tm_isdst=0)
+>>>dat.tm_mon
+10
+>>> dat.tm_year
+2025
+>>> dat.tm_mday
+5
+>>> dat.tm_hour
+12
+>>> dat.tm_min
+20
+>>> dat.tm_sec
+10
+>>> dat.tm_wday
+6
+>>> time.localtime()
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=5, tm_hour=15, tm_min=23, tm_sec=36, tm_wday=6, tm_yday=278, tm_isdst=0)
+>>> time.asctime()
+'Sun Oct  5 15:23:46 2025'
+>>> time.ctime()
+'Sun Oct  5 15:23:52 2025'
+>>> time.sleep(3)
+
+>>> t=(2025, 10, 5, 15, 23, 36, 6, 278, 0)
+>>> obj= time.struct_time(t); obj
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=5, tm_hour=15, tm_min=23, tm_sec=36, tm_wday=6, tm_yday=278, tm_isdst=0)
+>>> s=time.mktime(obj);s
+1759667016.0
+>>> back=time.localtime(s);back
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=5, tm_hour=15, tm_min=23, tm_sec=36, tm_wday=6, tm_yday=278, tm_isdst=0)
+```
+
+## Пункт 7. Графические функции
+
+```py
+>>> import pylab
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000001FA91846350>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>> pylab.show()
+```
+
+![Скриншот графика1](график1.png)
+
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000001FA92FFED50>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000001FA92FFEE90>]
+>>> pylab.show()
+```
+
+![Скриншот графика2](график2.png)
+
+#### Построение круговой диаграммы
+
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000001FA918016A0>, <matplotlib.patches.Wedge object at 0x000001FA9257CB90>, <matplotlib.patches.Wedge object at 0x000001FA9257CF50>, <matplotlib.patches.Wedge object at 0x000001FA9257D1D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()
+```
+![Скриншот графика3](график3.png)
+
+#### Гистограммы и столбиковые диаграммы 
+Построим гистограмму:
+```py
+>>> import matplotlib.pyplot as plt
+>>> ocenki = [3, 4, 4, 5, 5, 5, 4, 3, 5, 4, 5, 5, 4, 3]
+>>> plt.hist(ocenki, color='orange', edgecolor='black')
+(array([3., 0., 0., 0., 0., 5., 0., 0., 0., 6.]), array([3. , 3.2, 3.4, 3.6, 3.8, 4. , 4.2, 4.4, 4.6, 4.8, 5. ]), <BarContainer object of 10 artists>)
+>>> plt.title('Распределение оценок в классе')
+Text(0.5, 1.0, 'Распределение оценок в классе')
+>>> plt.xlabel('Оценки')
+Text(0.5, 0, 'Оценки')
+>>> plt.ylabel('Количество учеников')
+Text(0, 0.5, 'Количество учеников')
+>>> plt.show()
+```
+![Скриншот графика4](график4.png)
+
+Построим столбиковую диаграмму:
+```py
+>>> name = ['Пн', 'Вт', 'Ср', 'Чт', 'Пт']
+>>> number = [10, 25, 15, 30, 20]
+>>> plt.bar(name, number, color='skyblue')
+<BarContainer object of 5 artists>
+>>> plt.title('Моя диаграмма')
+Text(0.5, 1.0, 'Моя диаграмма')
+>>> plt.xlabel('Дни недели')
+Text(0.5, 0, 'Дни недели')
+>>> plt.ylabel('Значения')
+Text(0, 0.5, 'Значения')
+>>> plt.show()
+```
+![Скриншот графика5](график5.png)
+
+## Пункт 8. Состав модуля statistics
+
+```py
+>>> import statistics
+>>> g = [45, 50, 55, 60, 65, 70, 75, 80, 85, 200]
+>>> mean = statistics.mean(g); mean
+78.5
+>>> mode = statistics.mode(g); mode
+45
+>>>stdev = statistics.stdev(g); stdev
+44.60007473835292
+>>> variance = statistics.variance(g); variance
+1989.1666666666667
+>>> quantiles = statistics.quantiles(g, n=4); quantiles
+[53.75, 67.5, 81.25]
+>>> harmonic_mean = statistics.harmonic_mean(g); harmonic_mean
+66.96171069719155
+```
+
+## Пунтк 9. Завершение сеанса IDLE

TEMA4/task.md

@@ -0,0 +1,56 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности ин-струкций, выполняющих следующие действия:
+1. Напишите и исполните единое выражение, реализующее последовательное выполнение следу-ющих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух зна-чений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из это-го списка с тремя днями недели. 
+4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+```py
+>>> import math
+>>> import cmath
+>>> import time
+>>> import random
+>>> import string
+>>> import statistics
+
+>>> divmod(((round(cmath.phase(0.2+0.8j),2)) * 20),3)
+(8.0, 2.6000000000000014)
+
+>>> msc_time = time.gmtime(time.time() + 3 * 3600);msc_time
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=10, tm_min=31, tm_sec=45, tm_wday=0, tm_yday=293, tm_isdst=0)
+>>> hm=(f'{msc_time.tm_hour}:{msc_time.tm_min}'); hm
+'10:31'
+
+
+>>> wd = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+>>> p = random.sample(wd, 3); p
+['Суббота', 'Среда', 'Понедельник']
+
+>>> k = list(range(14, 33, 3)); k
+[14, 17, 20, 23, 26, 29, 32]
+>>> rand = random.choice(k);rand
+14
+
+>>> N = round(random.gauss(15, 4)); N
+14
+>>> p=random.sample(string.ascii_letters, N); p
+['s', 'h', 'd', 'L', 'i', 'C', 'z', 'P', 'k', 'y', 'D', 'l', 'H', 'Z']
+
+>>> c = time.time()+3*3600;c
+1760912196.5972443
+>>> inter_sec = c - time.mktime(msc_time);inter_sec
+11362.597244262695
+>>> inter_min = round(inter_sec / 60, 2); inter_min
+189.38
+```
+
+

TEMA4/task.py

@@ -0,0 +1,27 @@
+import math
+import cmath
+import time
+import random
+import string
+import statistics
+print(divmod(((round(cmath.phase(0.2+0.8j),2)) * 20),3))
+msc_time = time.gmtime(time.time() + 3 * 3600);msc_time
+hm=(f'{msc_time.tm_hour}:{msc_time.tm_min}')
+print(hm)
+wd = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+p = random.sample(wd, 3);
+print(p)
+k = list(range(14, 33, 3))
+print(k)
+rand = random.choice(k)
+print(rand)
+N = round(random.gauss(15, 4))
+print(N)
+p=random.sample(string.ascii_letters, N)
+print(p)
+c = time.time()+3*3600
+print(c)
+inter_sec = c - time.mktime(msc_time)
+print(inter_sec)
+inter_min = round(inter_sec / 60, 2)
+print(inter_min)

TEMA4/test.md

@@ -0,0 +1,31 @@
+# Индивидуальное контрольное задание по теме 4
+
+Зеленкина Катерина, А-02-23
+Вариант 4
+
+## Задание
+Создайте список с 20 случайными, нормально распределенными (математическое ожидание равно 3400, стандартное отклонение равно 121) числами. Рассчитайте по нему среднее значение и число элементов, значение которых превышает это среднее.
+
+## Решение
+
+```py
+import random
+import statistics
+sps = []
+for i in range(20):
+    a = random.gauss(3400, 121)
+    sps.append(a) 
+print('Список: ', sps)
+sr = statistics.mean(sps)
+print('Среднее значение: ', sr)
+i=0
+for el in sps:
+    if el>sr:
+        i+=1
+print('Кол-во элементов больше среднего: ', i)
+
+
+Список:  [3497.797538406104, 3267.084579757765, 3433.5344588585167, 3467.31945703132, 3219.709391355155, 3319.3524633811053, 3247.9415423402065, 3396.8815287460775, 3510.7463491419835, 3307.80163577245, 3277.148366159288, 3409.7495053002212, 3474.074399355259, 3471.4930101011246, 3433.352490022768, 3509.521992706484, 3145.302863435359, 3359.933986462906, 3455.6657952685296, 3525.085510243645]
+Среднее значение:  3386.4748431923135
+Кол-во элементов больше среднего:  12
+```

TEMA4/test.py

@@ -0,0 +1,14 @@
+import random
+import statistics
+sps = []
+for i in range(20):
+    a = random.gauss(3400, 121)
+    sps.append(a) 
+print('Список: ', sps)
+sr = statistics.mean(sps)
+print('Среднее значение: ', sr)
+i=0
+for el in sps:
+    if el>sr:
+        i+=1
+print('Кол-во элементов больше среднего: ', i)

TEMA5/report.md

@@ -0,0 +1,299 @@
+# Отчёт по теме 5
+Зеленкина Катерина Михайловна, А-02-23
+
+## Пункт 1.Запуск оболочки IDLE
+## Пункт 2. Инструкция if
+- ветвление по условию 
+Определение значения dohod:
+
+```py
+>>> porog = 10
+>>> rashod1 = 50
+>>> rashod2 = 35
+
+>>> 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
+0
+```
+
+И ещё одна операция с множественным ветвлением линий потока:
+```py
+>>> if porog==3:
+...    dohod=1
+>>> elif porog==4:
+...    dohod=2
+>>> elif porog==5:
+...    dohod=2
+>>> else:
+...    dohod=0
+   
+>>> dohod
+0
+```
+
+
+Условные инструкции могут записываться также в одну строку в операторе присваивания:
+
+```py
+>>> del dohod
+>>> dohod=2 if porog>=4 else 0
+>>> dohod
+2
+>>> if porog>=5 : rashod1=6; rashod2=0
+
+>>> rashod1
+6
+>>> rashod2
+0
+```
+
+## Пункт 3.Инструкция for
+- цикл по перечислению 
+
+### Пункт 3.1. Простой цикл
+```py
+>>> temperatura=5
+>>> for i in range(3,18,3):
+...    temperatura+=i
+
+    
+>>> temperatura
+50
+```
+
+### Пункт 3.2. Более сложный цикл
+```py
+>>> sps=[2,15,14,8]
+>>> for k in sps:
+...    if len(sps)<=10:sps.append(sps[0])
+...    else:break
+ 
+>>> sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+
+#Чуть-чуть отличающуюся совокупность операций
+>>> 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, который изменяется внутри цикла и на каждой итерации добавляется новый элемент, что приводит к бесконечному циклу, прерванному только условием. Во-втором способе цикл итерируется по срезу-копии исходного списка, который не изменяется.
+
+### Пункт 3.3. Пример
+Создание списка с 10 целыми случайными числами из диапазона от 1 до 100. При этом, если сум-ма чисел не превышает 500, эта сумма должна быть отображена на экране.
+
+```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)
+
+    
+>>> sps5=[]
+>>> for i in range(10):
+...    sps5.append(rn.randint(1,100))
+...    ss=sum(sps5)
+...    if ss>500: break
+>>> else:
+    print(ss)
+...
+...  
+420
+```
+
+__Вывод:__ Вывод ss происходит только если цикл завершился нормально (без break), то есть в первом случае ss>500 и выполнился break, поэтому ничего не вывело.
+
+### Пункт 3.4. Пример с символьной строкой
+
+```py
+>>> stroka='Это – автоматизированная система'
+>>> stroka1=""
+>>> for ss in stroka:
+...    stroka1+=" "+ss
+... 
+>>> stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+
+### Пункт 3.5. Запись цикла в строке.
+___Пример:__ создание списка с синусоидальным сигналом.
+
+```py
+>>> import math
+>>> sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+>>> sps2
+[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
+
+>>> import pylab
+>>> pylab.plot(sps2)
+[<matplotlib.lines.Line2D object at 0x000001ECFBB62350>]
+>>> pylab.title('Синусоидальный сигнал')
+Text(0.5, 1.0, 'Синусоидальный сигнал')
+>>> pylab.xlabel('Отсчеты')
+Text(0.5, 0, 'Отсчеты')
+>>> pylab.ylabel('Амплитуда')
+Text(0, 0.5, 'Амплитуда')
+>>> pylab.grid(True)
+>>> pylab.show()
+```
+![Скриншот графика1](график1.png)
+
+## Пункт 4. Инструкция while
+### Пункт 4.1. Цикл со счётчиком
+
+```py
+>>> rashod=300
+>>> while rashod:
+...    print("Расход=",rashod)
+...    rashod-=50
+
+    
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+
+__Вывод:__ цикл завершился, когда rashod стал равен 0.
+
+### Пункт 4.2. Пример с символьной строкой
+```py
+>>> import math
+>>> stroka = 'Расчет процесса в объекте регулирования'
+>>> i = 0
+>>> sps2 = []
+>>> tp=[]
+>>> while i < len(stroka):
+...    r = 1 - 2 / (1 + math.exp(0.1 * i))
+...    sps2.append(r)
+...    tp.append(i)
+...    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
+
+>>> import matplotlib.pyplot as plt
+>>> plt.plot(tp, sps2, 'r-', marker='o', linewidth=2, markersize=4, label='Выходной сигнал инерционного звена')
+[<matplotlib.lines.Line2D object at 0x0000016A21FE20D0>]
+>>> plt.title('Сигнал на выходе инерционного звена')
+Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
+>>> plt.xlabel('Время, i')
+Text(0.5, 0, 'Время, i')
+>>> plt.ylabel('Значение сигнала')
+Text(0, 0.5, 'Значение сигнала')
+>>> plt.grid(True, which='major', linestyle='--', linewidth=0.5)
+>>> plt.legend()
+<matplotlib.legend.Legend object at 0x0000016A21FE2210>
+>>> plt.show()
+```
+![Скриншот графика2](график2.png)
+
+
+### Пункт 4.3. Определение, является ли число простым.
+
+```py
+chislo=267
+kandidat =chislo // 2
+while kandidat > 1:
+    if chislo%kandidat == 0:
+        print(chislo, ' имеет множитель ', kandidat)
+        break
+    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:
+...            break
+...        kandidat -= 1
+...    else:
+...        if chislo > 1:
+...            print(chislo, '- простое число')
+
+            
+251 - простое число
+257 - простое число
+263 - простое число
+269 - простое число
+271 - простое число
+277 - простое число
+281 - простое число
+283 - простое число
+293 - простое число
+```
+
+## Пункт 5. Закончила сеанс работы с IDLE

TEMA5/task.md

@@ -0,0 +1,109 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+1. Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+2. Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+3. Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+```py
+text = "Hello world from Python"
+print(text)
+
+alphabet = 'abcdefghijklmnopqrstuvwxyz'
+
+for char in text:
+    lower_char = char.lower()
+    if lower_char in alphabet:
+        position = alphabet.index(lower_char) + 1
+        print(f"Буква '{char}' имеет порядковый номер {position}")
+    else:
+        print(f"Символ '{char}' не является буквой английского алфавита")
+
+Hello world from Python
+Буква 'H' имеет порядковый номер 8
+Буква 'e' имеет порядковый номер 5
+Буква 'l' имеет порядковый номер 12
+Буква 'l' имеет порядковый номер 12
+Буква 'o' имеет порядковый номер 15
+Символ ' ' не является буквой английского алфавита
+Буква 'w' имеет порядковый номер 23
+Буква 'o' имеет порядковый номер 15
+Буква 'r' имеет порядковый номер 18
+Буква 'l' имеет порядковый номер 12
+Буква 'd' имеет порядковый номер 4
+Символ ' ' не является буквой английского алфавита
+Буква 'f' имеет порядковый номер 6
+Буква 'r' имеет порядковый номер 18
+Буква 'o' имеет порядковый номер 15
+Буква 'm' имеет порядковый номер 13
+Символ ' ' не является буквой английского алфавита
+Буква 'P' имеет порядковый номер 16
+Буква 'y' имеет порядковый номер 25
+Буква 't' имеет порядковый номер 20
+Буква 'h' имеет порядковый номер 8
+Буква 'o' имеет порядковый номер 15
+Буква 'n' имеет порядковый номер 14
+```
+
+```py
+words_list = ["создайте", "список", "со", "словами", "из", "задания", "данного", "пункта"]
+
+search_word = "список"
+
+print(f"Проверяем наличие слова: '{search_word}'")
+if search_word in words_list:
+    print(f"Элемент '{search_word}' найден в списке.")
+else:
+    print(f"Элемент '{search_word}' отсутствует в списке.")
+
+# С отсутствующим словом
+search_word_absent = "программирование"
+print(f"Проверяем наличие слова: '{search_word_absent}'")
+
+if search_word_absent in words_list:
+    print(f"Элемент '{search_word_absent}' найден в списке.")
+else:
+    print(f"Элемент '{search_word_absent}' отсутствует в списке.")
+
+Проверяем наличие слова: 'список'
+Элемент 'список' найден в списке.
+Проверяем наличие слова: 'программирование'
+Элемент 'программирование' отсутствует в списке.
+```
+
+```py
+students = ["Криви", "Шинкаренко", "Капитонов"]
+summer_grades = [4.5, 5.0, 3.8]
+winter_students = ["Капитонов", "Криви", "Шинкаренко"]
+winter_grades = [4.1, 4.3, 4.7]
+
+
+surname = input("Введите фамилию студента: ")
+if surname in students:
+    index = students.index(surname)
+    summer_grade = summer_grades[index]
+    
+    if surname in winter_students:
+        winter_index = winter_students.index(surname)
+        winter_grade = winter_grades[winter_index]
+        
+        print(f"Студент {surname}:")
+        print(f"  Летняя сессия: {summer_grade}")
+        print(f"  Зимняя сессия: {winter_grade}")
+        print(f"  Средний балл:{(summer_grade + winter_grade) / 2:.2f} ")
+
+    else:
+        print(f"Студент {surname} не найден в списке зимней сессии")
+else:
+    print(f"Студент {surname} не найден в списке студентов")
+
+Введите фамилию студента: Криви
+Студент Криви:
+  Летняя сессия: 4.5
+  Зимняя сессия: 4.3
+  Средний балл:4.40 
+```

TEMA5/task.py

@@ -0,0 +1,12 @@
+text = "Hello world from Python"
+print(text)
+
+alphabet = 'abcdefghijklmnopqrstuvwxyz'
+
+for char in text:
+    lower_char = char.lower()
+    if lower_char in alphabet:
+        position = alphabet.index(lower_char) + 1
+        print(f"Буква '{char}' имеет порядковый номер {position}")
+    else:
+        print(f"Символ '{char}' не является буквой английского алфавита")

TEMA5/task2.py

@@ -0,0 +1,18 @@
+words_list = ["создайте", "список", "со", "словами", "из", "задания", "данного", "пункта"]
+
+search_word = "список"
+
+print(f"Проверяем наличие слова: '{search_word}'")
+if search_word in words_list:
+    print(f"Элемент '{search_word}' найден в списке.")
+else:
+    print(f"Элемент '{search_word}' отсутствует в списке.")
+
+# С отсутствующим словом
+search_word_absent = "программирование"
+print(f"Проверяем наличие слова: '{search_word_absent}'")
+
+if search_word_absent in words_list:
+    print(f"Элемент '{search_word_absent}' найден в списке.")
+else:
+    print(f"Элемент '{search_word_absent}' отсутствует в списке.")

TEMA5/task3.py

@@ -0,0 +1,24 @@
+students = ["Криви", "Шинкаренко", "Капитонов"]
+summer_grades = [4.5, 5.0, 3.8]
+winter_students = ["Капитонов", "Криви", "Шинкаренко"]
+winter_grades = [4.1, 4.3, 4.7]
+
+
+surname = input("Введите фамилию студента: ")
+if surname in students:
+    index = students.index(surname)
+    summer_grade = summer_grades[index]
+    
+    if surname in winter_students:
+        winter_index = winter_students.index(surname)
+        winter_grade = winter_grades[winter_index]
+        
+        print(f"Студент {surname}:")
+        print(f"  Летняя сессия: {summer_grade}")
+        print(f"  Зимняя сессия: {winter_grade}")
+        print(f"  Средний балл:{(summer_grade + winter_grade) / 2:.2f} ")
+
+    else:
+        print(f"Студент {surname} не найден в списке зимней сессии")
+else:
+    print(f"Студент {surname} не найден в списке студентов")

TEMA5/test.md

@@ -0,0 +1,20 @@
+# Индивидуальное контрольное задание по теме 5
+
+Зеленкина Катерина, А-02-23
+Вариант 16
+
+## Задание
+Создайте кортеж с 2 элементами, которыми должны быть списки, каждый с 20 элементами - случайными, нормально распределенными числами с математическими ожиданиями, соответственно, -10 и 35 и одинаковыми стандартными отклонениями, равными 10. Рассчитайте разность средних значений по спискам. Отобразите её в виде строки вида: «Разность средних =ХХХ».
+
+## Решение
+```py
+>>> import random
+>>> import statistics
+>>> list1 = [random.gauss(-10, 10) for i in range(20)]
+>>> list2 = [random.gauss(35, 10) for i in range(20)]
+>>> tuple1 = (list1, list2) 
+>>> print(tuple1,'\n',"Разность средних = ", (statistics.mean(list2) - statistics.mean(list1)))
+
+([-3.857207501869989, 12.163653715490245, 6.037738138404084, -2.274750757964366, -18.503188229730835, -5.602409641454574, -10.317596576326157, -26.220376614524884, -1.077557960671717, -7.828144286037684, -12.997717295774278, -7.780166869177247, -15.674713428496627, -17.609307537231672, -24.456822102570097, -25.94735530125855, -11.801850723536688, -3.8493692175639698, -14.765366803043339, -17.50816105774217], [15.375854794491133, 37.80017868670642, 36.10655657961691, 38.75276253967245, 38.29862761493922, 35.65050866000108, 30.703573645790268, 17.95012433851909, 33.0836482546281, 28.375861385354913, 43.93674150004497, 28.726147637082953, 45.172822075379344, 38.44250595401752, 29.196660211866053, 43.58133732231829, 20.677542207236456, 33.119011163623234, 35.57034673802872, 32.31545293428262]) 
+Разность средних =  43.63534671473401
+```

TEMA5/test.py

@@ -0,0 +1,9 @@
+import random
+import statistics
+
+list1 = [random.gauss(-10, 10) for i in range(20)]
+list2 = [random.gauss(35, 10) for i in range(20)]
+
+tuple1 = (list1, list2) 
+
+print(tuple1, '\n',"Разность средних = ", (statistics.mean(list2) - statistics.mean(list1)))

TEMA6/Stroka.txt

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

TEMA6/report.md

@@ -0,0 +1,497 @@
+# Отчёт по теме 6
+Зеленкина Катерина Михайловна, А-02-23
+
+## Пункт 1.Запуск оболочки IDLE
+## Пункт 2. Вывод данных на экран дисплея
+### 2.1. Вывод в командной строке.
+Cодержимое любого объекта можно увидеть простым упоминанием его в командной строке (как это много раз делалось раньше), например:
+```py
+>>> stroka='Автоматизированная система управления'
+>>> stroka
+'Автоматизированная система управления'
+```
+Этот способ называется __«эхо-выводом»__
+
+### 2.2. Функция print
+Этот способ можно применять и в командной строке,  и в функциях
+```py
+>>> fff=234.5;gg='Значение температуры = '
+>>> print(gg, fff)
+Значение температуры =  234.5
+```
+Можно вывести несколько объектов за одно обращение к функции.
+
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разделитель его можно указать в отдельном аргументе sep, например:
+
+```py
+>>> print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+После вывода автоматически осуществляется переход на другую строку. Если курсор надо оставить в той же строке, то следует использовать еще один аргумент, например:
+```py
+>>> print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+```
+
+После end= надо указать какими символами должна закончиться выводимая строка или указать пустую строку. Наоборот, если в какой-то момент требуется просто перейти на новую строку, можно использовать такое обращение к функции:
+```py
+print()
+
+```
+
+Оператор вывода может располагаться на нескольких строках с использованием тройных кавычек:
+```py
+#1-й вариант
+>>> print(""" Здесь может выводиться
+... большой текст,
+... занимающий несколько строк""")
+
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+
+#2-й вариант
+>>> print("Здесь может выводиться",
+...      "большой текст,",
+...      "занимающий несколько строк")
+
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+Вывод: Во 1-ом варианте текст выводится в три отдельные строки как и при вводе команды, благодаря троиным кавычкам
+
+
+### 2.3. Вывод с использованием метода write  объекта sys.stdou.
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы вы-водят символьное представление данных. Объект находится в модуле __sys__ , который надо импортировать:
+
+```py
+>>> import sys
+>>> sys.stdout.write('Функция write')
+Функция write13
+```
+Этот метод после вывода строки не осуществляет переход на новую строку. Добавим в конце строки один или несколько символов “\n”:
+
+```py
+>>> sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+
+## Пункт 3. Ввод данных с клавиатуры.
+Для ввода используем знакомую функцию input. Например:
+
+```py
+>>> psw=input('Введите пароль:')
+Введите пароль:12345
+>>> psw
+'12345'
+>>> type(psw)
+<class 'str'>
+```
+
+### Пример 1. Ввод с контролем значения.
+Пусть вводится число, которое должно находиться в интервале значе-ний от 17.5 до 23.8.
+```py
+>>> while True:
+...    znach=float(input('Задайте коэф.усиления = '))
+...    if znach<17.5 or znach>23.8:
+...        print('Ошибка!')
+...    else:
+...        break
+
+    
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+```
+
+### Пример 2. Ввод и обработка выражения, подлежащего расчету.
+
+```py
+>>> import math
+>>> print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## Пункт 4. Ввод-вывод при работе с файлами.
+Работа с файлом требует указания источника данных - полного имени файла с путем доступа к  его расположению.
+
+### 4.1. Функции для работы с путем к файлу.
+Эти функции собраны в модуле os. Импортируем этот модуль и узнаем, какой рабочий каталог установлен в текущей момент времени с помощью os.getcwd (cwd = current working directory).
+
+```py
+>>> import os
+>>> os.getcwd()
+'C:\\Users\\user\\python-labs\\TEMA6'
+```
+Сохраним этот путь в переменной с именем ZelenkinaK и выведим с помощью «print»
+```py
+ZelenkinaK=os.getcwd()
+print(ZelenkinaK)
+C:\Users\user\python-labs\TEMA6
+```
+
+Изменить расположение рабочего каталога можно обращением к уже многократно применявшейся функции __os.chdir__
+```py
+os.chdir(r'C:\Users\user\python-labs\TEMA1')
+os.getcwd()
+'C:\\Users\\user\\python-labs\\TEMA1'
+```
+
+Самостоятельно изучите и попробуйте использовать следующие функции из модуля os: __mkdir__, __rmdir__, __listdir__ и функцию __isdir__ из вложенного в os модуля os.path.
+
+```py
+>>> import os
+>>> from os.path import isdir
+# mkdir - создаёт папку
+>>> os.mkdir("Секретная_папка")
+
+# isdir - проверяет наличие папки
+>>> print(isdir("Секретная_папка"))
+True
+
+# listdir - просматривает содержимое текущей директории
+>>> print(os.listdir())
+['.gitkeep', 'report.md', 'Секретная_папка']
+
+# rmdit - удаляет пустую папку
+>>> os.rmdir("Секретная_папка")
+>>> print(isdir("Секретная_папка"))
+False
+```
+
+Пусть в рабочем каталоге находится файл report.md. С помощью функции __os.path.abspath__ получим символьную строку, содержащую имя файла вместе с полным путем доступа к нему:
+```py
+>>> fil=os.path.abspath("report.md")
+>>> print(fil)
+C:\Users\user\python-labs\TEMA6\report.md
+```
+
+Выделим путь доступа к файлу из строки, содержащей и этот путь, и имя файла  с помощью функции __os.path.dirname__:
+```py
+>>> drkt=os.path.dirname(fil)
+>>> print(drkt)
+C:\Users\user\python-labs\TEMA6
+```
+
+Наоборот, выделить имя файла из этой строки с отбрасыванием пути можно с помощью функции __os.path.basename__.
+```py
+>>> file1 = os.path.basename(fil)
+>>> print(file1)
+report.md
+```
+
+Самостоятельно изучим функцию __os.path.split__ (возвращает кортеж (путь, имя_файла)):
+```py
+>>> file2 = os.path.split(fil); print(file2)
+('C:\\Users\\user\\python-labs\\TEMA6', 'report.md')
+```
+
+С помощью функции __os.path.exists__ можно проверить существует ли путь:
+
+```py
+>>> os.path.exists(r'C:\Users\user\python-labs\TEMA6')
+True
+>>> os.path.exists(r'C:\\Users\\user\\python-labs\\Дом')
+False
+>>> os.path.exists('file')
+False
+```
+
+Проверим наличие файла с известным расположением с помощью функции __os.path.isfile__, аргументом которой должна быть символьная строка с путем и именем интересующего файла:
+```py
+>>> a=os.path.isfile(r'C:\Users\user\python-labs\TEMA6\report.md')
+>>> print(a)
+True
+```
+
+### 4.2. Общая схема работы с файлом.
+Для обмена данными с файлом необходимо выполнить следующие операции:
+1. Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+2. Выполнение одной или нескольких операций обмена данными с файлом;
+3. Закрытие файла.
+
+## Пункт 4.3. Функция __open__
+Функция __open__ - открытие файла для записи или чтения данных.
+Запросим помощь:
+```py
+>>> help(open)
+
+Help on built-in function open in module _io:
+
+open(
+    file,
+    mode='r',
+    buffering=-1,
+    encoding=None,
+    errors=None,
+    newline=None,
+    closefd=True,
+    opener=None
+)
+    Open file and return a stream.  Raise OSError upon failure.
+...
+    It is also possible to use a string or bytearray as a file for both
+    reading and writing. For strings StringIO can be used like a file
+    opened in a text mode, and for bytes a BytesIO can be used like a file
+    opened in a binary mode.
+```
+
+При открытии файла необходимо указать имя файлы (с путем, если он не в рабочем каталоге) и цель работы с ним. Для открытия используется функция open. 
+
+```py
+fp=open(file=drkt+'\\zapis1.txt',mode='w')
+```
+
+Более короткая запись (без имен аргументов):
+```py
+fp=open(drkt+'\\zapis1.txt','w')
+```
+Если путь в переменной drkt совпадает с рабочим каталогом, то его можно опустить, оставив только имя открываемого файла:
+```py
+fp=open('zapis1.txt','w')
+```
+
+Отобразим тип и список атрибутов:
+```py
+>>> print(type(fp))                                                          
+<class '_io.TextIOWrapper'>
+
+>>> dir(fp)
+                                                          
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+```
+
+## Пункт 4.4. Закрытие файла.
+Сразу после завершения работы с файлом его следует закрыть для обеспечения сохранности его содержимого с помощью метода close, применяемого к объекту – файловой переменной.
+```py
+fp.close()
+
+
+```
+### 4.5. Запись информации в файл с помощью метода write.
+               
+Метод __write__ относится к объекту – файловой переменной.
+
+Пример 1. Создадим список с элементами-числами от 1 до 12 и запишите их в файл по 4 числа на строке:
+```py
+>>> sps=list(range(1,13))                                                      
+>>> fp2=open('zapis3.txt','w')                                                          
+>>> fp2.write(str(sps[:4])+'\n')                                                      
+13
+>>> fp2.write(str(sps[:4])+'\n')                                                      
+13
+>>> fp2.write(str(sps[8:])+'\n')                                                         
+16
+>>> fp2.close()                     
+```
+
+В файле появилась запись:
+```py
+[1, 2, 3, 4]
+[1, 2, 3, 4]
+[9, 10, 11, 12]
+```
+
+Пример 2. 
+```py
+>>>sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]                                                       
+>>> fp3=open('zapis4.txt','w')                                                          
+>>> for i in range(len(sps3)):
+...    stroka4=sps3[i][0]+' '+str(sps3[i][1])
+...    fp3.write(stroka4)
+
+            
+11
+11
+12
+>>> fp3.close()
+```
+
+В файле появилась запись:
+
+![Скриншот файла zapis4](Фото1.png)
+
+Попробуем сделать так:
+```py
+>>> gh=open('zapis5.txt','w')
+>>> for r in sps3:
+...    gh.write(r[0]+' '+str(r[1])+'\n')
+
+    
+12
+12
+13
+>>> gh.close()
+```
+
+Обратите внимание на то, что этот цикл можно представить одной строкой:
+```py
+ for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+```
+
+### 4.6. Первый способ чтения информации из текстового файла.
+Прочитаем информацию из ранее созданного файла zapis3.txt.
+```py
+>>> sps1=[]
+>>> fp=open('zapis3.txt')
+>>> for stroka in fp:
+...    stroka=stroka.rstrip('\n')
+...    stroka=stroka.replace('[','')
+...    stroka=stroka.replace(']','')
+...    sps1=sps1+stroka.split(',')
+
+    
+>>> fp.close()
+>>> print(sps1)
+['1', ' 2', ' 3', ' 4', '1', ' 2', ' 3', ' 4', '9', ' 10', ' 11', ' 12']
+```
+Обратите внимание, что в функции открытия файла использован только один аргумент, остальные – со значениями «по умолчанию».
+Здесь, перед занесением строки в список с помощью метода __rstrip__, из неё удаляется символ конца строки, а с помощью метода __replace__ – скобки.
+
+__Отличия:__ Данные в sps1 представлены в виде строк, а в zapis3.txt — в виде целых чисел.
+Подумаем, как сделать так, чтобы список, полученный при чтении из файла, совпал с исходным:
+
+```py
+>>>sps=[]
+>>> for i in sps1:
+...    sps.append(int(i))
+  
+>>> sps
+[1, 2, 3, 4, 1, 2, 3, 4, 9, 10, 11, 12]
+```
+
+### 4.7. Чтение информации из файла с помощью метода read.
+Метод __read__, как и __write__, относится к объекту – файловой переменной. 
+Метод read() читает данные из файла (текстового или бинарного) и возвращает строку или байтовую последовательность. 
+
+```py
+>>> fp=open('zapis3.txt')
+>>> stroka1=fp.read(12)
+>>> stroka2=fp.read()
+>>> fp.close()
+>>> stroka1
+'[1, 2, 3, 4]'
+>>> stroka2
+'\n[1, 2, 3, 4]\n[9, 10, 11, 12]\n'
+```
+
+### 4.8. Чтение информации с помощью методов readline и readlines.
+Эти методы позволяют прочитать из файла, начиная с текущего положения маркера, соответствен-но, одну строку символов (совокупность байт)  или все строки (все байты). 
+
+__readline()__ - функция, которая читает одну строку из файла.
+```py
+>>> fp=open('zapis3.txt')
+>>> s1=fp.readline(); s1
+[1, 2, 3, 4]
+
+>>> s2 = fp.readline(); s2
+'[1, 2, 3, 4]\n'
+
+>>> s3=fp.readline();s3
+'[9, 10, 11, 12]\n'
+
+>>> fp.close()
+```
+__readlines()__ - функция, которая читает все строки, возвращая их в виде списка
+
+```py
+>>> fp=open('zapis3.txt')
+>>> s4=fp.readlines(); s4
+['[1, 2, 3, 4]\n', '[1, 2, 3, 4]\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)
+>>> fp.close()
+```
+В файле появилась запись:
+
+![Скриншот файла запись6](Фото3.png)
+
+Теперь прочитаем данные из файла в объект mnoz2:
+```py
+>>> fp=open('zapis6.mnz','rb')
+>>> mnoz2=pickle.load(fp)
+>>> fp.close()
+>>> mnoz2
+{'iPhone', 'table', 'pen', 'book'}
+```
+Инструкцией проверили два объекта: mnoz1 и mnoz2 на совпадение.
+```py
+mnoz1==mnoz2
+True
+```
+Результат отличается от введённого множества mnoz1 потому, что множество автоматически удалило все повторяющиеся слова и могло изменить их порядок
+
+А теперь с использованием тех же функций запишите в файл, а затем прочитайте два объекта раз-ных типов: то же множество mnoz1 и ранее созданный список sps3. При считывании объекты из-влекаются из файла в той же последовательности, в которой они в него записывались.
+```py
+>>> fp=open('zapis7.2ob','wb')
+>>> pickle.dump(mnoz1,fp)
+>>> pickle.dump(sps3,fp)
+>>> fp.close()
+>>> fp=open('zapis7.2ob','rb')
+>>> obj1=pickle.load(fp)
+>>> obj2=pickle.load(fp)
+>>> fp.close()
+
+>>> obj1; mnoz1
+{'iPhone', 'table', 'pen', 'book'}
+{'iPhone', 'table', 'pen', 'book'}
+>>> obj2; sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+
+## Пункт 5. Перенаправление потоков ввода и вывода данных.
+Проделаем следующие операции:
+```py
+>>>import sys
+>>>vr_out=sys.stdout  #Запоминаем текущий поток вывода
+>>>fc=open('Stroka.txt','w') #Откроем файл вывода
+>>>sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+>>>print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>>sys.stdout=vr_out  #Восстановление текущего потока
+>>>print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+>>>fc.close()
+```
+
+В файле:
+
+![Скриншот файла](Фото4.png)
+
+Точно также можно перенаправить поток ввода – sys.stdin – вместо клавиатуры – из файла.
+```py
+>>> import sys
+>>> vr_out=sys.stdout #Запоминаем текущий поток вывода
+>>> fc=open('Stroka.txt','w') #Откроем файл вывода
+>>> sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+>>> print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>> sys.stdout=vr_out #Восстановление текущего потока
+>>> print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+>>> fc.close()
+>>> tmp_in = sys.stdin #Запоминаем текущий поток ввода
+>>> fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+>>> sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+>>> sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+>>> while True:
+...    try:
+...        line = input () #Считываем из файла строку
+...        print(line) # Отображаем считанное
+...    except EOFError:
+...        break
+
+запись строки в файл
+>>> fd.close()
+>>> sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+```
+
+## Пункт 6. Завершение сеанса

TEMA6/result.txt

@@ -0,0 +1,2 @@
+a+b*c+d
+32.0

TEMA6/task.md

@@ -0,0 +1,68 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+3. Записывается кортеж в бинарный файл.
+4. Записывается в этот же файл список и закрывается файл.
+5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее со-общение.
+7. Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде от-дельных списков со своими именами.
+ 
+## Решение
+```py
+# Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+import random
+tp = tuple(random.randint(6, 56) for i in range(125))
+str_tp = tuple(map(str, tp))
+print(str_tp)
+
+# Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассни
+surname = ["Криви", "Киреев", "Капитонов", "Ефремов", "Добровольска"]
+print("Список фамилий:", surname)
+
+
+# Записать кортеж в бинарный файл.
+import os
+import pickle
+os.chdir(r"C:\Users\user\python-labs\TEMA6")
+a = open('bin.mnz', 'wb')
+pickle.dump(str_tup, a)
+
+#  Записывается в этот же файл список и закрывается файл.
+pickle.dump(surname, a)
+a.close()
+
+# Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+a = open('bin.mnz', 'rb')
+obj1 = pickle.load(a)
+obj2_spis = pickle.load(a)
+a.close()
+print("Прочитан кортеж:", obj1)
+print("Прочитан список:", obj2_spis)
+
+#  Проверяется на совпадение новых объектов с исходными и выводится соответствующее со-общение.
+if obj1 == str_tup and obj2_spis == surname:
+    print("Объекты совпадают с исходными!")
+else:
+    print("Объекты не совпадают с исходными!")
+
+# Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+for i in range(25):
+    exec(f"list{i+1} = list(str_tp[{i*5}:{i*5+5}])")
+
+print("Список 1: " , list1,'\n',"Список 2: ", list2)
+
+#Вывод
+```py
+('7', '49', '35', '8', '14', '41', '56', '19', '47', '19', '35', '17', '42', '24', '6', '51', '54', '44', '35', '17', '48', '31', '8', '23', '14', '26', '50', '46', '52', '13', '39', '26', '10', '53', '56', '53', '30', '44', '51', '6', '54', '24', '42', '8', '53', '46', '42', '15', '30', '41', '25', '30', '25', '48', '26', '53', '45', '33', '36', '54', '42', '16', '23', '24', '38', '34', '46', '42', '56', '13', '30', '21', '20', '34', '39', '8', '53', '35', '14', '34', '11', '54', '22', '20', '51', '24', '51', '38', '31', '34', '54', '27', '50', '41', '9', '31', '7', '36', '27', '36', '53', '39', '10', '40', '13', '6', '34', '28', '56', '30', '37', '41', '18', '26', '34', '46', '16', '34', '11', '24', '13', '37', '46', '17', '37')
+Список фамилий: ['Криви', 'Киреев', 'Капитонов', 'Ефремов', 'Добровольска']
+Прочитан кортеж: ('7', '49', '35', '8', '14', '41', '56', '19', '47', '19', '35', '17', '42', '24', '6', '51', '54', '44', '35', '17', '48', '31', '8', '23', '14', '26', '50', '46', '52', '13', '39', '26', '10', '53', '56', '53', '30', '44', '51', '6', '54', '24', '42', '8', '53', '46', '42', '15', '30', '41', '25', '30', '25', '48', '26', '53', '45', '33', '36', '54', '42', '16', '23', '24', '38', '34', '46', '42', '56', '13', '30', '21', '20', '34', '39', '8', '53', '35', '14', '34', '11', '54', '22', '20', '51', '24', '51', '38', '31', '34', '54', '27', '50', '41', '9', '31', '7', '36', '27', '36', '53', '39', '10', '40', '13', '6', '34', '28', '56', '30', '37', '41', '18', '26', '34', '46', '16', '34', '11', '24', '13', '37', '46', '17', '37')
+Прочитан список: ['Криви', 'Киреев', 'Капитонов', 'Ефремов', 'Добровольска']
+Объекты совпадают с исходными!
+Список 1:  ['7', '49', '35', '8', '14'] 
+Список 2:  ['41', '56', '19', '47', '19']
+```

TEMA6/task.py

@@ -0,0 +1,42 @@
+# Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+import random
+tp = tuple(random.randint(6, 56) for i in range(125))
+str_tp = tuple(map(str, tp))
+print(str_tp)
+
+# Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассни
+surn = ["Криви", "Киреев", "Капитонов", "Ефремов", "Добровольска"]
+print("Список фамилий:", surn)
+
+
+# Записать кортеж в бинарный файл.
+import os
+import pickle
+os.chdir(r"C:\Users\user\python-labs\TEMA6")
+a = open('bin.mnz', 'wb')
+pickle.dump(str_tp, a)
+
+#  Записывается в этот же файл список и закрывается файл.
+pickle.dump(surn, a)
+a.close()
+
+# Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+a = open('bin.mnz', 'rb')
+obj1 = pickle.load(a)
+obj2 = pickle.load(a)
+a.close()
+print("Прочитан кортеж:", obj1)
+print("Прочитан список:", obj2)
+
+#  Проверяется на совпадение новых объектов с исходными и выводится соответствующее со-общение.
+if obj1 == str_tp and obj2 == surn:
+    print("Объекты совпадают с исходными!")
+else:
+    print("Объекты не совпадают с исходными!")
+
+# Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+# Создание и вывод в одном цикле
+for i in range(25):
+    exec(f"list{i+1} = list(str_tp[{i*5}:{i*5+5}])")
+
+print("Список 1: " , list1,'\n',"Список 2: ", list2)

TEMA6/test.md

@@ -0,0 +1,55 @@
+# Индивидуальное контрольное задание по теме 5
+
+Зеленкина Катерина, А-02-23
+Вариант 17
+
+## Задание
+1) Запросите у пользователя и введите символьную строку, содержащую некоторое алгебраическое выражение с некоторыми объектами.
+
+2) Задайте значения входящих в выражение объектов и обеспечьте вычисление введенного выражения. 
+
+3) Отобразите полученный результат на экране по шаблону: "Выражение: <введенное выражение> : результат вычисления = <полученный результат>"
+
+4) Запишите в текстовый файл: на первой строке - введенное выражение, на второй строке - результат его вычисления.
+
+5) Удалите из памяти созданные объекты-переменные.
+
+## Решение
+```py
+# 1) Ввод алгебраического выражения 
+a = input("Введите выражение (например: a*b+c): ")
+
+# 2) Даём значения переменным и вычисляем введенное выражение
+b = {}
+for i in a:
+    if i.isalpha() and i not in b: #i.isalpha() - проверяем, что элемент является буквой
+        b[i] = float(input(f"Задайте значение {i}: "))
+
+result = eval(a, b)
+
+# 3) Отображаем полученный результат
+print(f"Выражение: {a} : результат вычисления = {result}")
+
+# 4) Записываем в текстовый файл
+with open('result.txt', 'w') as f:
+    f.write(a + '\n')
+    f.write(str(result))
+
+# 5) Удаляем переменные из памяти
+del a, b, result
+```
+
+Вывод:
+
+```py
+Введите выражение (например: a*b+c): a+b*c+d
+Задайте значение a: 2
+Задайте значение b: 4
+Задайте значение c: 5
+Задайте значение d: 10
+Выражение: a+b*c+d : результат вычисления = 32.0
+```
+
+Запись в файл:
+![Скриншот файла](Фото5.png)
+

TEMA6/test.py

@@ -0,0 +1,21 @@
+# 1) Ввод алгебраического выражения 
+a = input("Введите выражение (например: a*b+c): ")
+
+# 2) Даём значения переменным и вычисляем введенное выражение
+b = {}
+for i in a:
+    if i.isalpha() and i not in b: #i.isalpha() - проверяем, что элемент является буквой
+        b[i] = float(input(f"Задайте значение {i}: "))
+
+result = eval(a, b)
+
+# 3) Отображаем полученный результат
+print(f"Выражение: {a} : результат вычисления = {result}")
+
+# 4) Записываем в текстовый файл
+with open('result.txt', 'w') as f:
+    f.write(a + '\n')
+    f.write(str(result))
+
+# 5) Удаляем переменные из памяти
+del a, b, result

TEMA6/zapis3.txt

@@ -0,0 +1,3 @@
+[1, 2, 3, 4]
+[1, 2, 3, 4]
+[9, 10, 11, 12]

TEMA6/zapis4.txt

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

TEMA6/zapis5.txt

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

TEMA7/report.md

@@ -0,0 +1,570 @@
+# Отчёт по теме 7
+Зеленкина Катерина, А-02-23
+
+## Пункт 1.Запуск оболочки IDLE
+## Пункт 2. Создание пользовательской функции
+### 2.1. Функция без аргументов.
+
+```py
+>>> def uspeh():
+...    """Подтверждение успеха операции"""
+...    print('Выполнено успешно!')
+
+    
+>>> uspeh()
+Выполнено успешно!
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+>>> type(uspeh)
+<class 'function'>
+>>> help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+__Вывод:__ Встроенная помощь (docstring) для функции создается с помощью строки документации в тройных кавычках сразу после объявления функции. Эта строка автоматически становится частью объекта функции и отображается при вызове help()
+
+### 2.2. Функция с аргументами.
+```py
+>>> def sravnenie(a,b):
+...    """Сравнение a и b"""
+...    if a>b:
+...        print(a,' больше ',b)
+...    elif a<b:
+...        print(a, ' меньше ',b)
+...    else:
+...        print(a, ' равно ',b)
+
+>>> n,m=16,5;sravnenie(n,m)
+16  больше  5
+```
+
+Проверим, можно ли эту функцию выполнить с аргументами - символьными строками: 
+```py
+n,m='7','5';sravnenie(n,m)
+7  больше  5
+```
+__Вывод:__ да, эту функцию можно выполнить с символьными строками
+
+### 2.3. Пример функции, содержащей return.
+```py
+>>> def logistfun(b,a):
+...    """Вычисление логистической функции"""
+...    import math
+...    return a/(1+math.exp(-b))
+
+>>> v,w=1,0.7;z=logistfun(w,v)
+>>> z
+0.6681877721681662
+```
+
+### 2.4. Сложение для разных типов аргументов.
+```py
+>>> def slozh(a1,a2,a3,a4):
+...    """ Сложение значений четырех аргументов"""
+...    return a1+a2+a3+a4
+
+>>> slozh(1,2,3,4) #Сложение чисел
+10
+>>> slozh('1','2','3','4') #Сложение строк
+'1234'
+>>> b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+>>> q=slozh(b1,b2,b3,b4); q #Сложение списков
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+Применения этой функции для сложения кортежей, словарей и множеств:
+
+```py
+#Сложение кортежей
+>>> k1=(1, 'p', 3); k2=(4, 'o', 5); k3=(6, 'a', 'b'); k4=(7,'n', 'k')
+>>> q2=slozh(k1,k2,k3,k4);q2 
+(1, 'p', 3, 4, 'o', 5, 6, 'a', 'b', 7, 'n', 'k')
+
+#Сложение множеств
+>>> m1={1, 'p', 3}; m2={4, 'o', 5}; m3={6, 'a', 'b'}; m4={7,'n', 'k'}
+>>> slozh(m1,m2,m3,m4)
+...
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+
+#Сложение словарей
+s1={'a': 1}; s2={'b': 2}; s3={'c': 3}; s4={'d': 4}
+slozh(s1,s2,s3,s4)
+...
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+```
+
+__Вывод:__ Нам выдало ошибку, потому что использование оператора + со множествами и словарями не поддерживается в Python.
+
+### 2.5. Модель устройства: преобразование сигнала x в y.
+```py
+>>> def inerz(x,T,ypred):
+...    """ Модель устройства с памятью:
+...    x- текущее значение вх.сигнала,
+...    T -постоянная времени,
+...    ypred - предыдущее значение выхода устройства"""
+...    y=(x+T*ypred)/(T+1)
+...    return y
+```
+
+Создадим список с измерениями значений входного сигнала – в виде «ступеньки»:
+```py
+>>> sps=[0]+[1]*100
+>>> spsy=[]
+>>> TT=20
+>>> yy=0
+>>> for xx in sps:
+...    yy=inerz(xx,TT,yy)
+...    spsy.append(yy)
+```
+
+Представим выходной сигнал в виде графика.
+
+```py
+>>> import matplotlib.pyplot as plt
+>>> plt.figure(figsize=(10, 6))
+<Figure size 1000x600 with 0 Axes>
+>>> plt.plot(sps, 'r-', linewidth=2, label='Входной сигнал (x)')
+[<matplotlib.lines.Line2D object at 0x0000020A4DDD6490>]
+>>> plt.plot(spsy, 'b-', linewidth=2, label='Выходной сигнал (y)')
+[<matplotlib.lines.Line2D object at 0x0000020A4F55E710>]
+>>> plt.title('Модель устройства с памятью')
+Text(0.5, 1.0, 'Модель устройства с памятью')
+>>> plt.xlabel('Время')
+Text(0.5, 0, 'Время')
+>>> plt.ylabel('Сигнал')
+Text(0, 0.5, 'Сигнал')
+>>> plt.grid(True)
+>>> plt.legend()
+<matplotlib.legend.Legend object at 0x0000020A4F554D70>
+>>> plt.show()
+```
+
+![Скриншон графика1](image1.png)
+
+## Пункт 3. Функции как объекты.
+### 3.1. Получение списка атрибутов объекта-функции.
+
+Получение списка атрибутов объекта-функции.
+```py
+>>> dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+```
+Пример использования атрибута функции:
+```py
+>>> inerz.__doc__
+'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства'
+```
+__Вывод:__ данные берутся из самой функции - строка документации (docstring) в тройных кавычках становится атрибутом __doc__ объекта-функции.
+
+Для сравнения, введём инструкцию:
+```py
+>>> help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+    x- текущее значение вх.сигнала,
+    T -постоянная времени,
+    ypred - предыдущее значение выхода устройства
+```
+__Вывод:__ функция help() форматирует строку документации из doc и дополняет её служебной информацией о функции.
+
+### 3.2. Сохранение ссылки на объект-функцию в другой переменной.
+```py
+>>> fnkt=sravnenie
+>>> v=16
+>>> fnkt(v,23)
+16  меньше  23
+```
+__Вывод:__ в Python можно создать несколько имён-ссылок на одну и ту же функцию, и все они будут работать одинаково.
+
+### 3.3. Возможность альтернативного определения функции в программе.
+```py
+>>> typ_fun=8
+>>> if typ_fun==1:
+...    def func():
+...        print('Функция 1')
+>>> else:
+...    def func():
+...        print('Функция 2')
+
+        
+func()
+Функция 2
+```
+__Вывод:__  вывелась "Функция 2", потому что условие typ_fun==1 ложно и выполнился блок else, где функция переопределяется.
+
+## Пункт 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
+```
+### 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже.
+```py
+>>> b1234=[b1,b2,b3,b4] # Список списков из п.2.4
+>>> qq=slozh(*b1234); qq #Перед ссылкой на список или кортеж надо ставить звездочку
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+### 4.5. Пример со значениями аргументов функции, содержащимися в словаре.
+Функция получила доступ к значениям словаря через переданную ссылку на него.
+```py
+>>> dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+>>> qqq=slozh(**dic4); qqq
+10
+```
+
+### 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):
+...    """Кортеж - сборка аргументов - должен быть последним!"""
+...    smm=0
+...    for elt in kort7:
+...        smm+=elt
+...    return a*smm+b
+
+>>> func4(-1,2,0,3,6)
+-7
+```
+Подобным же образом в списке аргументов функции также можно использовать словарь, предварив его имя двумя звездочками:
+
+```py
+>>> def func_dict(**slovar):
+...    print('Ваш словарь: ', slovar)
+
+    
+>>> func_dict(a=1, b=2, c=3)
+Ваш словарь:  {'a': 1, 'b': 2, 'c': 3}
+```
+
+### 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
+Такое изменение возможно только у объектов изменяемого типа.
+Пример с числовым объектом.
+```py
+>>> a=90 #Числовой объект – не изменяемый тип
+>>> def func3(b):
+...    b=5*b+67
+ 
+>>> func3(a)
+>>> a
+90
+```
+__Вывод:__ значение a не изменилось, так как числа - неизменяемый тип и внутри функции создается новый объект.
+
+Пример со списком.
+```py
+>>> sps1=[1,2,3,4] #Список – изменяемый тип объекта
+>>> def func2(sps):
+...    sps[1]=99
+
+    
+>>> func2(sps1)
+>>> print(sps1)
+[1, 99, 3, 4]
+```
+
+__Вывод:__ да, список sps1 изменился, так как списки передаются по ссылке и являются изменяемыми объектами. Операция sps[1]=99 изменяет исходный список по индексу.
+
+Попробуем применить эту функцию к кортежу.
+```py
+kort=(1,2,3,4)
+func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#162>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#158>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+__Вывод:__ кортежи являются неизменяемыми объектами и не поддерживают присваивание по индексу
+
+## Пункт 5. Специальные типы  пользовательских функций.
+### 5.1. Анонимные функции.
+Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
+Пример.
+```py
+>>> import math
+>>> anfun1=lambda: 1.5+math.log10(17.23)
+>>> anfun1()
+2.7362852774480286
+>>> anfun2=lambda a,b : a+math.log10(b)
+>>> 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
+```
+Попробуем повторно вызвать код:
+```py
+>>> print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#189>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+__Вывод:__ На 4 раз появилась ошибка, потому что итератор alp уже исчерпан и не имеет больше элементов для возврата
+
+## Пункт 6. Локализация объектов в функциях.
+### 6.1. Примеры на локализацию объектов.
+
+Пример 1. Одноименные локальный и глобальный объекты.
+```py
+>>> glb=10
+>>> def func7(arg):
+...    loc1=15
+...    glb=8
+...    return loc1*arg
+
+>>> res=func7(glb)
+>>> res
+150
+```
+
+__Вывод:__ Использовались значения глобальной переменной glb = 10 (как аргумент arg) и локальная переменная loc1 = 15
+Значение glb не изменилась, она осталась равной 10, так как внутри функции создана новая локальная переменная с тем же именем glb=8.
+
+Пример 2. Ошибка в использовании локального объекта.
+```py
+>>> def func8(arg):
+...    loc1=15
+...    print(glb)
+...    glb=8
+...    return loc1*arg
+
+>>> res=func8(glb); res
+Traceback (most recent call last):
+  File "<pyshell#204>", line 1, in <module>
+    res=func8(glb); res
+  File "<pyshell#203>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+
+__Вывод:__ возникает ошибка, потому что сначала идет обращение к переменной, а потом её создание.
+
+Пример 3. Переопределение локализации объекта
+```py
+>>> glb=11
+>>> def func7(arg):
+...        loc1=15
+...        global glb
+...        print(glb)
+...        glb=8
+...        return loc1*arg
+
+    
+>>> res=func7(glb); res
+11
+165
+```
+__Вывод:__ значение переменной glb изменилось, потому что инструкция global glb явно указала, что переменная glb является глобальной, и присваивание glb=8 изменило глобальную переменную, а не создало локальную.
+
+### 6.2. Функции locals() и globals() из builtins
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соот-ветственно, локальными или глобальными на уровне вызова этих функций. 
+Примеры.
+В командной строке введите инструкции
+```py
+>>> globals().keys() #Перечень глобальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'n', 'm', 'sravnenie', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'k1', 'k2', 'k3', 'k4', 'q2', 'm1', 'm2', 'm3', 'm4', 's1', 's2', 's3', 's4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func_dict', 'a', 'func3', 'b', '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', 'n', 'm', 'sravnenie', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'k1', 'k2', 'k3', 'k4', 'q2', 'm1', 'm2', 'm3', 'm4', 's1', 's2', 's3', 's4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func_dict', 'a', 'func3', 'b', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+```
+
+Различий нет, так как в основном модуле (глобальной области видимости) словари globals() и locals() ссылаются на один и тот же объект.
+
+```py
+>>> def func8(arg):
+...    loc1=15
+...    loc1=15
+...    print(globals().keys())
+...    print(locals().keys())
+...    return loc1*arg
+
+>>> hh=func8(glb); hh
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'n', 'm', 'sravnenie', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'k1', 'k2', 'k3', 'k4', 'q2', 'm1', 'm2', 'm3', 'm4', 's1', 's2', 's3', 's4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func_dict', 'a', 'func3', 'b', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1'])
+120
+```
+
+Внутри функции locals() показывает только локальные параметры и переменные функции, а globals() — все объекты модуля.
+
+Проверим наличие объекта glb в перечне глобальных объектов:
+```py
+>>> '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); kk
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'n', 'm', 'sravnenie', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'k1', 'k2', 'k3', 'k4', 'q2', 'm1', 'm2', 'm3', 'm4', 's1', 's2', 's3', 's4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func_dict', 'a', 'func3', 'b', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'n', 'm', 'sravnenie', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'k1', 'k2', 'k3', 'k4', 'q2', 'm1', 'm2', 'm3', 'm4', 's1', 's2', 's3', 's4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func_dict', 'a', 'func3', 'b', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+85
+```
+Внешняя функция func9 содержит в своей локальной области параметры arg2, arg3 и внутренние переменные loc1, glb, а также вложенную функцию func9_1.
+Вложенная функция func9_1 работает в изолированной локальной области со своими переменными arg1, loc1, glb1 и не видит локальные переменные внешней функции func9, но имеет доступ к глобальной области модуля.
+
+### 6.4. Большой пример
+```py
+import math
+
+# Ввод параметров
+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))
+
+print("Входной сигнал:", vhod)
+
+# Функции компонентов системы
+def realdvig(xtt, kk1, TT, yti1, ytin1):
+    """Модель реального двигателя"""
+    yp = kk1 * xtt  # усилитель
+    yti1 = yp + yti1  # Интегратор
+    ytin1 = (yti1 + TT * ytin1) / (TT + 1)
+    return [yti1, ytin1]
+
+def tahogen(xtt, kk2, yti2):
+    """Модель тахогенератора"""
+    yp = kk2 * xtt   # усилитель
+    yti2 = yp + yti2  # интегратор
+    return yti2
+
+def nechus(xtt, gran):
+    """Зона нечувствительности"""
+    if xtt < gran and xtt > (-gran):
+        ytt = 0
+    elif xtt >= gran:
+        ytt = xtt - gran
+    elif xtt <= (-gran):
+        ytt = xtt + gran
+    return ytt
+
+# Реализация соединения компонент
+yi1 = 0; yin1 = 0; yi2 = 0
+vyhod = []
+for xt in vhod:
+    xt1 = xt - yi2   # отрицательная обратная связь
+    [yi1, yin1] = realdvig(xt1, k1, T, yi1, yin1)
+    yi2 = tahogen(yin1, k2, yi2)
+    yt = nechus(yin1, Xm)
+    vyhod.append(yt)
+
+print('y=', vyhod)
+
+k1,T,k2,Xm,A,F,N=10, 20, 1.5, 8, 3.9, 22, 12
+Входной сигнал: [0.0, 1.0987569716815757, 2.1084991880768302, 2.947423339981607, 3.5475647818826213, 3.8603036233356374, 3.860303623335638, 3.5475647818826217, 2.947423339981607, 2.108499188076831, 1.0987569716815757, 2.209560170082712e-15]
+y= [0, 0, 0, 0, 0, 0, 0, -0.25334827984566566, 0, 7.152382915540651, 20.1527847908908, 9.624947687157025]
+```
+
+## Пункт 7. Окончание сеанса работы с IDLE.

TEMA7/signal.txt

@@ -0,0 +1,20 @@
+0.0
+1.1755705045849463
+1.902113032590307
+1.9021130325903073
+1.1755705045849465
+2.4492935982947064e-16
+-1.175570504584946
+-1.902113032590307
+-1.9021130325903073
+-1.1755705045849467
+-4.898587196589413e-16
+1.1755705045849445
+1.902113032590307
+1.9021130325903073
+1.1755705045849467
+7.347880794884119e-16
+-1.1755705045849456
+-1.9021130325903068
+-1.9021130325903075
+-1.175570504584947

TEMA7/task.md

@@ -0,0 +1,104 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с за-держкой на заданное время Т.
+2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: вы-борка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y ли-нейной регрессии при значении переменной Х 
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+
+## Решение
+```py
+def signal_delay(current_input, delay_time, output_history, input_history):
+    """
+    Расчет выходного сигнала устройства задержки
+    current_input - текущее значение входного сигнала
+    delay_time - время задержки
+    output_history - история выходных значений
+    input_history - история входных значений
+    """
+    if len(input_history) < delay_time:
+        return 0
+    else:
+        return input_history[-delay_time]
+
+
+d = 4
+output_signal = []
+input_signal = [1, 2, 3, 4, 5, 6, 7]
+input_history = []
+
+for x in input_signal:
+    input_history.append(x)
+    y = signal_delay(x, d, output_signal, input_history)
+    output_signal.append(y)
+
+print("Входной сигнал:", input_signal)
+print("Выходной сигнал:", output_signal, "(задержка 4)")
+
+
+Входной сигнал: [1, 2, 3, 4, 5, 6, 7]
+Выходной сигнал: [0, 0, 0, 1, 2, 3, 4] (задержка 4)
+```
+
+```py
+# Пункт 2
+def raschet_giostogrammy(viborka, kol_int):
+    """
+    Расчет гистограммы по выборке случайной величины
+    
+    Аргументы:
+    viborka - список значений выборки
+    kol_int - число интервалов разбиения
+    
+    Возвращает:
+    w - список с числами элементов в интервалах
+    """
+    minn = min(viborka)
+    maxx = max(viborka)
+    shirina = (maxx - minn) / kol_int  
+
+    w = [0] * kol_int
+
+    for znachenie in viborka:
+        num_int = int((znachenie - minn) / shirina)  
+        if num_int == kol_int:
+            num_int = kol_int - 1
+        w[num_int] += 1
+
+    # Вывод таблицы
+    print("Гистограмма:")
+    print("Интервал\t\tКоличество")
+    for i in range(kol_int):
+        start = minn + i * shirina
+        end = minn + (i + 1) * shirina
+        print(f"{start:.2f} - {end:.2f}\t\t{w[i]}")
+
+    return w
+
+# Проверка функции
+import random
+
+viborka = [random.gauss(0, 1) for _ in range(100)]
+kol_interv = 5
+resultat = raschet_giostogrammy(viborka, kol_interv)
+
+
+
+Гистограмма:
+Интервал		Количество
+-2.11 - -1.31		13
+-1.31 - -0.52		12
+-0.52 - 0.28		30
+0.28 - 1.07		34
+1.07 - 1.86		11
+```
+
+```py
+anonim_func = lambda b1, b2, X: b1 + b2 * X
+print(anonim_func (1, 2, 3))
+
+7
+```

TEMA7/task.py

@@ -0,0 +1,75 @@
+# Пункт 1
+def signal_delay(current_input, delay_time, output_history, input_history):
+    """
+    Расчет выходного сигнала устройства задержки
+    current_input - текущее значение входного сигнала
+    delay_time - время задержки
+    output_history - история выходных значений
+    input_history - история входных значений
+    """
+    if len(input_history) < delay_time:
+        return 0
+    else:
+        return input_history[-delay_time]
+
+
+d = 4
+output_signal = []
+input_signal = [1, 2, 3, 4, 5, 6, 7]
+input_history = []
+
+for x in input_signal:
+    input_history.append(x)
+    y = signal_delay(x, d, output_signal, input_history)
+    output_signal.append(y)
+
+print("Входной сигнал:", input_signal)
+print("Выходной сигнал:", output_signal, "(задержка 4)")
+
+
+# Пункт 2
+def raschet_giostogrammy(viborka, kol_int):
+    """
+    Расчет гистограммы по выборке случайной величины
+    
+    Аргументы:
+    viborka - список значений выборки
+    kol_int - число интервалов разбиения
+    
+    Возвращает:
+    w - список с числами элементов в интервалах
+    """
+    minn = min(viborka)
+    maxx = max(viborka)
+    shirina = (maxx - minn) / kol_int  
+
+    w = [0] * kol_int
+
+    for znachenie in viborka:
+        num_int = int((znachenie - minn) / shirina)  
+        if num_int == kol_int:
+            num_int = kol_int - 1
+        w[num_int] += 1
+
+    # Вывод таблицы
+    print("Гистограмма:")
+    print("Интервал\t\tКоличество")
+    for i in range(kol_int):
+        start = minn + i * shirina
+        end = minn + (i + 1) * shirina
+        print(f"{start:.2f} - {end:.2f}\t\t{w[i]}")
+
+    return w
+
+# Проверка функции
+import random
+
+viborka = [random.gauss(0, 1) for _ in range(100)]
+kol_interv = 5
+resultat = raschet_giostogrammy(viborka, kol_interv)
+
+
+# Пункт 3
+anonim_func = lambda b1, b2, X: b1 + b2 * X
+print(anonim_func (1, 2, 3))
+

TEMA7/test.md

@@ -0,0 +1,34 @@
+# Индивидуальное контрольное задание по теме 7
+
+Зеленкина Катерина, А-02-23
+Вариант 1
+
+## Задание
+Разработайте функцию с 5 аргументами, создающую последовательность отсчетов синусоидального сигнала с заданными параметрами: амплитуда, период, фаза, число отсчетов (аргументы функции). Сигнал должен быть записан в виде столбца в текстовый файл с заданным именем (5-й аргумент функции), а также возвращен в вызывающую программу в виде списка.
+
+## Решение
+```py
+import math
+def signal(A, T, phi, N, filename):
+    signal = []
+    for i in range(N):
+        value = A * math.sin(2 * math.pi * i / T + phi)
+        signal.append(value)
+        
+    f = open(filename, 'w')
+    for val in signal:
+        f.write(str(val) + '\n')
+    f.close()
+    return signal
+
+result = signal(2.0, 10.0, 0.0, 20, "signal.txt")
+print(f"Количество отсчётов: {len(result)}")
+print(f"Значений: {result}")
+
+
+Количество отсчётов: 20
+Значения: [0.0, 1.1755705045849463, 1.902113032590307, 1.9021130325903073, 1.1755705045849465, 2.4492935982947064e-16, -1.175570504584946, -1.902113032590307, -1.9021130325903073, -1.1755705045849467, -4.898587196589413e-16, 1.1755705045849445, 1.902113032590307, 1.9021130325903073, 1.1755705045849467, 7.347880794884119e-16, -1.1755705045849456, -1.9021130325903068, -1.9021130325903075, -1.175570504584947]
+```
+
+Содержимое файла "signal"
+![Скриншот файла](image2.png)

TEMA7/test.py

@@ -0,0 +1,16 @@
+import math
+def signal(A, T, phi, N, filename):
+    signal = []
+    for i in range(N):
+        value = A * math.sin(2 * math.pi * i / T + phi)
+        signal.append(value)
+        
+    f = open(filename, 'w')
+    for val in signal:
+        f.write(str(val) + '\n')
+    f.close()
+    return signal
+
+result = signal(2.0, 10.0, 0.0, 20, "signal.txt")
+print(f"Количество отсчётов: {len(result)}")
+print(f"Значения: {result}")

TEMA8/MM0.py

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

TEMA8/MM1.py

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

TEMA8/MM2.py

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

TEMA8/Mod0.py

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

TEMA8/Mod2.py

@@ -1,6 +1,8 @@
 def alpha():
     print('****ALPHA****')
     t=input('Значение t=')
+    n=beta(6)
+    print(n)
     return t
 
 def beta(q):
@@ -8,4 +10,3 @@ def beta(q):
     import math
     expi=q*math.pi
     return math.exp(expi)
-    

TEMA8/data.txt

@@ -0,0 +1,3 @@
+10 20 30.5
+40 50 60
+70 80

TEMA8/data2.txt

@@ -0,0 +1,4 @@
+15.2 20.1 25.3 18.4 22.7
+19.6 14.8 13.5 24.9 28.3
+21.4 23.6 27.9 16.8 22.2
+14.7 29.5 21.8 25.1 17.3

TEMA8/report.md

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

TEMA8/task.md

@@ -0,0 +1,69 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+Разработайте программу, состоящую из трех модулей:
+1. Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+2. Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+3. Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+
+## Решение
+Модуль 1
+```py
+def mod1(fn):
+    numbers = []
+    
+    with open(fn, 'r') as f:
+        for line in f:
+            # Разбиваем строку на элементы
+            elements = line.strip().split()
+            # Преобразуем каждый элемент в число
+            for element in elements:
+                number = float(element)
+                numbers.append(number)
+    
+    return numbers
+
+# Пример использования
+result = mod1("data.txt")
+print('Список файла1: ', result)
+
+Список файла1:  [10.0, 20.0, 30.5, 40.0, 50.0, 60.0, 70.0, 80.0]
+```
+
+Модуль 2
+```py
+import statistics
+def mod2(list1, list2):
+    n = min(len(list1), len(list2))
+    if n == 0:
+        return 0.0
+    x = list1[:n]
+    y = list2[:n]
+    
+    cor = statistics.correlation(x, y)
+    return cor
+```
+
+Модуль 3
+```py
+import task1
+import task2
+
+file1 = input("Первый файл: ")
+file2 = input("Второй файл: ")
+
+list1 = task1.mod1(file1)
+list2 = task1.mod1(file2)
+result = task2.mod2(list1, list2)
+
+print(f"Коэффициент корреляции: {result:.3f}")
+
+
+Первый файл: data.txt
+Второй файл: data2.txt
+Коэффициент корреляции: -0.361
+```

TEMA8/task1.py

@@ -0,0 +1,17 @@
+def mod1(fn):
+    numbers = []
+    
+    with open(fn, 'r') as f:
+        for line in f:
+            # Разбиваем строку на элементы
+            elements = line.strip().split()
+            # Преобразуем каждый элемент в число
+            for element in elements:
+                number = float(element)
+                numbers.append(number)
+    
+    return numbers
+
+# Пример использования
+result = mod1("data.txt")
+print('Список файла1: ', result)

TEMA8/task2.py

@@ -0,0 +1,10 @@
+import statistics
+def mod2(list1, list2):
+    n = min(len(list1), len(list2))
+    if n == 0:
+        return 0.0
+    x = list1[:n]
+    y = list2[:n]
+    
+    cor = statistics.correlation(x, y)
+    return cor

TEMA8/task3.py

@@ -0,0 +1,11 @@
+import task1
+import task2
+
+file1 = input("Первый файл: ")
+file2 = input("Второй файл: ")
+
+list1 = task1.mod1(file1)
+list2 = task1.mod1(file2)
+result = task2.mod2(list1, list2)
+
+print(f"Коэффициент корреляции: {result:.3f}")

TEMA8/test/Mod1.py

@@ -0,0 +1,37 @@
+# Mod1.py
+import math
+
+def calc_function(a, x):
+    if x == 0:
+        return a
+    return a * math.sin(x) / x
+
+def calculate_interval(a, x_start=0.5, x_end=50, step=0.5):
+    results = []
+    x = x_start
+    while x <= x_end:
+        value = calc_function(a, x)
+        results.append((x, value))
+        x += step
+    return results
+
+def write_to_file(results, filename="output.txt"):
+    with open(filename, 'w', encoding='utf-8') as f:
+        for x, val in results:
+            f.write(f"{val}\n")
+    print(f"Данные записаны в файл: {filename}")
+
+def plot_function(results):
+    import matplotlib.pyplot as plt
+    
+    x_vals = [item[0] for item in results]
+    y_vals = [item[1] for item in results]
+    
+    plt.figure(figsize=(10, 5))
+    plt.plot(x_vals, y_vals, label="f(x) = a * sin(x) / x", color='blue')
+    plt.title("График функции f(x) = a * sin(x) / x")
+    plt.xlabel("x")
+    plt.ylabel("f(x)")
+    plt.grid(True)
+    plt.legend()
+    plt.show()

TEMA8/test/Mod2.py

@@ -0,0 +1,24 @@
+import Mod1
+
+print("=" * 50)
+print("Расчёт функции f(x) = a * sin(x) / x")
+print("=" * 50)
+
+try:
+    a = float(input("Введите коэффициент a: "))
+    filename = input("Введите имя файла ('output.txt'): ") or "output.txt"
+except ValueError:
+    print("Ошибка ввода! Используйте числа.")
+    exit()
+
+results = Mod1.calculate_interval(a)
+
+print("\nПервые 10 значений:")
+for x, val in results[:10]:
+    print(f"  x={x:.1f}, f(x)={val:.6f}")
+
+Mod1.write_to_file(results, filename)
+
+print("\nОтображение графика:")
+Mod1.plot_function(results)
+

TEMA8/test/output.txt

@@ -0,0 +1,100 @@
+1.917702154416812
+1.682941969615793
+1.3299933154720727
+0.9092974268256817
+0.47877771528316515
+0.0940800053732448
+-0.20044755867978276
+-0.3784012476539641
+-0.43445783007337646
+-0.3835697098652554
+-0.2565601183892334
+-0.09313849939964196
+0.0661907655654817
+0.18771045677679687
+0.25013332713993036
+0.24733956165584545
+0.18787932061729182
+0.09158188560927924
+-0.015821288518275644
+-0.10880422217787396
+-0.16756109713746095
+-0.181816401191037
+-0.1522525521197267
+-0.08942881966673916
+-0.01061150357619211
+0.06464108258871398
+0.11907917430394385
+0.14151533652783863
+0.1289510421413356
+0.08670504535428224
+0.026640965411328592
+-0.03598791458313316
+-0.08627701119625734
+-0.11310558727994786
+-0.11150011491064658
+-0.08344302741907512
+-0.037024931726444596
+0.015776548385573932
+0.06210665330457447
+0.09129452507276277
+0.09725168724671213
+0.0796814893843863
+0.04387339563666941
+-0.0008046644809458069
+-0.043304401107600844
+-0.07358438297175397
+-0.08494315131739542
+-0.07546486350055198
+-0.0482740840706224
+-0.010588140007821843
+0.028161439531150453
+0.05865834234458482
+0.07391378438520128
+0.07084266136329652
+0.050853820484007106
+0.019350413450562074
+-0.015702150188547117
+-0.045767854083652935
+-0.06379873954867482
+-0.06586877493952412
+-0.05200834357096952
+-0.026066944859552584
+0.005331711472491862
+0.03446416757760566
+0.05439202606435881
+0.06060071879437983
+0.052008358219055306
+0.031122510948236697
+0.0033326074263724387
+-0.024467581114065773
+-0.04557852204010741
+-0.05509882519128421
+-0.05105298015642222
+-0.034785845046324294
+-0.010549269313944655
+0.015598346247862386
+0.03729738144268281
+0.049425404424825015
+0.049298504085821676
+0.03725565802396744
+0.01650129268387262
+-0.007737691161205316
+-0.029520971227733485
+-0.0436438832340778
+-0.046874658970333834
+-0.038687197331562714
+-0.021324851309601257
+0.0008046329593369808
+0.02224203674393834
+0.0378179344237386
+0.043894104281836065
+0.0392081890282091
+0.02512673481347465
+0.005258430755115915
+-0.01546548838459753
+-0.03201061088848612
+-0.04045807994239575
+-0.03892867970446824
+-0.027995351686209927
+-0.01049499414815715

TEMA8/test/test.md

@@ -0,0 +1,101 @@
+# Индивидуальное контрольное задание по теме 8
+
+Зеленкина Катерина, А-02-23
+Вариант 8
+
+## Задание
+Задание из ЛР7: разработайте анонимную функцию, вычисляющую значение a*sin(x)/x, где a,x – аргументы функции. Рассчитайте эту функцию в интервале значений х:  0<x≤50 с шагом 0.5 и при некотором значении коэффициента a. Обеспечьте запись рассчитанных значений в текстовый файл по одному значению на строке. Отобразите рассчитанные значения в виде графика.
+
+## Решение
+Содержимое Mod1
+```py
+# Mod1.py
+import math
+
+def calc_function(a, x):
+    if x == 0:
+        return a
+    return a * math.sin(x) / x
+
+def calculate_interval(a, x_start=0.5, x_end=50, step=0.5):
+    results = []
+    x = x_start
+    while x <= x_end:
+        value = calc_function(a, x)
+        results.append((x, value))
+        x += step
+    return results
+
+def write_to_file(results, filename="output.txt"):
+    with open(filename, 'w', encoding='utf-8') as f:
+        for x, val in results:
+            f.write(f"{val}\n")
+    print(f"Данные записаны в файл: {filename}")
+
+def plot_function(results):
+    import matplotlib.pyplot as plt
+    
+    x_vals = [item[0] for item in results]
+    y_vals = [item[1] for item in results]
+    
+    plt.figure(figsize=(10, 5))
+    plt.plot(x_vals, y_vals, label="f(x) = a * sin(x) / x", color='blue')
+    plt.title("График функции f(x) = a * sin(x) / x")
+    plt.xlabel("x")
+    plt.ylabel("f(x)")
+    plt.grid(True)
+    plt.legend()
+    plt.show()
+```
+
+Содержимое Mod2:
+```py
+import Mod1
+
+print("=" * 50)
+print("Расчёт функции f(x) = a * sin(x) / x")
+print("=" * 50)
+
+try:
+    a = float(input("Введите коэффициент a: "))
+    filename = input("Введите имя файла ('output.txt'): ") or "output.txt"
+except ValueError:
+    print("Ошибка ввода! Используйте числа.")
+    exit()
+
+results = Mod1.calculate_interval(a)
+
+print("\nПервые 10 значений:")
+for x, val in results[:10]:
+    print(f"  x={x:.1f}, f(x)={val:.6f}")
+
+Mod1.write_to_file(results, filename)
+
+print("\nОтображение графика:")
+Mod1.plot_function(results)
+```
+
+Вывод:
+```py
+Введите коэффициент a: 2
+Введите имя файла ('output.txt'): output.txt
+
+Первые 10 значений:
+  x=0.5, f(x)=1.917702
+  x=1.0, f(x)=1.682942
+  x=1.5, f(x)=1.329993
+  x=2.0, f(x)=0.909297
+  x=2.5, f(x)=0.478778
+  x=3.0, f(x)=0.094080
+  x=3.5, f(x)=-0.200448
+  x=4.0, f(x)=-0.378401
+  x=4.5, f(x)=-0.434458
+  x=5.0, f(x)=-0.383570
+Данные записаны в файл: output.txt
+
+Отображение графика:
+```
+![Скриншот графика1](image1.png)
+
+Файл __output.txt__ был успешно создан:
+![Скриншот файла](image2.png)

TEMA9/Mod3.py

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

TEMA9/SAU.py

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

TEMA9/main_SAU.py

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

TEMA9/report.md

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

TEMA9/task.md

@@ -0,0 +1,71 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+1.Конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+2.Метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+3.Метод для обеспечения перевода сотрудника из одного отдела в другой;
+4.Метод для изменения должности сотрудника;
+5.Свойство, содержащее перечень (список) поощрений сотрудника.
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобрази-те эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+## Решение
+```py
+class CLASS:
+    def __init__(self, fio, otdel, dolzhnost, oklad):
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+        self.pooshrenia = []  
+
+    def salary_raise(self, summa):
+        if summa > 0:
+            self.oklad += summa
+            return f"Оклад увеличен на {summa}. Новый: {self.oklad}"
+
+    def change_department(self, new_department):
+        self.otdel = new_department
+        return f"Переведен в отдел {new_department}"
+
+    def change_position(self, new_position):
+        self.dolzhnost = new_position
+        return f"Должность изменена на {new_position}"
+
+    def add_encouragement(self, tekst):
+        self.pooshrenia.append(tekst)
+
+    def info(self):
+        return f"{self.fio}, {self.otdel}, {self.dolzhnost}, оклад: {self.oklad}"
+
+
+emp1 = CLASS("Обычайко Д. С.", "УИТ", "Ассистент", 70000)
+emp2 = CLASS("Толчеев В. О.", "УИТ", "Профессор", 100000)
+
+print(emp1.info())
+print(emp2.info())
+
+print(emp1.salary_raise(10000))
+print(emp2.change_department("Зав. кафедры"))
+print(emp1.change_position("Старший преподаватель"))
+
+emp2.add_encouragement("Лучший лектор")
+emp1.add_encouragement("За экспертную работу")
+
+print(f"Поощрения {emp1.fio}: {emp1.pooshrenia}")
+print(f"Поощрения {emp2.fio}: {emp2.pooshrenia}")
+
+```
+
+```py
+Обычайко Д. С., УИТ, Ассистент, оклад: 70000
+Толчеев В. О., УИТ, Профессор, оклад: 100000
+Оклад увеличен на 10000. Новый: 80000
+Переведен в отдел Зав. кафедры
+Должность изменена на Старший преподаватель
+Поощрения Обычайко Д. С.: ['За экспертную работу']
+Поощрения Толчеев В. О.: ['Лучший лектор']
+```
+

TEMA9/task.py

@@ -0,0 +1,43 @@
+class CLASS:
+    def __init__(self, fio, otdel, dolzhnost, oklad):
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+        self.pooshrenia = []  
+
+    def salary_raise(self, summa):
+        if summa > 0:
+            self.oklad += summa
+            return f"Оклад увеличен на {summa}. Новый: {self.oklad}"
+
+    def change_department(self, new_department):
+        self.otdel = new_department
+        return f"Переведен в отдел {new_department}"
+
+    def change_position(self, new_position):
+        self.dolzhnost = new_position
+        return f"Должность изменена на {new_position}"
+
+    def add_encouragement(self, tekst):
+        self.pooshrenia.append(tekst)
+
+    def info(self):
+        return f"{self.fio}, {self.otdel}, {self.dolzhnost}, оклад: {self.oklad}"
+
+
+emp1 = CLASS("Обычайко Д. С.", "УИТ", "Ассистент", 70000)
+emp2 = CLASS("Толчеев В. О.", "УИТ", "Профессор", 100000)
+
+print(emp1.info())
+print(emp2.info())
+
+print(emp1.salary_raise(10000))
+print(emp2.change_department("Зав. кафедры"))
+print(emp1.change_position("Старший преподаватель"))
+
+emp2.add_encouragement("Лучший лектор")
+emp1.add_encouragement("За экспертную работу")
+
+print(f"Поощрения {emp1.fio}: {emp1.pooshrenia}")
+print(f"Поощрения {emp2.fio}: {emp2.pooshrenia}")

TEMA9/test/M0.py

@@ -0,0 +1,10 @@
+import M2
+
+res = M2.main()
+if res:
+    c, p, o = res
+    with open("Res3030.txt", "w", encoding="utf-8") as f:
+        f.write("Результаты:\n")
+        for country, value in zip(c, p):
+            f.write(f"{country}: {value}\n")
+        f.write(f"\nОбщее: {o}")

TEMA9/test/M1.py

@@ -0,0 +1,20 @@
+import pylab
+
+def calc(d):
+    pop = 0
+    res = 0
+    cnt = []
+    per = []
+    for c, v in d.items():
+        pop += v[0]
+        res += v[1]
+        cnt.append(c)
+        per.append(v[1]/v[0] if v[0]>0 else 0)
+    return cnt, per, res/pop if pop>0 else 0
+
+def plot(d):
+    pylab.bar(d.keys(), [v[1] for v in d.values()])
+    pylab.title('Ресурс по странам')
+    pylab.xlabel('Страны')
+    pylab.ylabel('Ресурс')
+    pylab.show()

TEMA9/test/M2.py

@@ -0,0 +1,30 @@
+import os
+import M1
+
+def main():
+    fname = input("Файл (data.txt): ")
+    if not os.path.isfile(fname):
+        print("Файл не найден")
+        return
+    
+    # Чтение данных
+    data = {}
+    with open(fname, 'r', encoding='utf-8') as f:
+        for line in f:
+            c, p, r = line.strip().split()
+            data[c] = [float(p), float(r)]
+    
+    print("Данные:", data)
+    
+    # Расчёт
+    c, p, o = M1.calc(data)
+    
+    print("\nРесурс на душу:")
+    for country, val in zip(c, p):
+        print(f"{country}: {val:.3f}")
+    print(f"\nОбщее: {o:.3f}")
+    
+    # График
+    M1.plot(data)
+    
+    return c, p, o

TEMA9/test/Res3030.txt

@@ -0,0 +1,9 @@
+Результаты:
+США: 0.07682119205298013
+Россия: 0.10342465753424657
+Австралия: 0.5
+Китай: 0.009216909216909217
+Индия: 0.007279151943462898
+Германия: 0.03975903614457831
+
+Общее: 0.023178226514486387