Test

TEMA1/Pr0.py

@@ -0,0 +1,58 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Параметры системы
+K = 2.0
+
+# Частотный диапазон (логарифмическая шкала)
+omega = np.logspace(-1, 2, 500)  # от 0.1 до 100 рад/с
+
+# Действительная и мнимая части АФХ
+U = np.zeros_like(omega)  # Всегда 0
+V = -K / omega  # Мнимая часть
+
+# Построение годографа
+plt.figure(figsize=(8, 8))
+plt.plot(U, V, 'b-', linewidth=2, label='АФХ (годограф)')
+plt.plot(U[0], V[0], 'go', markersize=8, label='Начало (ω=0.1)')
+plt.plot(U[-1], V[-1], 'ro', markersize=8, label='Конец (ω=100)')
+
+# Стрелки направления увеличения частоты
+for i in [50, 150, 300]:  # индексы для стрелок
+    plt.arrow(U[i], V[i], U[i+10]-U[i], V[i+10]-V[i],
+              head_width=0.1, head_length=0.1, fc='k', ec='k')
+
+plt.xlabel('Действительная часть Re(W)')
+plt.ylabel('Мнимая часть Im(W)')
+plt.title(f'АФХ для интегрирующего звена $W(p) = K/p$\nK={K}')
+plt.grid(True, alpha=0.3)
+plt.axis('equal')
+plt.legend()
+plt.show()
+
+# Дополнительно: построение отдельно действительной и мнимой частей
+plt.figure(figsize=(12, 4))
+
+plt.subplot(1, 2, 1)
+plt.semilogx(omega, U, 'r-', linewidth=2)
+plt.xlabel('ω (рад/с)')
+plt.ylabel('Re(W)')
+plt.title('Действительная часть')
+plt.grid(True, alpha=0.3)
+
+plt.subplot(1, 2, 2)
+plt.semilogx(omega, V, 'g-', linewidth=2)
+plt.xlabel('ω (рад/с)')
+plt.ylabel('Im(W)')
+plt.title('Мнимая часть')
+plt.grid(True, alpha=0.3)
+
+plt.tight_layout()
+plt.show()
+
+# Вывод таблицы значений
+print("Таблица значений АФХ:")
+print("ω\t\tRe(W)\t\tIm(W)")
+print("-" * 40)
+for i in range(0, len(omega), 50):
+    print(f"{omega[i]:.2f}\t\t{U[i]:.2f}\t\t{V[i]:.2f}")

TEMA1/protocolIDLE.py

@@ -0,0 +1,14 @@
+ #Программа по Теме 1 <Зеленкина Ксения Михайловна>
+import os
+os.chdir("C:/Users/user/OneDrive/Documents/ZelenkinaKs/python-labs/TEMA1/Отчет")
+
+import Pr0
+Hello
+Your name=Ksenia
+
+import os
+os.chdir("C:/Users/user/OneDrive/Documents/ZelenkinaKs/python-labs/TEMA1/Отчет")
+
+import prb1
+Hello
+Your name=Ksenia

TEMA1/Отчет/report.md

@@ -0,0 +1,86 @@
+# Отчет по Теме 1
+
+Зеленкина Ксения, А-02-23
+
+## Интерпретатор
+## __п. 2 - 5__
+Запустила на выполнение программу-интерпретатор. Изучила содержание открывающегося диалогового окна интерпретатора. Ввела инструкцию, указанную в п.3-5.
+
+<img src = "./photo1.png" width="500" height="300" align="center">
+
+### Изучение среды IDLE
+##### __п. 6 - 8__
+Запустила оболочку интерактивную графическую оболочку IDLE среды Python и изучила устройство главного командного окна среды. В командном окне после символов приглашения к диалогу ввела инструкцию настройки рабочего каталога среды по образцу.
+
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\user\\OneDrive\\Documents\\KseniaZelenkina\\python-labs\\TEMA1\\Отчет')
+```
+
+## Стиль и запуск файла Pr0
+## __п. 9 - 10__
+Изучила предложения главного меню, а также предложения выпадающих меню. Установила в среде шрифт типа _Arial CYR_, размер 11, размер начального окна - высота 50 символов, ширина 100 символов, подкраска комментариев - коричневая.
+В окне текстового редактора оболочки IDLE вставьте инструкции, использованные при выполнении п.п. 3, 4 и 8.  
+
+<img src = "./photo3.png">
+
+Сохранила в файле __Pr0__ с расширением __py__ и запустите инструкции 3 способами:
+__1 способ:__ через «Run module». 
+__2 способ:__ через import Pr0
+__3 способ:__ с помощь F5
+
+<img src = "./photo4.png">
+
+<img src = "./photo5.png">
+
+## Запуск файла prb1
+## __п. 11__
+prb1 запустила также через _import prb1_, _«Run module»_ и _F5_.
+
+<img src = "./photo6.png">
+
+## Каталог pycache
+## __п. 12__
+Открыл в каталоге __pycache__  и открыла в текстовом редакторе файл __Pr0.cpython-34.pyc__, а также запустила его.
+
+<img src = "./photo7.png">
+
+Мы видим скомпилированный байт-код Python, а не исходный код. Это происходит потому, что Python сначала компилирует программу в промежуточный байт-код, который затем выполняется виртуальной машиной Python. 
+Компиляция программ нужна для: проверки синтаксиса, оптимизации, сокрытия исходного кода.
+
+<img src = "./photo8.png">
+
+## Раздел Help
+## __п. 13 - 14__
+Изучила раздел помощи __Help__, в которой прилагаются такие виды помощи как _About IDLE_, _IDLE Doc_, _Python Docs_, _Turtle Demo_.
+Также в командном окне ввела инструкцию __help(print)__,  а затем попробовала ввести сразу несколько инструкций __help(print)__, __help(input)__.
+
+<img src = "./photo9.png" width="500" height="400" align="center">
+
+Затем попробовала ранее рассмотренный способ: поставила в командном окне IDLE курсор на строку с ранее введенной инструкцией помощи по функции print и нажала клавишу _Enter_. Копия инструкции появилась в новой строке.
+Также попробовала обратиться к оперативной помощи через клавишу __F1__ _(fn + F1)_. Нашла через  закладку __Index__ строку __print() (built-in function)__.
+
+<img src = "./photo10.png" width="500" height="400" align="center">
+
+<img src = "./photo11.png" width="500" height="400" align="center">
+
+## Window и возможности Help
+## __п. 15 - 14__
+Открыла 3 окна: командное окно IDLE (Python Shell) и 2 окна текстового редактора. Воспользовалась предложением __Window__.
+
+<img src = "./photo12.png">
+
+Сделала активным окно редактора с программой prb1 и запустила её. Теперь у меня 4 окна: командное окно (Python Shell) и три окна в редакторе. Поочередно активизировала эти окна.
+Запустила программу из файла __tdemo_chaos__. . Открыла этот файл в окне текстового редактора и оценила краткость программы и её графические возможности.
+
+<img src = "./photo13.png" width="500" height="400" align="center">
+
+Выберите предложения __Help => Turtle Demo => Examples__ и из появляющегося списка примеров - __Clock => Start__.
+
+<img src = "./photo14.png" width="500" height="300" align="center">
+
+Попробовала другие примеры.
+
+<img src = "./photo15.png" width="500" height="300" align="center">
+
+## Завершение работы со средой

TEMA1/Отчет/Ответ.md

@@ -0,0 +1,13 @@
+# Общее контрольное задание по теме 1
+
+Зеленкина Ксения, А-02-23
+
+## Вопрос
+Для чего предназначено предложение __«Окно (Window)»__ главного меню?
+
+## Ответ
+
+"Окно (Window)" позволяет:
+1) Посмотреть, какие файлы открыты ( а также увидеть их расположение)
+2) Переключаться между файлами
+3) Увидеть, в какой последовательности они были открыты

TEMA2/Кз.md

@@ -0,0 +1,26 @@
+# Общее контрольное задание по теме 2
+
+Зеленкина Ксения, А-02-23
+
+## Задание
+__Вариант 15__
+
+Создайте объект
+nm=(12,23,34,14,-7,-34)
+К какому классу относится этот объект? Напишите инструкцию, обеспечивающую расчет разности сумм первых трех элементов и последних трех.
+
+## Решение
+
+Данный объект относится к классу _кортеж_.
+__Код:__
+```py
+>>> nm=(12,23,34,14,-7,-34)
+>>> a = sum(nm[:3])
+>>> b = sum(nm[3:])
+>>> print(a - b)
+```
+
+__Вывод:__
+```py
+96
+```

TEMA2/Отчет2.md

@@ -0,0 +1,416 @@
+# Отчет по Теме 2
+
+Зеленкина Ксения, А-02-23
+
+## Простые объекты
+#### п. 2
+Изучила простые объекты и рассмотрела операции присваивания значения объектам-переменным.
+```py
+f1 = 16
+f2 = 3
+```
+<img src = "./photo1.png">
+
+ ## Правила именования объектов в Python
+ #### п. 3
+ Изучила правила наименования переменных. С учетом этих правил в командном окне IDLE выполнила следующие операции:
+```py
+>>> gg1 = 1.6
+>>> hh1 = 'Строка' 
+```
+Также попробовала создать переменную, нарушив правила именования.
+
+```py
+>>> 73sr = 3
+```
+Выдало ошибку "_SyntaxError: invalid decimal literal_"
+
+```py
+>>> and = 7 
+```
+Выдало ошибку "_SyntaxError: invalid syntax_"
+
+## Cписок ключевых слов
+#### п. 4
+Вывела список ключевых слов с помощью инструкции, посмотрела его и сохранила в переменную k.
+```py
+>>> import keyword
+>>> k = keyword.kwlist
+>>> k
+```
+Вывод списка ключевых слов:
+```py
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+## Встроенные идентификаторы
+#### п. 5
+Вывела список встроенных идентификаторов с помощью инструкций.
+```py
+>>> import builtins
+>>> dir(builtins)
+```
+Выведенный список:
+```py
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+Изучила назначение функций: _abs, len, max, min, pow, round, sorted, sum, zip_. Применив фнкцию __help()__.
+```py
+>>> help(abs), help(len)
+```
+и т.д.
+Узнала данные функции и попробовала применить некоторые из них.
+```py
+>>> abs(-2)
+    2
+>>> pow(2, 3)
+    8
+```
+## Малые и большие буквы в именах объектов
+#### п. 6
+Убедилась, что малые и большие буквы в именах объектов различаются.
+```py
+>>> Gg1 = 45
+>>> gg1, Gg1
+    (1.6, 45)
+```
+
+## Типы объектов
+#### п. 7
+Типы объектов: 
+- логический (bool), 
+- целый (int), 
+- вещественный (float), 
+- комплексный (complex), 
+- строка символов (str).
+
+#### п. 7.1. Логический тип
+```py
+>>> bb1=True; bb2=False
+>>> bb1;bb2
+    True
+    False
+>>> type(bb1) 
+    <class'bool'>
+```
+
+#### п. 7.2. Другие простые типы.
+Аналогичным способом изучила другие типы.
+```py
+>>> ii1=-1234567890
+>>> ff1=-8.9876e-12
+>>> dv1=0b1101010
+>>> vsm1=0o52765 
+>>> shest1=0x7109af6 
+>>> cc1=2-3j
+>>> a=3.67; b=-0.45
+>>> cc2=complex(a,b)  
+>>> ii1, ff1,dv1, vsm1, shest1, cc1, cc2
+    (-1234567890, -8.9876e-12, 106, 22005, 118528758, (2-3j), (3.67-0.45j))
+>>> type(ii1), type(ff1), type(dv1), type(vsm1), type(shest1), type(cc1), type(cc2)
+    (<class 'int'>, <class 'float'>, <class 'int'>, <class 'int'>, <class 'int'>, <class 'complex'>, <class 'complex'>)
+```
+
+#### п. 7.3. Строка символов.
+Изучила создание строки и создала строку по шаблону.
+```py
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+    Это - " строка символов ", 
+ 	 выводимая на двух строках
+```
+Также создала ещё одну строку по шаблону.
+```py
+>>> ss1b= 'Меня зовут: \n Зеленкина Ксения'
+>>> print(ss1b)
+    Меня зовут: 
+    Зеленкина Ксения
+```
+Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек, например:
+```py
+>>>  mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+    Нетрудно заметить , что в результате операции
+    над числами разных типов получается число,
+    имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке.
+```py
+>>> ss1='Это - строка символов'
+>>> ss1[0]   #Это – символ «Э»
+>>> ss1[8]  #А это – символ «р»
+>>> ss1[-2]  #А это – символ «о» (при знаке «-»(минус) отсчет от конца строки)
+```
+
+Операция _«разрезания»_ или _«создания среза»_, создающая новый объект:
+```py
+  ss1[6:9]  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)
+  ss1[13:]  #Это часть строки – с 13-го индекса и до конца
+  ss1[:13]  #Это часть строки – с начала и до 12-го индекса включительно
+  ss1[5:-8]  #Это часть строки – с 5-го индекса и до 8-го от конца
+  ss1[3:17:2]  #Часть строки – с 3-го по 16-й индексы с шагом 2
+```
+
+Самостоятельно посмотрела, что получилось при __отрицательном__ значении шага:
+```py
+>>> ss1[17:3:-2]
+    'омсаот '
+>>> ss1[-4:3:-2]
+    'омсаот '
+```
+
+Строка является неизменяемым объектом!
+```diff
+>>> ss1[4]='='
+-    Traceback (most recent call last):
+-      File "<pyshell#74>", line 1, in <module>
+-        ss1[4]='='
+-    TypeError: 'str' object does not support item assignment
+>>> ss1=ss1[:4]+'='+ss1[5:]
+>>> ss1
+    'Это = строка символов'
+```
+
+Мои придуманные срезы:
+```py
+>>> ss1[10:15]
+    'ка си'
+>>> ss1[-3:-15:-1]
+    'ловмис акорт'
+>>> ks = 4e938
+>>> type(ks)
+    <class 'float'>
+>>> x = 'Hello'
+>>> type(x)
+    <class 'str'>
+```
+
+#### п. 8. Более сложные типы объектов
+- списки (list), 
+- кортежи (tuple), 
+- словари (dict), 
+- множества (set).
+
+#### п. 8.1. Список
+__Список__ – это последовательность:  упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. 
+Пример списка с 3 элементами разных типов, список как последовательность сигнала («единичная ступенька») и многострочный ввод списка.
+```py
+>>> spis1=[111,'Spisok',5-9j]
+>>> spis1
+    [111, 'Spisok', (5-9j)]
+>>> stup=[0,0,1,1,1,1,1,1,1]
+>>> stup
+    [0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+>>> spis
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+При работе с элементами списка таже можно пользоваться индексами.
+```py
+>>> spis1[-1]
+    (5-9j)
+>>> stup[-8::2]
+    [0, 1, 1, 1]
+```
+Индексы в исходном списке: 1, 3, 5, 7 (или -8, -6, -4, -2).
+Посмотрим на изменняемость списка.
+```py
+>>> spis1[1]='Список'
+>>> spis1
+    [111, 'Список', (5-9j)]
+```
+Предыдущий список: [111, 'Spisok', (5-9j)]
+Измененный список: [111, 'Список', (5-9j)]
+Узнаем текущее число элементов в списке.
+```py
+ >>> 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.
+```
+С помощью методов объектов-списков добавим и удалим элементы:
+```py
+>>> 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, remove, extend, clear, sort, reverse, copy, count, index и изучила их самостоятельно и попробовала их применить.
+Списки могут быть вложенными:
+```py
+>>> spis1
+    [111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина Ксения']
+>>> spis2=[spis1,[4,5,6,7]]
+>>> spis2[0][1]
+    (5-9j)
+>>> spis2[0][1]=78
+>>> spis2
+    [[111, 78, 'New item', 'Меня зовут: \n Зеленкина Ксения'], [4, 5, 6, 7]]
+>>> spis1
+[111, 78, 'New item', 'Меня зовут: \n Зеленкина Ксения']
+```
+Spis2[0] не является копией списка spis1 - это ссылка на тот же самый объект в памяти. Когда мы изменяем элемент через spis2[0][1], мы фактически изменяем исходный список spis1.
+
+```py
+>>> my_list = [100, "Привет", True, [1, 2, 3]]
+>>> print(my_list)
+    [100, 'Привет', True, [1, 2, 3]]
+>>> print(type(my_list[0]))
+    <class 'int'>
+>>> print( type(my_list[1]))
+    <class 'str'>
+>>> print(my_list[3][0])
+    1
+>>> print(my_list[3][-1])
+    3
+>>> my_list[0] = 200    
+>>> my_list[1] = "Мир"
+>>> my_list[3][1] = 99 
+>>> print(my_list)
+    [200, 'Мир', True, [1, 99, 3]]
+```
+
+#### п. 8.2. Кортеж 
+Примеры операций с кортежами: создание кортежа:
+```py
+>>> kort1=(222,'Kortezh',77+8j)
+    (222, 'Kortezh', (77+8j))
+```
+Изменить кортеж нельзя, но можно его переопределить:
+```py
+>>> kort1= kort1+(1,2)
+>>> kort1= kort1+(ss1b,)
+    (222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Зеленкина Ксения')
+```
+Теперь переопределим кортеж с удалением комплексного элемента:
+```py
+>>> kort2=kort1[:2]+kort1[3:]
+    (222, 'Kortezh', 1, 2, 'Меня зовут: \n Зеленкина Ксения')
+```
+Два важных метода кортежа (они есть также и у списков):
+- Определение индекса заданного элемента:
+```py
+>>> kort1.index(2)
+    4
+```
+- Подсчет числа вхождений заданного элемента в кортеже:
+```py
+>>>  kort1.count(222) 
+    1
+```
+Попробуем операцию замены элемента кортежа:
+```diff
+>>> kort1[2] = 90
+- Traceback (most recent call last):
+-   File "<pyshell#142>", line 1, <module>
+-     kort1[2] = 90
+- TypeError: 'tuple' object does not support item assignment
+```
+Создание кортежа.
+```py
+>>> my_tuple = (42, "Hello, World!", [1, 2, 3, 4, 5], (9, 8, 7))
+```
+
+#### п. 8.2. Словарь
+Его содержанием является совокупность пар: «ключ (key)»:«значение (value)».
+Пример создания словаря:
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> dic1['Orel']
+    56
+```
+
+Пополнение словаря (добавление элемента, изменение словаря):
+```py
+>>>  dic1['Pskov']=78
+    'Saratov': 120, 'Vologda': 45, 'Pskov': 78, 'Orel': 56}
+```
+Функция sorted:
+```py
+>>> sorted(dic1.keys())
+    ['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>> sorted(dic1.values())
+    [45, 56, 78, 145]
+```
+
+Элементы словаря могут быть любого типа, в том числе и словарями. Например, создадим словарь:
+```py
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}
+>>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+>>> dic3['statistics'][2]
+    'standart deviation'
+```
+Создадим более сложный словарь из списка с элементами-кортежами с использованием функции dict:
+```py
+>>> dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+    {1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Зеленкина Ксения'}
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+    {'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Зеленкина Ксения'}
+```
+Создание объект-кортежа с 7 элементами и объект-список с 5 элементами.
+```py
+>>> keys_tuple = ('name', 'age', 'city', 'country', 'hobby', 'language', 'score')
+>>> values_list = ['Anna', 25, 'Moscow', 'Russia', 'programming']
+>>> my_dict = dict(zip(keys_tuple, values_list))
+>>> my_dict
+    {'name': 'Anna', 'age': 25, 'city': 'Moscow', 'country': 'Russia', 'hobby': 'programming'}
+```
+
+В получившемся словаре 5 элементов. Функция zip() создает пары "ключ-значение" до тех пор, пока не закончится самая короткая из последовательностей
+У нас кортеж имеет 7 элементов, а список - 5 элементов
+zip() создаст только 5 пар, потому что после 5-го элемента в списке значений больше нет
+Лишние ключи из кортежа отбрасываются - они остаются без соответствующих значений/
+
+#### п. 8.2. Множество
+Объект-множество – это неупорядоченная совокупность неповторяющихся элементов.
+Пример создания множества:
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>> mnoz1
+    {'линия связи', 'датчик', 'двигатель', 'микропроцессор'}
+```
+Некоторые операции с множеством:
+- определение числа элементов
+- проверка наличия элемента во множестве
+- добавление элемента
+- удаление элемента
+
+```py
+>>> len(mnoz1)
+    4
+>>> 'датчик' in mnoz1
+    True
+>>> mnoz1.add('реле')
+>>> mnoz1
+    {'двигатель', 'реле', 'датчик', 'линия связи', 'микропроцессор'}
+>>> mnoz1.remove('линия связи')
+>>> mnoz1
+    {'двигатель', 'реле', 'датчик', 'микропроцессор'}
+```
+
+Моё множество:
+```py
+>>> my_set = {1, "apple", 3.14, True, (1, 2, 3)}
+>>> my_set.add("banana")
+>>> my_set.add(42)
+>>> my_set
+    {1, 3.14, 'apple', 42, (1, 2, 3), 'banana'}
+>>> my_set.remove("apple")
+    {1, 3.14, 42, (1, 2, 3), 'banana'}
+```
+## Завершение работы

TEMA2/Решение.py

@@ -0,0 +1,13 @@
+# Решение
+nm=(12,23,34,14,-7,-34)
+a = sum(nm[:3])
+b = sum(nm[3:])
+print(a - b)
+
+import os
+from os.path import isdir
+f = open('a.txt', 'w+')
+f.write('text')
+f.close()
+
+with ope

TEMA3/GeneralControlTask.md

@@ -0,0 +1,133 @@
+# Общее контрольное задание
+Зеленкина Ксения, А-02-23
+## 1.
+Преобразовать восьмеричное значение 45 в целое число.
+_Код:_
+```py
+res = int('45', 8)
+print(res)
+```
+_Вывод:_
+```py
+37
+```
+
+## 2.
+Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+_Код:_
+```py
+dir = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+key = dir.keys()
+val = dir.values()
+lk = list(key)
+lv = list(val)
+kort = tuple(lk + lv)
+print(kort)
+print(type(kort))
+```
+
+_Вывод:_
+```py
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+```
+
+__Список:__ Изменяемый (mutable).
+	    Может использоваться в качестве ключа в словаре, так как он неизменяемый.
+	    Позиции элементов фиксированы.
+	    
+__Кортеж:__ Неизменяемый (immutable). 
+	    Не может использоваться в качестве ключа в словаре, так как он изменяемый.
+	    Позиции элементов фиксированы.
+
+## 3.
+Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+_Код:_
+```py
+print(pow(((1768 // 24.8) % 3), 2.4))
+```
+
+_Вывод:_
+```py
+5.278031643091577
+```
+
+## 4.
+Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+_Код:_
+```py
+print(((~(13 & 27)) ^ 14) << 2)
+```
+
+_Вывод:_
+```py
+-32
+```
+
+## 5.
+Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+_Код:_
+```py
+spis = ['колебат'] * 4
+cs = spis[1] + spis[2]
+if 'аткол' in cs:
+    print("Комбинация 'аткол' найдена в конкатенации.")
+else:
+    print("Комбинация 'аткол' не найдена в конкатенации.")
+```
+
+_Вывод:_
+```py
+Комбинация 'аткол' найдена в конкатенации.
+```
+
+## 6.
+Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+
+_Код:_
+```py
+D = {'a': 1, 'b': 2, 'c': 3}
+#print(dir(D))
+k = D.keys()
+print(k)
+print(type(k))
+print(list(k))
+
+v = D.values()
+print(v)
+print(type(v))
+print(list(v))
+```
+
+_Вывод:_
+```py
+['__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']
+dict_keys(['a', 'b', 'c'])
+<class 'dict_keys'>
+['a', 'b', 'c']
+dict_values([1, 2, 3])
+<class 'dict_values'>
+[1, 2, 3]
+```
+
+## 7.
+Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+_Код:_
+```py
+stroka = 'Создать объект - символьную строку с текстом данного предложения'
+l = stroka.split(' ')
+print(l)
+a = l.index('-')
+l[a] = ','
+l.remove('данного')
+print(l)
+```
+
+_Вывод:_
+```py
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+2
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA3/Pr1.py

@@ -0,0 +1,444 @@
+#Тема 3 <Зеленкина Ксения Михайловна>
+print('2.1. Функция bool')
+logiz1=bool(56)
+print(type(logiz1))
+logiz2=bool(0)
+print(type(logiz2))
+logiz3=bool("Beta")
+print(type(logiz3))
+logiz4=bool("")
+print(type(logiz4))
+print('\n')
+
+print('2.2 Функция int')
+tt1=int(198.6) #Отбрасывается дробная часть
+print(tt1)
+tt2=int("-76")  #Число – в строке символов, система по умолчанию - десятичная
+print(tt2)
+tt3=int("B",16)
+print(tt3)
+tt4=int("71",8)
+print(tt4)
+#tt5=int("98.76")  #Код с ошибкой
+#print(tt5)
+tt5i = int(float("98.76"))   #Исправленный вариант
+print(tt5i)
+print('\n')
+
+print('#Функция float')
+flt1=float(789)
+print(flt1)
+flt2=float(-6.78e2)
+print(flt2)
+flt3=float("Infinity")
+print(flt3)
+flt4=float("-inf")
+print(flt4)
+print('\n')
+
+print('2.3. Системы считсления')
+hh=123
+print(hh)
+print('Двоичная система счисления')
+dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+print(dv1)
+print('Восьмеричная система счисления')
+vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+print(vos1)
+print('Шестнадцатеричная система счисления')
+shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+print(shs1)
+print('\n')
+
+print('3.1 Функция str.')
+strk1=str(23.6)
+print(strk1)
+strk2=str(logiz3)
+print(strk2)
+strk3=str(["A","B","C"])  #Преобразуем список
+print(strk3)
+strk4=str(("A","B","C"))  #Преобразуем кортеж
+print(strk4)
+strk5=str({"A":1,"B":2,"C":9})  #Преобразуем словарь
+print(strk5)
+print('\n')
+
+print('3.2 Функция list.')
+spis1=list("Строка символов")  #Заданная строка разделяется на символы
+print(spis1)
+spis2=list((124,236,-15,908))   #Кортеж превращается в список
+print(spis2)
+spis3=list({"A":1,"B":2,"C":9})  #Преобразование словаря в список
+print(spis3)
+print('\n')
+
+print('3.3 Функция tuple.')
+kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+print(kort7)
+kort8=tuple(spis2)   #Преобразование списка в кортеж
+print(kort8)
+kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+print(kort9)
+print('\n')
+
+print('3.4 Функция del.')
+del strk5, kort8
+print('strk5' in globals()) 
+print('kort8' in globals())  
+print('\n')
+
+print('#Преобразование ФИО ')
+FIO = "Зеленкина Кс. М."
+print(FIO)
+listFIO = list(FIO)
+print(listFIO)
+kortFIO = tuple(listFIO)
+print(kortFIO)
+strFIO = str(kortFIO)
+print(strFIO)
+print('\n')
+
+print('4.1 Сложение и вычитание')
+print(12+7+90)  # Сложение целых чисел
+print(5.689e-1 - 0.456)  #Вычитание вещественных чисел
+print(23.6+54)   #Сложение вещественного и целого чисел
+print(14-56.7+89) # Сложение и вычитание целых и вещественных чисел
+print('\n')
+
+print('4.2 Умножение')
+print(-6.7*12)   #Умножение вещественного числа на целое число
+print('\n')
+
+print('4.3 Деление')
+print( -234.5/6)   #Деление вещественного числа на целое
+a=(178/45)  #Деление двух целых чисел – проверьте тип объекта a!
+print(a, type(a))
+print('\n')
+ 
+print('4.4 Округление')
+b=178//45   #Деление двух целых чисел
+c=-24.6//12.1  #Деление двух вещественных чисел
+print(b, c)
+print('\n')
+
+print('#Смешанные комбинации')
+# Целое // Вещественное
+d = 100 // 2.5
+e = -50 // 3.2
+print(type(d), type(e))
+print(d, e)
+# Вещественное // Целое  
+f = 15.8 // 4     
+g = -7.5 // 2
+print(type(f), type(g))
+print(f, g)
+# Отрицательные числа
+h = -100 // 3 
+i = 100 // -3      
+print(type(h), type(i))
+print(h, i)
+print('\n')
+
+print('4.5 Остаток от деления')
+print(148%33)   #Остаток от деления двух целых чисел
+print(12.6%3.8)  #Остаток от деления двух вещественных чисел
+print('\n')
+
+print('#Смешанные комбинации')
+c = 100 % 2.5 
+d = 17 % 3.2
+print(type(c), type(d))
+print(c, d)
+# Вещественное % Целое  
+e = 15.8 % 4     
+f = 7.5 % 2   
+print(type(e), type(f))
+print(e, f)
+# Отрицательные числа
+g = -100 % 3 
+h = 100 % -3    
+i = -12.6 % 3.8
+print(type(g), type(h), type(i))
+print(g, h, i)
+print('\n')
+
+print('4.6 Возведение в степень')
+print(14**3)  #Целое число возводится в целую степень
+e=2.7**3.6  #Вещественное число возводится в вещественную степень
+print(e)
+print('\n')
+
+print('#Операции с комплексными числами')
+print((3+4j) + (2-1j)) 
+print((5+2j) - (1+3j))
+print((2+3j) * (1-2j))
+print((4+0j) * 2.5)
+print((6+8j) / (2+0j))
+print((10+5j) / 2)
+print((1+1j)**2 )
+#print((5+3j) // (2+1j))
+#print((8+4j) % (3+1j))
+print('\n')
+
+print('5.1 Двоичная инверсия')
+dv1=9
+dv2=~dv1
+print(dv1, dv2)
+print('\n')
+
+print('5.2 Двоичное "И"')
+print(7&9)    # 111 и 1001 = 0001
+print(7&8)    # 111 и 1000 = 0000
+print('\n')
+
+print('5.3 Двоичное "ИЛИ"')
+print(7|9)     # 111 или 1001 = 1111
+print(7|8)     # 111 или 1000 = 1111
+print(14|5)   # 1110 или 0101 = 1111
+print('\n')
+
+print('5.4  Двоичное "исключающее  ИЛИ"')
+print(14^5)  # 1110 исключающее или 0101 = 1011
+print('\n')
+
+print('5.5 Сдвиг двоичного представления')
+h =14   #Двоичное представление = 1110
+print(h)
+g=h<<2  # Новое двоичное представление = 111000
+print(g)
+g1=h>>1  # Новое двоичное представление = 0111
+print(g1)
+g2=h>>2  # Новое двоичное представление = 0011
+print(g2)
+print('\n')
+
+print('#Пример с 7 - ми битными числами')
+a = 0b1101010  # 106 (десятичное
+b = 0b1011011  # 91 (десятичное)
+print(a & b)   
+print(a | b)    
+print(a ^ b)   
+print(a << 2) 
+print(b >> 1) 
+print(~a)
+print('\n')
+
+print('6.1 Объединение последовательностей (конкатенация)(+)')
+print('Система '+'регулирования')  #Соединение двух строк символов
+print(['abc','de','fg']+['hi','jkl'])  # Объединение двух списков
+print(('abc','de','fg')+('hi','jkl'))  # Объединение двух кортежей
+print('\n')
+
+print('6.2 Повторение (*)')
+print('ля-'*5)   #Повторение строки 5 раз
+print(['ку','-']*3) #Повторение списка 3 раза
+print(('кис','-')*4)  #Повторение кортежа 4 раза
+signal1=[0]*3+[1]*99
+print(signal1)
+signal2=(0,)*3+(1,)*5+(0,)*7
+print(signal2)
+print('\n')
+      
+print('6.3 in')
+stroka='Система автоматического управления'
+print(stroka)
+print('автомат' in stroka)  #Наличие подстроки в строке
+print('ку' in ['ку','-']*3)  #Наличие контекста в списке
+print('ля-' in ('abc', 'de', 'fg', 'hi', 'jkl'))  #Наличие контекста в кортеже
+print('\n')
+
+print('6.4 Подстановка значений в строку с помощью оператора «%»')
+print('Пример 1')
+stroka='Температура = %g %s  %g'
+print(stroka)
+print(stroka % (16,' меньше ',25))
+print('Пример 2')
+stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+print(stroka)
+print(stroka % {'zn1':16,'sravn':' меньше ','zn2':25})
+print('\n')
+
+print('7.1 Обычное присваивание значения переменной (=)')
+zz=-12
+print('zz = ', zz)
+print('\n')
+
+print('7.2 Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)')
+zz+=5   # Значение zz увеличивается на 5
+print('zz + 5 = ', zz)
+zz-=3  # Значение уменьшается на 3
+print('zz - 3 = ', zz)
+stroka='Система'
+print(stroka)
+stroka+=' регулирования'
+print(stroka)
+print('\n')
+
+print('7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)')
+zz/=2
+print(zz)
+zz*=5
+print(zz)
+stroka *= 2
+print('stroka * 2 = ', stroka)
+print('\n')
+
+print('7.4 Операции //=, %=, **=')
+zz = zz1 =zz2 = 17
+zz //= 5
+print(zz)
+zz1 %= 5
+print(zz1)
+zz2 **= 4
+print(zz2)
+print('\n')
+
+print('7.5 Множественное присваивание')
+w = v = 10  # Переменным присваивается одно и то же значение
+print(w, v)
+n1,n2,n3 = (11,-3,'all')  #Значения переменных берутся из кортежа
+print(n1, n2, n3)
+
+n1, n2, n3 = "11-"
+print(n1, n2, n3)
+n1, n2, n3 = [11, -3, 'all']
+print(n1, n2, n3)
+n1, n2, n3 = {11, -3, 'all'}
+print(n1, n2, n3)
+n1, n2, n3 = {11: 'a', -3: 'b', 'all': 'c'}
+print(n1, n2, n3)
+print('\n')
+
+print('8.1 Операции сравнение')
+print(w == v)
+print(w != v)
+print(w < v)
+print(w > v)
+print(w <= v)
+print( w >= v)
+print('\n')
+
+print('8.2 Операции со множеством')
+mnoz1={'pen','book','pen','iPhone','table','book'}
+print('book' in mnoz1)
+print('cap' in mnoz1)
+print('Операции со словарем')
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+print('Vologda' in dic1)
+print('Pskov' in dic1)
+print(56 in dic1.values())
+print('Ещё пример работы со словарем:')
+dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+print('UII' in dct1['Depart'])
+dct1['Depart'][1] == 'MM'
+print(dct1)
+print('\n')
+
+print('8.3 Логические "И", "ИЛИ", "НЕ"')
+a=17
+b=-6
+print((a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1))
+print('\n')
+
+print('#Сложные примеры')
+x = 10
+y = 20
+z = 30
+result = (x < y) and (y < z) or (x == 10) and not (z == 40)
+print(result)
+a = 5
+b = 12
+c = 8
+d = 20
+result = (a < b) and (b < d) or (c == 8) and not (d == 15)
+print(result)
+print('\n')
+
+print('8.4 Проверка ссылок переменных на один и тот же объект (is)')
+w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+print(w is v)
+w1=['A','B']
+v1=['A','B']
+print(w1 is v1)
+print('\n')
+
+print('9 dir')
+stroka='Микропроцессорная система управления'
+print(dir(stroka))
+print('\n')
+
+print('9.1 Методы для работы со строками')
+print(stroka.find('пр'))   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+print(stroka.count("с")) #Подсчет числа вхождений строки “с” в stroka
+print(stroka.replace(' у',' автоматического у'))
+spis22=stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+print(spis22)
+print(stroka.upper())   #Возвращает строку со всеми заглавными буквами
+stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+print(stroka3)
+print(stroka3.partition("с"))  #Возвращает кортеж с результатами поиска «с» слева
+print(stroka3.rpartition("с")) #Возвращает кортеж с результатами поиска «с» справа
+print('\n')
+
+print('#format')
+strk1 = 'Момент времени {}, значение = {}'
+result1 = strk1.format(1, 89.7)
+print(result1)
+print()
+
+strk2 = 'Момент времени {1}, значение = {0}:{2}'
+result2 = strk2.format(36.7, 2, 'норма!')
+print(result2)
+print()
+
+strk3 = 'Момент времени {num}, значение = {znch}'
+result3 = strk3.format(znch=89.7, num=2)
+print(result3)
+print()
+
+print('9.2 Методы для работы со списками. ')
+spsk = [10, 'apple', 3.14, 'banana', 42]
+print(spsk)
+print("Атрибуты списка:", dir(spsk))
+print(spsk.pop(2))
+spsk.append('c')
+print(spsk)
+spsk.insert(2,'a')
+print(spsk)
+print(spsk.count('a'))
+print()
+
+print('9.3 Изучение применение методов кортежа')
+kort = (1, 2, 3, 2, 4, 2, 5)
+print(kort)
+print(dir(kort))
+print(kort.count(2))
+print(kort.index(3)) # 2 (число 3 на позиции 2
+print(kort.index(2, 3)) # 5 (число 2 начиная с позиции 3)
+print()
+
+print('9.4 Изучение применение методов словарей и множеств')
+print('#Словарь')
+d = {'a': 1, 'b': 2, 'c': 3}
+print(d)
+print(dir(d))
+print(d.keys())
+print(d.values())
+d.update({'d': 4}) # Добавляет/обновляет элементы
+print(d)
+removed = d.pop('b')  # Удаляет ключ и возвращает значение
+print(removed)
+print()
+print('#Множество')
+s1 = {1, 2, 3, 4}
+s2 = {3, 4, 5, 6}
+print(dir(s1))
+print("Множество 1:", s1)
+print("Множество 2:", s2)
+print(s1.union(s2)) #Объединение
+print(s1.intersection(s2)) # {3, 4} - пересечение
+print(s1.difference(s2)) #разность
+s1.add(5)
+print(s1)
+s1.remove(1)
+print(s1)

TEMA3/Test.md

@@ -0,0 +1,100 @@
+# Индивидуальное контрольное задание по модулю 1
+
+Зеленкина Ксения А-02-23
+## Задание
+1)	Как установить рабочий (текущий) каталог в среде? Какую пользу можно получить от такой установки?
+2)	Напишите инструкции, обеспечивающие подсчет числа букв (без запятой, скобок и пробелов) в данном предложении. Отобразите результат с использованием формата по шаблону: " в предложении ХХ букв".
+3)	Создайте числовой объект со значением 2345. Поочередно представьте и отобразите на экране это число в двоичном, восьмеричном и шестнадцатеричном виде. Определите класс созданного объекта и отобразите список его атрибутов. Напишите инструкцию определения числа разрядов в двоичном представлении числа.
+4)	Создайте объект со значением {-45,78,90,-3,56}. Определите класс этого объекта. Атрибуты объекта запишите в объект-кортеж. Напишите инструкцию, позволяющую проверить наличие метода clear у этого кортежа.
+5)	Подсчитайте сумму элементов в объекте, созданном в п.4. Отобразите результат по шаблону: "Сумма элементов=ХХХ".
+
+## Решение
+#### 1.
+В командном окне после символов приглашения к диалогу нужно ввести инструкции настройки рабочего каталога среды по следующему образцу:
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\user\\OneDrive\\Documents\\KseniaZelenkina\\python-labs\\TEMA1\\Отчет')
+```
+__Важно!__ В строке, задающей путь к рабочему каталогу, имена папок разделены двойными слешамию.
+__Польза:__
+- Можно открывать файлы просто по имени: open('data.txt')
+- Не нужно писать полные пути к файлам
+- Импорт модулей из той же папки работает без настройки путей
+
+Чтобы проверить текущий каталог, можно написать следующую инструкцию:
+```py
+>>> import os
+>>> print(os.getcwd())
+```
+
+#### 2.
+_Код:_
+```py
+s = "Напишите инструкции, обеспечивающие подсчет числа букв (без запятой, скобок и пробелов) в данном предложении."
+s = s.replace(',', '')
+s = s.replace('(', '')
+s  = s.replace(')', '')
+s  = s.replace(' ', '')
+lc = len(s)
+e = 'В предложении %d букв'
+kol = 82
+print(e % kol)
+```
+
+_Вывод:_
+```py
+В предложении 82 букв
+```
+
+#### 3.
+
+_Код:_
+```py
+num = 2345
+print('Двочиное представление: ', bin(num))
+print('Восьмеричное: представление: ', oct(num))
+print('Шестнадцатеричное: представление: ', hex(num))
+print(type(num))
+print(dir(num))
+kol_raz = len(bin(num)) - 2 
+print('Число разрядов в двоичном представлении: ', kol_raz)
+```
+
+_Вывод:_
+```py
+Двочиное представление:  0b100100101001
+Восьмеричное: представление:  0o4451
+Шестнадцатеричное: представление:  0x929
+<class 'int'>
+['__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']
+Число разрядов в двоичном представлении:  12
+```
+_В строке "kol_raz = len(bin(num)) - 2" мы вычитаем 2, так как в двоичном представлениии перед 0 и 1 стоит '0b', которую нам учитывать не надо._
+
+#### 4.
+
+_Код:_
+```py
+d = {-45, 78, 90, -3, 56}
+print(type(d))
+attrib =  tuple(dir(d))
+print('Атрибуты: ', attrib)
+pr = 'clear' in dir(attrib)
+print(pr)
+```
+
+_Вывод:_
+```py
+<class 'set'>
+Атрибуты:  ('__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update')
+False
+```
+
+#### 5.
+_Код:_
+```py
+print('Сумма элементов= ', sum(d))
+```
+```py
+Сумма элементов=  176
+```

TEMA3/Test.py

@@ -0,0 +1,35 @@
+# Индивидуальное контрольное задание
+
+## 1
+
+## 2
+s = "Напишите инструкции, обеспечивающие подсчет числа букв (без запятой, скобок и пробелов) в данном предложении."
+s = s.replace(',', '')
+s = s.replace('(', '')
+s  = s.replace(')', '')
+s  = s.replace(' ', '')
+lc = len(s)
+e = 'В предложении %d букв'
+kol = 82
+print(e % kol)
+
+## 3
+num = 2345
+print('Двочиное представление: ', bin(num))
+print('Восьмеричное: представление: ', oct(num))
+print('Шестнадцатеричное: представление: ', hex(num))
+print(type(num))
+print(dir(num))
+kol_raz = len(bin(num)) - 2 
+print('Число разрядов в двоичном представлении: ', kol_raz)
+
+## 4
+d = {-45, 78, 90, -3, 56}
+print(type(d))
+attrib =  tuple(dir(d))
+print('Атрибуты: ', attrib)
+pr = 'clear' in dir(attrib)
+print(pr)
+
+## 5
+print('Сумма элементов= ', sum(d))

TEMA3/gct.py

@@ -0,0 +1,52 @@
+# Тема 3 "Зеленкина Ксения Михайловна"
+# Общее контрольное задание
+
+## 1.
+res = int('45', 8)
+print(res)
+
+## 2.
+dir = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+key = dir.keys()
+val = dir.values()
+lk = list(key)
+lv = list(val)
+kort = tuple(lk + lv)
+print(kort)
+print(type(kort))
+
+## 3.
+print(pow(((1768 // 24.8) % 3), 2.4))
+
+## 4.
+print(((~(13 & 27)) ^ 14) << 2)
+
+## 5.
+spis = ['колебат'] * 4
+cs = spis[1] + spis[2]
+if 'аткол' in cs:
+    print("Комбинация 'аткол' найдена в конкатенации.")
+else:
+    print("Комбинация 'аткол' не найдена в конкатенации.")
+
+## 6.
+D = {'a': 1, 'b': 2, 'c': 3}
+#print(dir(D))
+k = D.keys()
+print(k)
+print(type(k))
+print(list(k))
+
+v = D.values()
+print(v)
+print(type(v))
+print(list(v))
+
+## 7.
+stroka = 'Создать объект - символьную строку с текстом данного предложения'
+l = stroka.split(' ')
+print(l)
+a = l.index('-')
+l[a] = ','
+l.remove('данного')
+print(l)

TEMA3/Отчет3.md

@@ -0,0 +1,717 @@
+# Отчет по Теме 3
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+
+## 2. Преобразование простых базовых типов объектов.
+#### п. 2.1
+Преобразование в логический тип с помощью функции __bool(<Объект>)__.
+```py
+>>> logiz1=bool(56)
+>>> print(type(logiz1))
+    <class 'bool'>
+>>> logiz2=bool(0)
+>>> print(type(logiz2))
+    <class 'bool'>
+>>> logiz3=bool("Beta")
+>>> print(type(logiz3))
+    <class 'bool'>
+>>> logiz4=bool("")
+>>> print(type(logiz4))
+    <class 'bool'>  
+```
+
+#### п. 2.2
+Преобразуем в целое десятичное число объект с заданной системой счисления с помощью функции __int(<Объект>[,<Система счисления, в которой определен объект>])__.
+```diff
+>>> tt1=int(198.6) #Отбрасывается дробная часть
+>>> print(tt1)
+    198
+>>> tt2=int("-76")  #Число – в строке символов, система по умолчанию - десятичная
+>>> print(tt2)
+    -76
+>>> tt3=int("B",16)
+>>> print(tt3)
+    11
+>>> tt4=int("71",8)
+>>> print(tt4)
+    57
+>>> tt5=int("98.76")
+>>> print(tt5)
+-   Traceback (most recent call last):
+-     File "C:/Users/user/OneDrive/Documents/ZelenkinaKs/python-labs/TEMA3/Pr1.py", line 19, - in <module>
+-           tt5=int("98.76")
+-   ValueError: invalid literal for int() with base 10: '98.76'
+```
+В последнее функции ошибка возникает потому, что функция int() не может преобразовывать строки с десятичной точкой (дробные числа) напрямую.
+Исправленный вариант:
+```py
+>>> tt5 = int(float("98.76"))
+    98
+```
+Функция int() со строковым аргументом требует, чтобы строка содержала только:
+- Цифры (0-9)
+- Знак минус (для отрицательных чисел)
+- Буквы A-F (только для систем счисления выше 10)
+- Без десятичных точек, запятых или других нечисловых символов
+
+Преобразуем целые чисела или строки символов в вещественное число – с помощью функции __float(<Объект>)__.
+```py
+>>> flt1=float(789)
+>> print(flt1)
+    789.0
+>>> flt2=float(-6.78e2)
+>>> print(flt2)
+    -678.0
+>>> flt3=float("Infinity")
+>>> print(flt3)
+    inf
+>>> flt4=float("-inf")
+>>> print(flt4)
+    -inf
+```
+
+#### п. 2.3 
+Преобразование десятичных чисел в другие системы счисления:
+```py
+>> hh=123
+>> print(hh)
+    123
+>>> dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+>>> print(dv1)
+    0b1111011
+>>> vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+>>> print(vos1)
+    0o173
+>>> shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+>>> print(shs1)
+    0x7b
+```
+## 3. Преобразования более сложных базовых типов объектов.
+#### п. 3.1
+Преобразование в строку символов с помощью функции __str(<Объект>)__.
+```py
+>>> strk1=str(23.6)
+>>> print(strk1)
+    23.6
+>>> strk2=str(logiz3)
+>>> print(strk2)
+    True
+>>> strk3=str(["A","B","C"])  #Преобразуем список
+>>> print(strk3)
+    ['A', 'B', 'C']
+>>> strk4=str(("A","B","C"))  #Преобразуем кортеж
+>>> print(strk4)
+    ('A', 'B', 'C')
+>>> strk5=str({"A":1,"B":2,"C":9})  #Преобразуем словарь
+>>> print(strk5)
+    {'A': 1, 'B': 2, 'C': 9}
+```
+
+#### п. 3.2
+Преобразование элементов объекта в список с помощью функции __list(<Объект>)__.
+```py
+>>> spis1=list("Строка символов")  #Заданная строка разделяется на символы
+>>> print(spis1)
+    ['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+>>> spis2=list((124,236,-15,908))   #Кортеж превращается в список
+>>> print(spis2)
+    [124, 236, -15, 908]
+>>> spis3=list({"A":1,"B":2,"C":9})  #Преобразование словаря в список
+>>> print(spis3)
+    ['A', 'B', 'C']
+```
+
+#### п. 3.3
+Преобразование элементов объектов в кортеж с помощью функции __tuple(<Объект>)__.
+```py
+>>> kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+>>> print(kort7)
+    ('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8=tuple(spis2)   #Преобразование списка в кортеж
+>>> print(kort8)
+    (124, 236, -15, 908)
+>>> kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+>>> print(kort9)
+    ('A', 'B', 'C')
+```
+
+#### п. 3.4
+Очистить оперативную память от ранее созданных объектов можно с помощью инструкции __del__.
+ ```py
+ >>> del strk5, kort8
+>>> print('strk5' in globals()) 
+    False
+>>> print('kort8' in globals())
+    False
+ ```
+ Данные переменные были удалены.
+ __Преобрращование ФИО:__
+ ```py
+>> FIO = "Зеленкина Кс. М."
+>>> print(FIO)
+    Зеленкина Кс. М.
+>>> listFIO = list(FIO)
+>>> print(listFIO)
+    ['З', 'е', 'л', 'е', 'н', 'к', 'и', 'н', 'а', ' ', 'К', 'с', '.', ' ', 'М', '.']
+>>> kortFIO = tuple(listFIO)
+>>> print(kortFIO)
+    ('З', 'е', 'л', 'е', 'н', 'к', 'и', 'н', 'а', ' ', 'К', 'с', '.', ' ', 'М', '.')
+>>> strFIO = str(kortFIO)
+>>> print(strFIO)
+    ('З', 'е', 'л', 'е', 'н', 'к', 'и', 'н', 'а', ' ', 'К', 'с', '.', ' ', 'М', '.')
+ ```
+ ## 4. Арифметические операции.
+ #### п. 4.1
+ Сложение и вычитание (+ и -):
+ ```py
+>>> print(12+7+90)  # Сложение целых чисел
+    109
+>>> print(5.689e-1 - 0.456)  #Вычитание вещественных чисел
+    0.11289999999999994
+>>> print(23.6+54)   #Сложение вещественного и целого чисел
+    77.6
+>>> print(14-56.7+89) # Сложение и вычитание целых и вещественных чисел
+    46.3
+ ```
+ 
+#### п. 4.2
+ Умножение (*):
+ ```py
+ >>> print(-6.7*12)   #Умножение вещественного числа на целое число
+    -80.4
+ ```
+#### п. 4.3
+Деление (/):
+```py
+>>> print( -234.5/6)   #Деление вещественного числа на целое
+    -39.083333333333336
+>>> a = (178/45)  #Деление двух целых чисел – проверьте тип объекта a!
+>>> print(a, type(a))
+    3.9555555555555557 <class 'float'>
+```
+
+#### п. 4.4
+Деление с округлением вниз (//):
+```py
+>>> b=178//45   #Деление двух целых чисел
+>>> c=-24.6//12.1  #Деление двух вещественных чисел
+>>> print(b, c)
+    3 -3.0
+```
+__Смешанные комбинации__
+```py
+# Целое // Вещественное
+d = 100 // 2.5
+e = -50 // 3.2
+print(type(d), type(e))
+print(d, e)
+# Вещественное // Целое  
+f = 15.8 // 4     
+g = -7.5 // 2
+print(type(f), type(g))
+print(f, g)
+# Отрицательные числа
+h = -100 // 3 
+i = 100 // -3      
+print(type(h), type(i))
+print(h, i)
+print('\n')
+```
+
+#### п. 4.5
+Получение остатка от деления (%):
+```py
+>>> print(148 % 33)   #Остаток от деления двух целых чисел
+    16
+>>> print(12.6 % 3.8)  #Остаток от деления двух вещественных чисел
+    1.2000000000000002
+```
+Попробовала смешанные комбинации с данной операцией.
+
+#### п. 4.6
+Возведение в степень (**):
+```py
+>>> print(14**3)  #Целое число возводится в целую степень
+    2744
+>>> e = 2.7**3.6  #Вещественное число возводится в вещественную степень
+>>> print(e)
+    35.719843790663525
+```
+Попробовала смешанные комбинации с данной операцией.
+```py
+>>> print((3+4j) + (2-1j)) 
+>>> print((5+2j) - (1+3j))
+>>> print((2+3j) * (1-2j))
+>>> print((4+0j) * 2.5)
+>>> print((6+8j) / (2+0j))
+>>> print((10+5j) / 2)
+>>> print((1+1j)**2 )
+    (5+3j)
+    (4-1j)
+    (8-1j)
+    (10+0j)
+    (3+4j)
+    (5+2.5j)
+    2j
+```
+```diff
+>>> print((5+3j) // (2+1j))
+-    unsupported operand type(s) for //: 'complex' and 'complex'
+>>> print((8+4j) % (3+1j))
+-   TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+```
+Для комплексных чисел __допустимы__ следующие операции: +, -, *, /, **
+__Не допустимы:__ //, % 
+
+## 5. Операции с двоичными представлениями целых чисел.
+#### 5.1.
+Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+```py
+>>> dv1=9
+>>> dv2=~dv1
+>>> print(dv1, dv2)
+    9 -10
+```
+
+#### 5.2.
+Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+```py
+>>> print(7&9)    # 111 и 1001 = 0001
+    1
+>>> print(7&8)    # 111 и 1000 = 0000
+    0
+```
+
+#### 5.3.
+Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0.
+```py
+>>> print(7|9)     # 111 или 1001 = 1111
+    15
+>>> print(7|8)     # 111 или 1000 = 1111
+    15
+>>> print(14|5)   # 1110 или 0101 = 1111
+    15
+```
+
+#### 5.4.
+Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+```py
+>>> print(14^5)  # 1110 исключающее или 0101 = 1011
+    11
+```
+
+#### 5.5.
+Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
+```py
+>>> h =14   #Двоичное представление = 1110
+>>> print(h)
+    14
+>>> g=h<<2  # Новое двоичное представление = 111000
+>>> print(g)
+    56
+>>> g1=h>>1  # Новое двоичное представление = 0111
+>>> print(g1)
+    7
+>>> g2=h>>2  # Новое двоичное представление = 0011
+>>> print(g2)
+    3
+```
+Пример с 7-ми битными числами:
+```py
+>>> a = 0b1101010  # 106 (десятичное
+>>> b = 0b1011011  # 91 (десятичное)
+>>> print(a & b)   
+    74
+>>> print(a | b)   
+    123
+>>> print(a ^ b)
+    49
+>>> print(a << 2) 
+    424
+>>> print(b >> 1) 
+    45
+>>> print(~a)
+    -107
+```
+## 6. Операции при работе с последовательностями (строками, списками, кортежами).
+#### п. 6.1
+Объединение последовательностей (конкатенация)(+)
+```py
+>>> print('Система '+'регулирования')  #Соединение двух строк символов
+    Система регулирования
+>>> print(['abc','de','fg']+['hi','jkl'])  # Объединение двух списков
+    ['abc', 'de', 'fg', 'hi', 'jkl']
+>>> print(('abc','de','fg')+('hi','jkl'))  # Объединение двух кортежей
+    ('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+#### п. 6.2
+Повторение (*)
+```py
+>>> print('ля-'*5)   #Повторение строки 5 раз
+    ля-ля-ля-ля-ля-
+>>> print(['ку','-']*3) #Повторение списка 3 раза
+    ['ку', '-', 'ку', '-', 'ку', '-']
+>>> print(('кис','-')*4)  #Повторение кортежа 4 раза
+    ('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1=[0]*3+[1]*99
+>>> print(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
+>>> print(signal2)
+    (0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+#### п. 6.3
+Проверка наличия заданного элемента в последовательности (in):
+```py
+>>> stroka='Система автоматического управления'
+    Система автоматического управления
+>>> print(stroka)
+>>> print('автомат' in stroka)  #Наличие подстроки в строке
+    True
+>>> print('ку' in ['ку','-']*3)  #Наличие контекста в списке
+    True
+>>> print('ля-' in ('abc', 'de', 'fg', 'hi', 'jkl'))  #Наличие контекста в кортеже
+    False
+```
+
+#### п. 6.4
+Подстановка значений в строку с помощью оператора «%»
+_Пример 1_
+```py
+>>> stroka='Температура = %g %s  %g'
+>>> print(stroka)
+    Температура = %g %s  %g
+>>> print(stroka % (16,' меньше ',25))
+    Температура = 16  меньше   25
+```
+_Пример 2_
+```py
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> print(stroka)
+    Температура = %(zn1)g %(sravn)s  %(zn2)g
+>>> print(stroka % {'zn1':16,'sravn':' меньше ','zn2':25})
+    Температура = 16  меньше   25
+```
+## 7. Оператор присваивания
+#### п. 7.1
+Обычное присваивание значения переменной (=):
+```py
+>>> zz=-12
+>>> print('zz = ' zz)
+    zz =  -12
+```
+
+#### п. 7.2
+Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```py
+>>> zz+=5   # Значение zz увеличивается на 5
+>>> print('zz + 5 = ', zz)
+    zz + 5 =  -7
+>>> zz-=3  # Значение уменьшается на 3
+>>> print('zz - 3 = ', zz)
+    zz - 3 =  -10
+>>> stroka='Система'
+>>> print(stroka)
+    Система
+>>> stroka+=' регулирования'
+>>> print(stroka)
+    Система регулирования
+```
+
+#### п. 7.3
+Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```py
+>>> zz/=2
+>>> print(zz)
+    -5.0
+>>> zz*=5
+>>> print(zz)
+    -25.0
+>>> stroka *= 2
+>>> print('stroka * 2 = ', stroka)
+    stroka * 2 =  Система регулированияСистема регулирования
+```
+
+#### п. 7.4
+Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) изучите самостоятельно.
+```py
+>>> zz = zz1 =zz2 = 17
+>>> zz //= 5
+>>> print(zz)
+    3
+>>> zz1 %= 5
+>>> print(zz1)
+    2
+>>> zz2 **= 4
+>>> print(zz2)
+    83521
+```
+Данные операции не применимы к строкам!!!
+
+#### п. 7.5
+Множественное присваивание:
+```py
+>>> w = v = 10  # Переменным присваивается одно и то же значение
+>>> print(w, v)
+    10 10
+>>> n1,n2,n3 = (11,-3,'all')  #Значения переменных берутся из кортежа
+>>> print(n1, n2, n3)
+    11 -3 all
+```
+Вместо кортежа справа используем строку, список, словарь, множество.
+__Строка:__
+```py
+>>> n1, n2, n3 = "11-"
+>>> print(n1, n2, n3)
+    1 1 -
+```
+__Cписок:__
+```py
+>>> n1, n2, n3 = [11, -3, 'all']
+>>> print(n1, n2, n3)
+    11 -3 all
+```
+
+__Множество:__
+```py
+>>> n1, n2, n3 = {11, -3, 'all'}
+>>> print(n1, n2, n3)
+    11 all -3
+```
+
+__Словарь:__
+```py
+>>> n1, n2, n3 = {11: 'a', -3: 'b', 'all': 'c'}
+>>> print(n1, n2, n3)
+    11 -3 all
+```
+У __словаря__ распаковываются только ключи!
+
+## 8. Логические операции.
+#### п. 8.1 
+__Операции сравнение:__ равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) – придумайте примеры этих операций. 
+```py
+>>> print(w == v)
+>>> print(w != v)
+>>> print(w < v)
+>>> print(w > v)
+>>> print(w <= v)
+>>> print( w >= v)
+    True
+    False
+    False
+    False
+    True
+    True
+```
+
+#### п. 8.2
+Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in).
+__Операции с множеством:__
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> print('book' in mnoz1)
+    True
+>>> print('cap' in mnoz1)
+    False
+```
+__Операции со словарём:__
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> print('Vologda' in dic1)
+    True
+>>> print('Pskov' in dic1)
+    False
+>>> print(56 in dic1.values())
+    True
+__Ещё примеры работ со словарём:__
+```py
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>> print('UII' in dct1['Depart'])
+    True
+>>> dct1['Depart'][1] == 'MM'
+>>> print(dct1)
+    {'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+```
+
+#### п. 8.3
+Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not). 
+```py
+>>> a=17
+>>> b=-6
+>>> print((a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1))
+    True
+```
+
+__Придуманные сложные примеры:__
+_Пример 1:_
+```py
+>>> x = 10
+>>> y = 20
+>>> z = 30
+>>> result = (x < y) and (y < z) or (x == 10) and not (z == 40)
+>>> print(result)
+    True
+```
+_Пример 2:_
+```py
+>>> a = 5
+>>> b = 12
+>>> c = 8
+>>> d = 20
+>>> result = (a < b) and (b < d) or (c == 8) and not (d == 15)
+>>> print(result)
+    True
+```
+
+#### п. 8.4
+Проверка ссылок переменных на один и тот же объект (is).
+```py
+>>> w=v=10 
+>>> print(w is v)
+    True
+>>> w1=['A','B']
+>>> v1=['A','B']
+>>> print(w1 is v1)
+    False
+```
+__is__ проверяет идентичность объектов, а не равенство значений!
+
+## 9. Операции с объектами, выполняемые с помощью методов.
+Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например:
+```py
+>>> stroka='Микропроцессорная система управления'
+>>> dir(stroka)
+    ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+#### п. 9.1
+Методы для работы со строками. Рассмотрим несколько примеров таких методов:
+```py
+>>> print(stroka.find('пр')) 
+    5
+>>> print(stroka.count("с")) 
+    4
+>>> print(stroka.replace(' у',' автоматического у'))
+    Микропроцессорная система автоматического управления
+>>> spis22=stroka.split(' ')
+>>> print(spis22)
+    ['Микропроцессорная', 'система', 'управления']
+>>> print(stroka.upper()) 
+    МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ
+>>> stroka3=" ".join(spis22) 
+>>> print(stroka3)
+    Микропроцессорная система управления
+>>> print(stroka3.partition("с"))
+    ('Микропроце', 'с', 'сорная система управления')
+>>> print(stroka3.rpartition("с"))
+    ('Микропроцессорная си', 'с', 'тема управления')
+```
+Изучила метод __format__:
+```py
+>>> strk1 = 'Момент времени {}, значение = {}'
+>>> result1 = strk1.format(1, 89.7)
+>>> print(result1)
+    Момент времени 1, значение = 89.7
+>>> strk2 = 'Момент времени {1}, значение = {0}:{2}'
+>>> result2 = strk2.format(36.7, 2, 'норма!')
+>>> print(result2)
+    Момент времени 2, значение = 36.7:норма!
+>>> strk3 = 'Момент времени {num}, значение = {znch}'
+>>> result3 = strk3.format(znch=89.7, num=2)
+>>> print(result3)
+    Момент времени 2, значение = 89.7
+```
+
+#### п. 9.2
+Методы для работы со списками: 
+Создадим произвольный список spsk, не менее чем с 5 элементами и отобразите его атрибуты.
+Последовательно обратимся к методам этого списка с отображением каждый раз полученного списка:
+
+```py
+>>> spsk = [10, 'apple', 3.14, 'banana', 42]
+>>> print(spsk)
+    [10, 'apple', 3.14, 'banana', 42]
+>>> print("Атрибуты списка:", dir(spsk))
+    Атрибуты списка: ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+>>> print(spsk.pop(2))
+    3.14
+>>> spsk.append('c')
+>>> print(spsk)
+    [10, 'apple', 'banana', 42, 'c']
+>>> spsk.insert(2,'a')
+>>> print(spsk)
+    [10, 'apple', 'a', 'banana', 42, 'c']
+>>> print(spsk.count('a'))
+    1
+```
+Смысл выполненных операций:
+- __pop()__ - убирает элемент
+- __append()__ - добавляет в конец
+- __insert()__ - Вставляет элемент на указанную позицию
+- __count()__ - считает элементы
+
+#### п. 9.3
+Изучение применения основных методов кортежа:
+```py
+>>> kort = (1, 2, 3, 2, 4, 2, 5)
+>>> print(kort)
+    (1, 2, 3, 2, 4, 2, 5)
+>>> print(dir(kort))
+    ['__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']
+>>> print(kort.count(2))
+    3
+>>> print(kort.index(3)) # 2 (число 3 на позиции 2)
+    2
+>>> print(kort.index(2, 3)) # 5 (число 2 начиная с позиции 3)
+    3
+```
+
+#### п. 9.4
+Изучение применения основных методов словарей и множеств:
+__Словарь:__
+```py
+>>> d = {'a': 1, 'b': 2, 'c': 3}
+>>> print(d)
+    {'a': 1, 'b': 2, 'c': 3}
+>>> print(dir(d))
+    ['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>> print(d.keys())
+    dict_keys(['a', 'b', 'c'])
+>>> print(d.values())
+    dict_values([1, 2, 3])
+>>> d.update({'d': 4}) # Добавляет/обновляет элементы
+>>> print(d)
+    {'a': 1, 'b': 2, 'c': 3, 'd': 4}
+>>> removed = d.pop('b')  # Удаляет ключ и возвращает значение
+>>> print(removed)
+    2
+```
+
+__Множество:__
+```py
+>>> s1 = {1, 2, 3, 4}
+>>> s2 = {3, 4, 5, 6}
+>>> print(dir(s1))
+    ['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+>>> print("Множество 1:", s1)
+    Множество 1: {1, 2, 3, 4}
+>>> print("Множество 2:", s2)
+    Множество 2: {3, 4, 5, 6}
+>>> print(s1.union(s2)) #Объединение
+    {1, 2, 3, 4, 5, 6}
+>>> print(s1.intersection(s2)) # {3, 4} - пересечение
+    {3, 4}
+>>> print(s1.difference(s2)) #разность
+    {1, 2}
+>>> s1.add(5)
+>>> print(s1)
+    {1, 2, 3, 4, 5}
+>>> s1.remove(1)
+>>> print(s1)
+    {2, 3, 4, 5}
+```
+## Завершение работы

TEMA4/Task.md

@@ -0,0 +1,22 @@
+# Индивидуальные контрольные задания по теме 4
+Зеленкина Ксения А-02-23
+
+## Задача
+'''Создайте список с элементами, значения которых находятся в диапазоне от 4 до 53 с шагом 7. Определите число элементов в получившемся списке. Случайно выберите один из элементов списка.
+Рассчитайте его логарифм и отобразите в виде строки: «Результат = <значение>».'''
+
+## Решение
+_Код:_
+```py
+import random
+import math
+l = list(range(4, 53, 7))
+print(len(l))
+print(math.log(random.choice(l)))
+```
+
+_Вывод:_
+```py
+7
+3.4657359027997265
+```

TEMA4/Task.py

@@ -0,0 +1,6 @@
+# Индивидуальные контрольные задания по теме 4
+import random
+import math
+l = list(range(4, 53, 7))
+print(len(l))
+print(math.log(random.choice(l)))

TEMA4/gct.md

@@ -0,0 +1,104 @@
+#Общее контрольное задание по ТЕМЕ 4 "Зеленкина Ксения Михайловна"
+
+## 1.
+Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+
+_Код:_
+```py
+import cmath
+n = ((round(cmath.phase(0.2+0.8j),2)) * 20)
+a, b = divmod(n, 3)
+print(a,b)
+```
+
+_Вывод:_
+```py
+(8.0, 2.6000000000000014)
+```
+
+## 2.
+Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+_Код:_
+```py
+import time
+Mtime = time.gmtime(time.time() + 3 * 3600)
+print(f'{Mtime.tm_hour}:{Mtime.tm_min}')
+start_time = time.time()
+```
+
+_Вывод:_
+```py
+12:5
+```
+
+## 3.
+Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+
+_Код:_
+```py
+import random
+spis = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+l = random.sample(spis, 3)
+print(l)
+``` 
+
+_Вывод:_
+```py
+['Понедельник', 'Суббота', 'Вторник']
+```
+
+## 4.
+Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+_Код:_
+```py
+import random
+num = list(range(14, 32, 3))
+res = random.choice(num)
+print(res)
+``` 
+
+_Вывод:_
+```py
+20
+```
+
+## 5.
+Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+_Код:_
+```py
+import random
+import string
+N = round(random.gauss(15, 4))
+l = string.ascii_uppercase
+c = random.sample(l, N)
+print(c)
+print(N)
+print(f'Длина массива: {len(c)}')
+``` 
+
+_Вывод:_
+```py
+['M', 'Z', 'V', 'Q', 'G', 'O', 'N', 'J', 'X', 'R', 'C', 'S', 'H', 'B', 'T', 'F', 'U', 'E', 'K', 'W']
+20
+Длина массива: 20
+```
+
+## 6.
+Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+_Код:_
+```py
+import random
+import time
+NewMtime = time.time() + 3*3600  # Обновляем текущее московское время
+inter_minutes = (NewMtime - start_time) / 60
+print(inter_minutes)
+``` 
+
+_Вывод:_
+```py
+180.00013352632521
+```

TEMA4/genct4.py

@@ -0,0 +1,42 @@
+# Тема 3 "Зеленкина Ксения Михайловна"
+# Общее контрольное задание
+
+## 1.
+import cmath
+n = ((round(cmath.phase(0.2+0.8j),2)) * 20)
+a, b = divmod(n, 3)
+print(a,b)
+
+## 2.
+import time
+Mtime = time.gmtime(time.time() + 3 * 3600)
+print(f'{Mtime.tm_hour}:{Mtime.tm_min}')
+start_time = time.time()
+
+## 3.
+import random
+spis = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+l = random.sample(spis, 3)
+print(l)
+
+## 4.
+import random
+num = list(range(14, 32, 3))
+res = random.choice(num)
+print(res)
+
+## 5.
+import random
+import string
+N = round(random.gauss(15, 4))
+l = string.ascii_uppercase
+c = random.sample(l, N)
+print(c)
+print(N)
+print(f'Длина массива: {len(c)}')
+
+## 6.
+import time
+NewMtime = time.time() + 3*3600  # Обновляем текущее московское время
+inter_minutes = (NewMtime - start_time) / 60
+print(inter_minutes)

TEMA4/protocol.py

@@ -0,0 +1,210 @@
+# ТЕМА 4 "Зеленкина Ксения Михайловна"
+# 2.1
+print(round(123.456,1))
+print(round(123.456,0))
+
+print(round(123.456))
+
+# 2.2.
+gg=range(76,123,9)
+print(gg)
+
+print(list(gg))
+
+print(list(range(23)))
+
+# 2.3.
+qq = ['Зеленкина', 'Криви', 'Цветкова', 'Капитонов']
+print(qq)  
+ff = zip(gg, qq)
+print(ff) 
+
+result_tuple = tuple(ff)
+print(result_tuple)
+print(result_tuple[0]) 
+print(result_tuple[2])
+
+# 2.4.
+#fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+#print(fff, dan)
+
+# 2.5
+#exec(input('введите инструкции:'))
+
+# 2.6   
+print(abs(-7.5)) 
+print(pow(3, 4))
+
+numbers = [5, 2, 8, 1]
+print(max(numbers))  
+print(min(numbers)) 
+
+print(sum(numbers))
+
+a, b = divmod(17, 5)
+print(a, b)
+
+text = "Hello"
+print(len(text))  
+
+numbers = [1, 2, 3, 4]
+text_numbers = list(map(str, numbers))
+print(text_numbers)
+
+#3
+import math
+print(dir(math))
+help(math.factorial)
+print(math.factorial(5))
+
+import math
+
+print(dir(math))
+help(math.factorial)
+
+print(math.factorial(5))
+print(math.sin(math.pi/2))
+print(math.acos(0.5))
+print(math.degrees(math.pi))
+print(math.radians(180))
+print(math.exp(1))
+print(math.log(100))
+print(math.log10(100))
+print(math.sqrt(25))
+print(math.ceil(4.2))
+print(math.floor(4.9))
+print(math.pi)
+
+result = math.sin(2 * math.pi / 7 + math.exp(0.23))
+print(result)
+
+#4
+import cmath
+print(dir(cmath))
+print(cmath.sqrt(1.2-0.5j))
+print(cmath.phase(1-0.5j))
+
+#5
+import random
+print(dir(random))
+help(random.seed)
+print(random.seed())
+
+import random
+
+random.seed(42)
+
+print(random.random())
+print(random.uniform(10, 20))
+print(random.randint(1, 6))
+print(random.gauss(0, 1))
+
+fruits = ["яблоко", "банан", "апельсин", "киви"]
+print(random.choice(fruits))
+
+cards = ["Туз", "Король", "Дама", "Валет"]
+random.shuffle(cards)
+print(cards)
+
+numbers = list(range(1, 51))
+print(random.sample(numbers, 5))
+
+print(random.betavariate(2, 5))
+print(random.gammavariate(2, 1))
+print(random.randint(100, 999))
+print(random.uniform(-5, 5))
+
+random_values = [random.uniform(0, 1), random.gauss(0, 1), random.betavariate(2, 5), random.gammavariate(2, 1)]
+print(random_values)
+
+#6
+import time
+print(dir(time))
+c1=time.time()
+print(c1)
+c2=time.time()-c1
+print(c2)
+dat=time.gmtime()
+print(dat)
+print(dat.tm_mon)
+
+# local()
+local_time = time.localtime()
+print(local_time.tm_year)
+print(local_time.tm_mon)
+print(local_time.tm_mday)
+print(local_time.tm_hour)
+print(local_time.tm_min)
+print(local_time.tm_sec)
+
+# asctim()
+time_str = time.asctime(local_time)
+print(time_str)
+
+#ctime()
+current_seconds = time.time()
+print(current_seconds)
+time_from_seconds = time.ctime(current_seconds)
+print(time_from_seconds)
+
+#sleep()
+print("Начинаем отсчет...")
+for i in range(3, 0, -1):
+    print(f"{i}...")
+    time.sleep(1)
+print("Запуск!")
+
+#mtime
+seconds_from_struct = time.mktime(local_time)
+print(seconds_from_struct)
+
+#Обратное преобразование из секунды
+print(time.localtime(c1))
+
+# Графические функции.
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t, x)  # Создание графика в оперативной памяти
+pylab.title('Первый график')
+pylab.xlabel('время')
+pylab.ylabel('сигнал')
+pylab.show()  # Отображение графика на экране
+
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+pylab.plot(X2)
+pylab.show()
+
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+pylab.show()
+
+#hist
+import matplotlib.pyplot as plt
+assessments = [3, 4, 5, 3, 4, 5, 5, 4, 3, 2, 4, 5, 3, 4, 5, 4, 3, 5, 4, 3]
+plt.hist(assessments, bins=5, color='lightblue', edgecolor='black')
+plt.xlabel('Оценки')
+plt.ylabel('Количество студентов')
+plt.title('Распределение оценок студентов')
+plt.show()
+
+#bar
+fruits = ['Яблоки', 'Бананы', 'Апельсины', 'Груши']
+count = [25, 30, 15, 20]
+color = ['red', 'yellow', 'orange', 'green']
+plt.bar(fruits, count, color=color)
+plt.ylabel('Количество')
+plt.title('Любимые фрукты')
+plt.show()
+
+#Statistic
+import statistics
+print(dir(statistics))
+data = [1, 2, 3, 4, 5, 5, 6]
+print("Mean:", statistics.mean(data))
+print("Median:", statistics.median(data))
+print("Mode:", statistics.mode(data))
+print("Stdev:", statistics.stdev(data))

TEMA4/Отчет4.md

@@ -0,0 +1,424 @@
+# Отчет по Теме 4
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+
+## 2. Стандартные функции.
+Они находятся в модуле __builtins__, который становится доступным без импорта при запуске среды IDLE.
+#### п. 2.1.
+Функция __round__ – округление числа с заданной точностью. Попробую данную функцию на следующих примерах.
+```py
+>>> print(round(123.456,1))
+    123.5
+>>> print(round(123.456,0))
+    123.0
+```
+Данные результаты имеют тип float. Первое выражение округляет до одного знака после запятой, второе — до целого числа.
+Попробуем выполнить следующую инструкцию:
+```py
+>>> print(round(123.456))
+    123
+```
+Полученный результат имеет тип int.
+
+#### п. 2.2.
+Функция __range__ – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+```py
+>>> gg=range(76,123,9)
+>>> print(gg)
+    range(76, 123, 9)
+```
+Обратим внимание, что эта инструкция создает, так называемый, _«итерируемый объект»_ класса __range__. Чтобы увидеть получившуюся преобразуем его в список.
+```py
+>>> print(list(gg))
+    [76, 85, 94, 103, 112, 121]
+```
+Также возможно вызвать функцию __range__ с одним аргументом.
+```py
+>>> print(list(range(23)))
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+Мы получили объект, который содержит последовательность целых чисел от 0 до 22(включительно) с шагом 1.
+
+#### п. 2.3.
+Функция __zip__ – создание общего объекта, элементами которого являются кортежи, составленные из  элементов двух или более объектов-последовательностей. 
+```py
+>>> qq = ['Зеленкина', 'Криви', 'Цветкова', 'Капитонов']
+>>> print(qq)  
+    ['Зеленкина', 'Криви', 'Цветкова', 'Капитонов']
+>>> ff = zip(gg, qq)
+>>> print(ff) 
+    <zip object at 0x00000170234FAF40>
+>>> result_tuple = tuple(ff)
+>>> print(result_tuple)
+    ((76, 'Зеленкина'), (85, 'Криви'), (94, 'Цветкова'), (103, 'Капитонов'))
+```
+Количество элементов в ff равно минимальной длине из исходных списков gg и qq, то есть длине списка qq.
+Проверим, можно ли к объекту ff обращаться с указанием индекса.
+
+```py
+>>> print(result_tuple[0]) 
+    (76, 'Зеленкина')
+>>> print(result_tuple[2]) 
+    (94, 'Цветкова')
+```
+К объекту ff  можно обращаться с указанием индекса.
+
+#### п. 2.4.
+Функция __eval__ – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки.
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+>>> print(fff, dan)
+    коэффициент усиления=3
+    3.0 -141.0
+```
+
+#### п. 2.5.
+Похожая на __eval__ функция __exec__ – чтение и выполнение объекта-аргумента функции. Напишем и выполним код по инструкции:
+```py
+>>> exec(input('введите инструкции:'))
+    введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+```
+Убедимся, что появился числовой объект с именем gg и со значением 221.456.
+```py
+>>> gg
+    221.456
+>>> perem
+    -123.456
+```
+
+#### п. 2.6.
+Самостоятельно изучим и попробуем применить функции abs, pow, max, min, sum, divmod, len, map. 
+```py
+>>> print(abs(-7.5)) 
+    7.5
+>>> print(pow(3, 4))
+    81
+>>> numbers = [5, 2, 8, 1]
+>>> print(max(numbers))  
+    8
+>>> print(min(numbers)) 
+    1
+>>> print(sum(numbers))
+    16
+>>> a, b = divmod(17, 5)
+>>> print(a, b)
+    3 2
+>>> text = "Hello"
+>>> print('len("Hello") =', len(text))
+    5
+numbers = [1, 2, 3, 4]
+text_numbers = list(map(str, numbers))
+print(text_numbers)
+    ['1', '2', '3', '4']
+```
+
+## 3. Модуль math.
+Функции из стандартного модуля __math__ – совокупность разнообразных математических функций. Загрум модуль math с помощью инструкции. Затем узнаем содержание модуля с помощью
+функции _dir_. Изучим функцию расчета факториала __factorial__ с помощью функции __help__ и попробуем использовать эту функцию.
+_Обращение к функциям из импортированного модуля осуществляется с указанием имени модуля, по образцу:  <имя модуля>.<имя функции>(<аргументы функции>)_
+```py
+>>> import math
+>>> print(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', '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.
+>>> print(math.factorial(5))
+    120
+```
+Аналогичным образом изучим и попробуем применить некоторые другие функции из этого модуля: _sin, acos, degrees, radians, exp, log, log10, sqrt, ceil, floor, pi._
+```py
+>>> import math
+>>> print(math.factorial(5))
+    120
+>>> print(math.sin(math.pi/2))
+    1.0
+>>> print(math.acos(0.5))
+    1.0471975511965979
+>>> print(math.degrees(math.pi))
+    180.0
+>>> print(math.radians(180))
+    3.141592653589793
+>>> print(math.exp(1))
+    2.718281828459045
+>>> print(math.log(100))
+    4.605170185988092
+>>> print(math.log10(100))
+    2.0
+>>> print(math.sqrt(25))
+    5.0
+>>> print(math.ceil(4.2))
+    5
+>>> print(math.floor(4.9))
+    4
+>>> print(math.pi)
+    3.141592653589793
+```
+Решение примера sin(2π/7+e0.23 ):
+```py
+>>> result = math.sin(2 * math.pi / 7 + math.exp(0.23))
+>>> print(result)
+    0.8334902641414562
+```
+
+## 4. Модуль cmath. 
+Функции из модуля __cmath__ – совокупность функций для работы с комплексными числами.
+Начнём с импорта модуля, затем отобразим его атрибуты и изучим функцию для извлечения квадратного корня из комплексного числа и и функцию расчета фазы.
+```py
+>>> import cmath
+>>> print(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']
+>>> print(cmath.sqrt(1.2-0.5j))
+    (1.118033988749895-0.22360679774997896j)
+>>> print(cmath.phase(1-0.5j))
+    -0.4636476090008061
+```
+
+## 5. Модуль random.
+Стандартный модуль __random__ – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+```py
+>>> import random
+>>> print(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', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>> help(random.seed)
+    Help on method seed in module random:
+
+        seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+        The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+        None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+        If *a* is an int, all bits are used.
+
+        For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+>>> print(random.seed())
+    None
+```
+
+Далее самостоятельно изучим и попробуем применить следующие функции:
+```py
+>>> import random
+>>> random.seed(42)
+>>> print(random.random())
+    0.6394267984578837
+>>> print(random.uniform(10, 20))
+    10.25010755222667
+>>> print(random.randint(1, 6))
+    3
+>>> print(random.gauss(0, 1))
+    0.017593105583573694
+
+>>> fruits = ["яблоко", "банан", "апельсин", "киви"]
+>>> print(random.choice(fruits))
+    яблоко
+>>> cards = ["Туз", "Король", "Дама", "Валет"]
+>>> random.shuffle(cards)
+>>> print(cards)
+    ['Валет', 'Король', 'Дама', 'Туз']
+>>> numbers = list(range(1, 51))
+>>> print(random.sample(numbers, 5))
+    [3, 2, 6, 14, 15]
+>>> print(random.betavariate(2, 5))
+    0.3918844780644009
+>>> print(random.gammavariate(2, 1))
+    2.219353519271194
+>>> print(random.randint(100, 999))
+    703
+>>> print(random.uniform(-5, 5))
+    -2.218092917693373
+```
+
+Создадим список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма:
+```py
+random_values = [random.uniform(0, 1), random.gauss(0, 1), random.betavariate(2, 5), random.gammavariate(2, 1)]
+print(random_values)
+    [0.869300320792934, 0.5479616463399781, 0.33952976689383546, 0.5704217216825608]
+```
+
+## 6. Модуль time.
+Функции из модуля __time__ – работа с календарем и со временем.
+```py
+>>> import time
+>>> print(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()
+>>> print(c1)
+    1757970835.4250033
+```
+Изучим функцию __time__, возвращающую время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г.
+```py
+>>> c2=time.time()-c1
+>>> print(c2)
+    0.022925376892089844
+```
+Теперь изучим функцию __gmtime__.
+```py
+>>> dat=time.gmtime()
+>>> print(dat)
+    time.struct_time(tm_year=2025, tm_mon=9, tm_mday=15, tm_hour=21, tm_min=16, tm_sec=35, tm_wday=0, tm_yday=258, tm_isdst=0)
+>>> print(dat.tm_mon)
+    9
+```
+__ Функция localtime()__ - местное время:
+```py
+>>> local_time = time.localtime()
+>>> print(local_time.tm_year)
+    2025
+>>> print(local_time.tm_mon)
+    9
+>>> print(local_time.tm_mday)
+    18
+>>> print(local_time.tm_hour)
+    10
+>>> print(local_time.tm_min)
+    11
+>>> print(local_time.tm_sec)
+    12
+```
+__Функция asctime()__ - ппреобразование представления времени из кортежа в строку:
+```py
+time_str = time.asctime(local_time)
+print(time_str)
+    Thu Sep 18 10:22:12 2025
+```
+__Функция ctime()__ - преобразование времени в секундах, прошедшего с начала эпохи, в строку:
+```py
+>>> current_seconds = time.time()
+>>> print(current_seconds)
+    1758180132.4304066
+>>> time_from_seconds = time.ctime(current_seconds)
+>>> print(time_from_seconds)
+    Thu Sep 18 10:22:12 2025
+```
+
+__Функция sleep()__ - прерывание работы программы на заданное время:
+```py
+>>> print("Начинаем отсчет...")
+>>> for i in range(3, 0, -1):
+>>>    print(f"{i}...")
+>>>    time.sleep(2)
+>>> print("Запуск!")
+```
+Вывод программы:
+```py
+Начинаем отсчет...
+3...
+2...
+1...
+Запуск!
+```
+Числа выводлись через 2 секунды.
+
+__Функция mktime()__ - преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи.
+```py
+>>> seconds_from_struct = time.mktime(local_time)
+>>> print(seconds_from_struct)
+    1758180480.0
+```
+Обратное преобразование из секунд в местное время осуществляется той же функцией localtime():
+```py
+>>> print(time.localtime(c1))
+    time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=10, tm_min=29, tm_sec=52, tm_wday=3, tm_yday=261, tm_isdst=0)
+```
+
+## 7. Графические функции.
+Импортируем модуль с инструкцией. Создадим два списка, один из которых будет содержать значения сигнала x, а другой – моменты времени измерения значений сигнала t. После этого введем инструкции создания и отображения графика x(t):
+```py
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t, x) 
+pylab.title('Первый график')
+pylab.xlabel('время')
+pylab.ylabel('сигнал')
+pylab.show() 
+```
+
+Мы полчили:
+
+<img src = "./photo1.png" width="500" height="300" align="center">
+
+Изучим содержание окна с появившимся графиком и сохраним график в текущем каталоге в файле с именем __Ris1__. 
+Рассмотрим способ построения нескольких графиков на одном рисунке. Для этого создадим два списка:
+
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+>>> pylab.plot(X2)
+>>> pylab.show()
+```
+<img src = "./photo2.png" width="500" height="300" align="center">
+
+
+Теперь изучим возможность построения круговой диаграммы:
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  
+>>> naselen=[65,12,23,17] 
+>>> pylab.pie(naselen,labels=region) 
+>> pylab.show() 
+```
+<img src = "./photo3.png" width="500" height="300" align="center">
+
+Самостоятельно изучим и попробуем применить функции __hist__ и __bar__ для построения гистограмм и столбиковых диаграмм. 
+
+__hist__
+
+```py
+>>>> import matplotlib.pyplot as plt
+>>> assessments = [3, 4, 5, 3, 4, 5, 5, 4, 3, 2, 4, 5, 3, 4, 5, 4, 3, 5, 4, 3]
+>>> plt.hist(assessments, bins=5, color='lightblue', edgecolor='black')
+>>> plt.xlabel('Оценки')
+>>> plt.ylabel('Количество студентов')
+>>> plt.title('Распределение оценок студентов')
+>>> plt.show()
+```
+<img src = "./photo4.png" width="500" height="300" align="center">
+
+
+__bar__
+```py
+>>> fruits = ['Яблоки', 'Бананы', 'Апельсины', 'Груши']
+>>> count = [25, 30, 15, 20]
+>>> color = ['red', 'yellow', 'orange', 'green']
+>>> plt.bar(fruits, count, color=color)
+>>> plt.ylabel('Количество')
+>>> plt.title('Любимые фрукты')
+>>> plt.show()
+```
+<img src = "./photo5.png" width="500" height="300" align="center">
+
+
+__statistics__
+Изучим состав статистического модуля __statistics__:
+```py
+>>> import statistics
+>> print(dir(statistics))
+    ['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_mean_stdev', '_normal_dist_inv_cdf', '_rank', '_sqrt_bit_width', '_ss', '_sum', 'bisect_left', 'bisect_right', 'correlation', 'count', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'itemgetter', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'namedtuple', 'numbers', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sqrt', 'stdev', 'sumprod', 'sys', 'tau', 'variance']
+```
+Рассмотрим три функции:
+```py
+>>> data = [1, 2, 3, 4, 5, 5, 6]
+>>> print("Mean:", statistics.mean(data))
+>>> print("Median:", statistics.median(data))
+>>> print("Mode:", statistics.mode(data))
+>>> print("Stdev:", statistics.stdev(data))
+    Mean: 3.7142857142857144
+    Median: 4
+    Mode: 5
+    Stdev: 1.7994708216848747
+```
+
+## Завершение работы.

TEMA5/Task.md

@@ -0,0 +1,106 @@
+# Общее контрольное задание по теме 5
+Зеленкина Ксения, А-02-23
+
+## Задание 1
+
+Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+## Решение
+_Код:_
+```py
+text = "Create a new string object from the given object."
+sl = {}
+for x in text:
+    if x.isalpha() == True:
+        a  = x.lower()
+        pos = ord(a) - ord('a') + 1
+        sl[a] = pos
+for l in sl:
+    print(f"{l}: {sl[l]}")
+```
+
+_Вывод:_
+```py
+C: 3
+r: 18
+e: 5
+a: 1
+t: 20
+n: 14
+w: 23
+s: 19
+i: 9
+g: 7
+o: 15
+b: 2
+j: 10
+c: 3
+f: 6
+m: 13
+h: 8
+v: 22
+```
+
+## Задание 2
+
+Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+## Решение
+_Код:_
+```py
+spis = ["список", "со", "словами", "из", "задания", "данного", "пункта"]
+word1 = "список"
+word2 = "программа"
+
+if word1 in spis:
+    print(f"'{word1}' есть в списке!")
+else:
+    print(f"'{word1}' нет в списке!")
+
+if word2 in spis:
+    print(f"'{word2}' есть в списке!")
+else:
+    print(f"'{word2}' нет в списке!")
+```
+
+_Вывод:_
+```py
+'список' есть в списке!
+'программа' нет в списке!
+```
+
+## Задание 3
+Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+_Код:_
+```py
+studentsSum = ["Зеленкина", "Криви", "Капитонов", "Хатюхин"]
+gradesSum = [4.5, 3.8, 4.2, 4.9]
+studentsWin = ["Криви", "Хатюхин", "Зеленкина", "Капитонов"]
+gradesWin = [4.1, 4.7, 4.3, 4.0]
+print(f"Список студентов: {studentsSum}")
+surname = input("Введите фамилию студента из списка: ")
+if surname in studentsSum:
+    inds = studentsSum.index(surname)
+    gs = gradesSum[inds]
+    print(f"Летняя сессия: {gs}")
+else:
+    print("Такой студент не найден")
+
+if surname in studentsWin:
+    indw = studentsWin.index(surname)
+    gw = gradesWin[indw]
+    print(f"Зимняя сессия: {gw}")
+else:
+    print("Такой студент не найден")
+```
+
+_Вывод:_
+```py
+Список студентов: ['Зеленкина', 'Криви', 'Капитонов', 'Хатюхин']
+Введите фамилию студента из списка: Криви
+Летняя сессия: 3.8
+Зимняя сессия: 4.1
+```
+

TEMA5/Task.py

@@ -0,0 +1,47 @@
+#1
+text = "Create a new string object from the given object."
+sl = {}
+for x in text:
+    if x.isalpha() == True:
+        a  = x.lower()
+        pos = ord(a) - ord('a') + 1
+        sl[a] = pos
+for l in sl:
+    print(f"{l}: {sl[l]}")
+
+#2
+spis = ["список", "со", "словами", "из", "задания", "данного", "пункта"]
+word1 = "список"
+word2 = "программа"
+
+if word1 in spis:
+    print(f"'{word1}' есть в списке!")
+else:
+    print(f"'{word1}' нет в списке!")
+
+if word2 in spis:
+    print(f"'{word2}' есть в списке!")
+else:
+    print(f"'{word2}' нет в списке!")
+
+#3
+studentsSum = ["Зеленкина", "Криви", "Капитонов", "Хатюхин"]
+gradesSum = [4.5, 3.8, 4.2, 4.9]
+studentsWin = ["Криви", "Хатюхин", "Зеленкина", "Капитонов"]
+gradesWin = [4.1, 4.7, 4.3, 4.0]
+print(f"Список студентов: {studentsSum}")
+surname = input("Введите фамилию студента из списка: ")
+if surname in studentsSum:
+    inds = studentsSum.index(surname)
+    gs = gradesSum[inds]
+    print(f"Летняя сессия: {gs}")
+else:
+    print("Такой студент не найден")
+
+if surname in studentsWin:
+    indw = studentsWin.index(surname)
+    gw = gradesWin[indw]
+    print(f"Зимняя сессия: {gw}")
+else:
+    print("Такой студент не найден")
+

TEMA5/Test.md

@@ -0,0 +1,29 @@
+# Индивидуальные контрольные задания по теме 5
+Зеленкина Ксения А-02-23
+
+## Задача
+Создайте символьную строку с текстом: «я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство». Напишите инструкции, позволяющие определить, каких букв русского алфавита нет в этой строке.
+
+## Решение
+_Код:_
+```py
+stroka = 'я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство'
+RusAlph = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+HChar = set()
+for x in stroka.lower():
+    if x in RusAlph :
+        HChar.add(x)
+
+NHChar = []
+for i in RusAlph:
+    if i not in HChar:
+        NHChar.append(i)
+
+print(f'Буквы, которых нет в строке: {NHChar}')
+```
+
+_Вывод:_
+```py
+Буквы, которых нет в строке: ['ё', 'п', 'ы']
+```
+_Примечание:_ Используем множество (__HChar__), так как оно хранит только уникальные значения!

TEMA5/Test.py

@@ -0,0 +1,15 @@
+#Создайте символьную строку с текстом: «я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство». Напишите инструкции, позволяющие определить, каких букв русского алфавита нет в этой строке.
+
+stroka = 'я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство'
+RusAlph = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+HChar = set()
+for x in stroka.lower():
+    if x in RusAlph :
+        HChar.add(x)
+
+NHChar = []
+for i in RusAlph:
+    if i not in HChar:
+        NHChar.append(i)
+
+print(f'Буквы, которых нет в строке: {NHChar}')

TEMA5/report.py

@@ -0,0 +1,139 @@
+# Тема 5 < Зеленкина Ксения Михайловна>
+# 2.
+# Пример 1.
+porog, rashod1, rashod2 = 3, 120, 50
+if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+		dohod=-8
+print(dohod)
+
+# Пример 2.
+if rashod1>=3 and rashod2==4:
+		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+			dohod=porog
+print(dohod)
+
+# Пример 3
+if porog==3:
+		dohod=1
+elif porog==4:
+		dohod=2
+elif porog==5:
+		dohod=3
+else:
+		dohod=0
+print(dohod)
+
+
+# В одну строчку
+# Пример 1
+dohod=2 if porog>=4 else 0
+print(dohod)
+
+# Пример 2
+porog = 10
+if porog>=5 : rashod1=6; rashod2=0
+print(rashod1, rashod2)
+
+# 3.1
+temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+	print(temperatura)
+
+# 3.2
+# Пример 1
+sps=[2,15,14,8]
+for k in sps:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+print(sps)
+
+#Пример 2
+sps=[2,15,14,8]
+for k in sps[:]:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+print(sps)
+
+# 3.3
+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)
+
+# 3.4
+stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss
+print(stroka1)
+
+# 3.5.
+import math
+import matplotlib.pyplot as plt
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+x = list(range(100))
+
+plt.figure(figsize=(12, 6))
+plt.plot(x, sps2, 'b-', linewidth=1, label='sin(i*π/5 + 2)')
+plt.title('График сигнала: sin(i*π/5 + 2)')
+plt.xlabel('i (индекс)')
+plt.ylabel('Значение sin(i*π/5 + 2)')
+plt.show()
+
+
+# 4.1
+rashod=300
+while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+# 4.2
+import math
+import matplotlib.pyplot as plt
+stroka='Расчет процесса в объекте регулирования'
+i=0
+sps2=[]
+while i<len(stroka):
+	r=1-2/(1+math.exp(0.1*i))
+	sps2.append(r)
+	print('Значение в момент',i,"=",r)
+	i+=1
+plt.figure(figsize=(12, 6))
+plt.plot(sps2, 'b-', linewidth=2, label='Выход инерционного звена')
+plt.title('Сигнал на выходе инерционного звена')
+plt.xlabel('Время (момент i)')
+plt.ylabel('Значение r')
+plt.grid(True, alpha=0.3)
+plt.legend()
+plt.show()
+
+#4.3.
+chislo=267   #Проверяемое число
+kandidat =chislo // 2 		# Для значений chislo > 1
+while kandidat > 1:
+	if chislo%kandidat == 0: 	# Остаток от деления
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+else: 			# При завершении цикла без break
+	print(chislo, ' является простым!')
+
+# Дополненный код
+for chislo in range(250, 301):
+	kandidat = chislo // 2
+	while kandidat > 1:
+		if chislo % kandidat == 0:
+			break
+		kandidat -= 1
+	else:
+		print(chislo, 'является простым!')
+

TEMA5/report5.md

@@ -0,0 +1,263 @@
+# Отчет по Теме 5
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+
+## 2. Условный оператор.
+Изучила ветвление по условию – управляющая инструкция __if__. 
+Задала некоторые числовые значения объектам __porog__, __rashod1__, __rashod2__. Выполните следующую операцию, определив значение __dohod__:
+
+_Пример 1:_
+ ```py
+porog, rashod1, rashod2 = 3, 120, 50
+if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+	 	dohod=-8
+print(dohod)
+ ```
+ 
+__Результат:__
+```py
+12
+```
+Выполним ещё одну операцию, определив значение __dohod__:
+_Пример 2:_
+ ```py
+if rashod1>=3 and rashod2==4:
+ 		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+ 			dohod=porog
+print(dohod)
+ ```
+ __Результат:__
+```py
+12
+```
+Ещё одна операция с множественным ветвлением линий потока:
+_Пример 3:_
+```py
+if porog==3:
+		dohod=1
+elif porog==4:
+		dohod=2
+elif porog==5:
+		dohod=3
+else:
+		dohod=0
+print(dohod)
+```
+ __Результат:__
+```py
+1
+```
+Условные инструкции можно записываться также в одну строку в операторе присваивания. Изучим примеры:
+_Пример 1:_
+```py
+dohod=2 if porog>=4 else 0
+```
+ __Результат:__
+ ```py
+ 0
+ ```
+ 
+ _Пример 2:_
+```py
+porog = 10
+if porog>=5 : rashod1=6; rashod2=0
+print(rashod1, rashod2)
+```
+ __Результат:__
+ ```py
+ 6 0
+ ```
+ 
+## 3. Цикл по перечислению.
+ Цикл по перечислению – управляющая инструкция for. 
+#### 3.1.
+ Выполним простой цикл:
+ ```py
+ temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+	print(temperatura)
+ ```
+  __Результат:__
+ ```py
+8
+14
+23
+35
+50
+ ```
+#### 3.2.
+ Выполним более сложный цикл:
+ ```py
+ sps=[2,15,14,8]
+for k in sps:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+print(sps)
+ ```
+  __Результат:__
+ ```py
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+ ```
+ Выполним чуть-чуть отличающуюся совокупность операций:
+ ```py
+sps=[2,15,14,8]
+for k in sps[:]:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+print(sps)
+ ```
+   __Результат:__
+ ```py
+[2, 15, 14, 8, 2, 2, 2, 2]
+ ```
+#### 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)
+ ```
+    __Результат:__
+ ```py
+1 раз: (пусто)
+2 раз: (пусто)
+3 раз: 316
+ ```
+ Вывод значения __ss__ бывает не всегда, потому что блок __else__ относится к циклу __for__ и выполняется только если цикл не был прерван __break__.
+ 
+ #### 3.4.
+ Пример с символьной строкой
+ ```py
+ stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss
+print(stroka1)
+ ```
+__Результат:__
+ ```py
+ Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а
+ ```
+ 
+#### 3.5.
+ Запись цикла в строке. Пример: создание списка с синусоидальным сигналом:
+ ```py
+ import math
+import matplotlib.pyplot as plt
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+x = list(range(100))
+plt.figure(figsize=(12, 6))
+plt.plot(x, sps2, 'b-', linewidth=1, label='sin(i*π/5 + 2)')
+plt.title('График сигнала: sin(i*π/5 + 2)')
+plt.xlabel('i (индекс)')
+plt.ylabel('Значение sin(i*π/5 + 2)')
+plt.show()
+ ```
+__График:__
+ <img src = "./photo1.png" width="500" height="400" align="center">
+ 
+ ## 4. Цикл «пока истинно условие» 
+ Цикл «пока истинно условие» – управляющая инструкция __while__.
+ #### 4.1.
+ Цикл со счетчиком:
+ ```py
+ rashod=300
+while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+ ```
+__Результат:__
+ ```py
+ Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Цикл завершился, потому что условие __while rashod__: стало ложным, когда __rashod__ достиг нуля.
+
+#### 4.2.
+ Пример с символьной строкой.
+ ```py
+ import math
+import matplotlib.pyplot as plt
+stroka='Расчет процесса в объекте регулирования'
+i=0
+sps2=[]
+while i<len(stroka):
+	r=1-2/(1+math.exp(0.1*i))
+	sps2.append(r)
+	print('Значение в момент',i,"=",r)
+	i+=1
+plt.figure(figsize=(12, 6))
+plt.plot(sps2, 'b-', linewidth=2, label='Выход инерционного звена')
+plt.title('Сигнал на выходе инерционного звена')
+plt.xlabel('Время (момент i)')
+plt.ylabel('Значение r')
+plt.grid(True, alpha=0.3)
+plt.legend()
+plt.show()
+ ```
+ 
+__График:__
+ <img src = "./photo2.png" width="500" height="400" align="center">
+
+#### 4.3.
+Определим, является ли число простым (делится только на самого себя или 1).
+```py
+chislo=267   #Проверяемое число
+kandidat =chislo // 2 		
+while kandidat > 1:
+	if chislo%kandidat == 0: 
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+else: 			# При завершении цикла без break
+	print(chislo, ' является простым!')
+```
+__Результат:__
+ ```py
+ 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:
+		print(chislo, 'является простым!')
+ ```
+ 
+__Результат:__
+ ```py
+ 251 является простым!
+257 является простым!
+263 является простым!
+269 является простым!
+271 является простым!
+277 является простым!
+281 является простым!
+283 является простым!
+293 является простым!
+ ```
+
+## Завершение работы.

TEMA6/Stroka.txt

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

TEMA6/Task.md

@@ -0,0 +1,133 @@
+# Общее контрольное задание по теме 6
+Зеленкина Ксения, А-02-23
+
+## Задание 
+
+Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+
+#### Решение
+_Код:_
+```py
+import random
+num = list(range(1, 126, 1))
+tup = ()
+for i in num:
+    tup = tuple(tup + (random.randint(6, 56),))
+str_tup = tuple(map(str, tup))
+print(str_tup)
+```
+
+_Вывод:_
+```py
+('49', '46', '53', '24', '54', '8', '47', '48', '43', '43', '9', '8', '43', '14', '39', '17', '49', '47', '34', '18', '37', '39', '17', '30', '9', '19', '56', '8', '15', '36', '31', '52', '20', '26', '40', '15', '14', '29', '37', '48', '55', '16', '36', '34', '53', '10', '26', '37', '10', '53', '48', '49', '33', '38', '44', '33', '23', '18', '54', '8', '19', '42', '49', '18', '8', '22', '16', '9', '14', '54', '29', '9', '52', '55', '13', '27', '13', '46', '29', '13', '11', '37', '20', '21', '24', '27', '53', '39', '25', '40', '20', '33', '15', '24', '33', '18', '40', '35', '11', '52', '44', '10', '53', '29', '35', '42', '8', '42', '18', '19', '6', '55', '23', '34', '49', '46', '10', '20', '46', '26', '43', '25', '43', '29', '12')
+```
+
+## Задание 
+Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+
+#### Решение
+_Код:_
+```py
+surname = ["Зеленкина", "Криви", "Капитонов", "Хатюхин", "Шабатов"]
+print("Создан список фамилий:", surname)
+```
+_Вывод:_
+```py
+Создан список фамилий: ['Зеленкина', 'Криви', 'Капитонов', 'Хатюхин', 'Шабатов']
+```
+
+## Задание 
+Записывается кортеж в бинарный файл.
+
+#### Решение
+_Код:_
+```py
+f = open('bin.mnz', 'wb')
+```
+
+## Задание 
+Записывается в этот же файл список и закрывается файл.
+
+#### Решение
+_Код:_
+```py
+pickle.dump(str_tup, f)
+pickle.dump(surname, f)
+f.close()
+```
+
+
+## Задание 
+Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+
+#### Решение
+_Код:_
+```py
+f = open('bin.mnz', 'rb')
+obj1 = pickle.load(f)
+obj2_spis = pickle.load(f)
+f.close()
+print("Прочитан кортеж:", obj1)
+print("Прочитан список:", obj2_spis)
+```
+_Вывод:_
+```py
+Прочитан кортеж: ('49', '46', '53', '24', '54', '8', '47', '48', '43', '43', '9', '8', '43', '14', '39', '17', '49', '47', '34', '18', '37', '39', '17', '30', '9', '19', '56', '8', '15', '36', '31', '52', '20', '26', '40', '15', '14', '29', '37', '48', '55', '16', '36', '34', '53', '10', '26', '37', '10', '53', '48', '49', '33', '38', '44', '33', '23', '18', '54', '8', '19', '42', '49', '18', '8', '22', '16', '9', '14', '54', '29', '9', '52', '55', '13', '27', '13', '46', '29', '13', '11', '37', '20', '21', '24', '27', '53', '39', '25', '40', '20', '33', '15', '24', '33', '18', '40', '35', '11', '52', '44', '10', '53', '29', '35', '42', '8', '42', '18', '19', '6', '55', '23', '34', '49', '46', '10', '20', '46', '26', '43', '25', '43', '29', '12')
+Прочитан список: ['Зеленкина', 'Криви', 'Капитонов', 'Хатюхин', 'Шабатов']
+```
+
+## Задание 
+Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+
+#### Решение
+_Код:_
+```py
+if obj1 == str_tup and obj2_spis == surname:
+    print("Объекты совпадают с исходными!")
+else:
+    print("Объекты не совпадают с исходными!")
+```
+_Вывод:_
+```py
+Объекты совпадают с исходными!
+```
+
+## Задание 
+Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+#### Решение
+_Код:_
+```py
+l = []
+for i in range(0, 125, 5):
+    l.append(list(str_tup[i:i + 5]))
+for i in range(25):
+    print(f"list{i + 1} = {l[i]}")
+```
+_Вывод:_
+```py
+list1 = ['43', '47', '53', '54', '35']
+list2 = ['10', '21', '16', '26', '54']
+list3 = ['55', '8', '15', '47', '56']
+list4 = ['21', '9', '18', '20', '8']
+list5 = ['25', '48', '28', '28', '12']
+list6 = ['16', '41', '13', '18', '6']
+list7 = ['50', '15', '51', '36', '31']
+list8 = ['46', '33', '12', '8', '9']
+list9 = ['49', '50', '45', '41', '14']
+list10 = ['56', '13', '31', '45', '30']
+list11 = ['45', '37', '12', '35', '50']
+list12 = ['13', '54', '17', '19', '33']
+list13 = ['39', '28', '56', '10', '18']
+list14 = ['23', '20', '43', '17', '14']
+list15 = ['29', '17', '44', '7', '41']
+list16 = ['9', '51', '25', '21', '26']
+list17 = ['51', '18', '10', '31', '48']
+list18 = ['23', '49', '54', '25', '18']
+list19 = ['8', '46', '37', '22', '28']
+list20 = ['11', '6', '37', '34', '11']
+list21 = ['6', '17', '38', '45', '46']
+list22 = ['30', '15', '7', '20', '45']
+list23 = ['54', '47', '24', '30', '18']
+list24 = ['48', '36', '8', '14', '32']
+list25 = ['35', '52', '39', '39', '10']
+```

TEMA6/Task.py

@@ -0,0 +1,38 @@
+import random
+import os
+import pickle
+
+num = list(range(1, 126, 1))
+tup = ()
+for i in num:
+    tup = tuple(tup + (random.randint(6, 56),))
+str_tup = tuple(map(str, tup))
+print(str_tup)
+surname = ["Зеленкина", "Криви", "Капитонов", "Хатюхин", "Шабатов"]
+print("Создан список фамилий:", surname)
+
+f = open('bin.mnz', 'wb')
+pickle.dump(str_tup, f)
+pickle.dump(surname, f)
+f.close()
+
+f = open('bin.mnz', 'rb')
+obj1 = pickle.load(f)
+obj2_spis = pickle.load(f)
+f.close()
+print("Прочитан кортеж:", obj1)
+print("Прочитан список:", obj2_spis)
+
+if obj1 == str_tup and obj2_spis == surname:
+    print("Объекты совпадают с исходными!")
+else:
+    print("Объекты не совпадают с исходными!")
+
+l = []
+for i in range(0, 125, 5):
+    l.append(list(str_tup[i:i + 5]))
+
+for i in range(25):
+    exec(f"list{i + 1} = {l[i]}")
+
+print(dir())

TEMA6/Test.md

@@ -0,0 +1,90 @@
+# Индивидуальное контрольное задание по модулю 2
+
+Зеленкина Ксения А-02-23
+## Задание
+1)	Создайте словарь с 10 элементами: ключи - фамилии студентов, значения - целые, случайные числа в диапазоне от 1 до 100.
+2)	Запишите словарь в бинарный файл.
+3)	Удалите словарь из памяти.
+4)	Прочитайте словарь из файла и удалите из него два элемента: первого и последнего студента.
+5)	Выведите на экран элементы полученного словаря в виде строк по шаблону: "Студент <ключ из словаря> : <значение из словаря>"
+
+
+## Решение
+#### 1. Создайте словарь с 10 элементами: ключи - фамилии студентов, значения - целые, случайные числа в диапазоне от 1 до 100.
+```py
+import pickle
+import random
+sl = {"Беженарь": random.randint(1, 100),
+            "Володин": random.randint(1, 100),
+            "Добровольска": random.randint(1, 100),
+            "Ефремов": random.randint(1, 100),
+            "Зеленкина": random.randint(1, 100),
+            "Зеленкина2": random.randint(1, 100),
+            "Капитонов": random.randint(1, 100),
+            "Киреев": random.randint(1, 100),
+            "Коломейцев": random.randint(1, 100),
+            "Криви": random.randint(1, 100)}
+```
+
+#### 2. Запишите словарь в бинарный файл.
+__Способ 1 (как в лр):__
+
+_Код:_
+```py
+fl=open('test.mnz','wb')
+pickle.dump(sl, fl)
+```
+__Способ 2 (как в методичке):__
+
+_Код:_
+```py
+with open('test.mnz', 'wb') as file:
+    pickle.dump(sl, fl)
+```
+<img src = "./phototest.png" width="500" height="300" align="center">
+
+#### 3. Удалите словарь из памяти.
+_Код:_
+```py
+del sl
+```
+
+#### 4. Прочитайте словарь из файла и удалите из него два элемента: первого и последнего студента.
+_Код:_
+```py
+with open('test.mnz', 'rb') as fl:
+    rsl = pickle.load(fl)
+```
+Выведим первый и последний элемент и удалим их
+_Код:_
+```py
+print(list(rsl.keys())[0])
+print(list(rsl.keys())[-1])
+
+del rsl[list(rsl.keys())[0]]
+del rsl[list(rsl.keys())[-1]]
+```
+
+_Вывод:_
+```py
+Беженарь
+Криви
+```
+
+#### 5. Выведите на экран элементы полученного словаря в виде строк по шаблону: "Студент <ключ из словаря> : <значение из словаря>"
+_Код:_
+```py
+for i in rsl:
+    print(f"Студент {i}", rsl[i], sep =': ')
+```
+_Вывод:_
+```py
+Студент Володин: 4
+Студент Добровольска: 10
+Студент Ефремов: 46
+Студент Зеленкина: 80
+Студент Зеленкина2: 75
+Студент Капитонов: 36
+Студент Киреев: 90
+Студент Коломейцев: 5
+```

TEMA6/Test.py

@@ -0,0 +1,41 @@
+# Индивидуальное контрольное задание
+
+## 1
+import pickle
+import random
+sl = {"Беженарь": random.randint(1, 100),
+            "Володин": random.randint(1, 100),
+            "Добровольска": random.randint(1, 100),
+            "Ефремов": random.randint(1, 100),
+            "Зеленкина": random.randint(1, 100),
+            "Зеленкина2": random.randint(1, 100),
+            "Капитонов": random.randint(1, 100),
+            "Киреев": random.randint(1, 100),
+            "Коломейцев": random.randint(1, 100),
+            "Криви": random.randint(1, 100)}
+
+## 2
+# Как в лр
+fl=open('test.mnz','wb')
+pickle.dump(sl, fl)
+
+#
+# with open('test.mnz', 'wb') as file:
+#     pickle.dump(sl, fl)
+
+# 3
+del sl
+
+# 4
+with open('test.mnz', 'rb') as fl:
+    rsl = pickle.load(fl)
+# Выведим первое и последнее значение словаря
+print(list(rsl.keys())[0])
+print(list(rsl.keys())[-1])
+# Удалим
+del rsl[list(rsl.keys())[0]]
+del rsl[list(rsl.keys())[-1]]
+
+# 5
+for i in rsl:
+    print(f"Студент {i}", rsl[i], sep =': ')

TEMA6/report.md

@@ -0,0 +1,550 @@
+# Отчет по Теме 6
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+
+## 2. Вывод данных на экран дисплея.
+#### 2.1. Вывод в командной строке.
+Cодержимое любого объекта можно увидеть простым упоминанием его в командной строке (как это много раз делалось раньше), например:
+```py
+>> stroka='Автоматизированная система управления'
+>> stroka
+```
+_Вывод:_
+```py
+'Автоматизированная система управления'
+```
+Этот способ называется __«эхо-выводом»__.
+
+
+#### 2.2. Вывод с использованием функции  __print__.
+Пример вывода:
+```py
+>> fff=234.5;gg='Значение температуры = '
+>> print(gg, fff)
+```
+
+_Вывод:_
+```py
+Значение температуры =  234.5
+```
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разделитель его можно указать в отдельном аргументе _sep_, например:
+
+```py
+print(gg, fff, sep='/')
+```
+ _Вывод:_
+```py
+Значение температуры = /234.5
+
+```
+После вывода автоматически осуществляется переход на другую строку. Если курсор надо оставить в той же строке, то следует использовать еще один аргумент, например:
+
+```py
+print(gg, fff,sep='/',end='***'); print('____')
+```
+
+ _Вывод:_
+```py
+Значение температуры = /234.5***____
+```
+После end= надо указать какими символами должна закончиться выводимая строка или указать пустую строку. Наоборот, если в какой-то момент требуется просто перейти на новую строку, можно использовать такое обращение к функции:
+
+```py
+print()
+```
+
+Оператор вывода может располагаться на нескольких строках с использованием тройных кавычек:
+```py
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+```
+_Вывод:_
+```py
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+```
+Или
+
+```py
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+```
+
+_Вывод:_
+```py
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+#### 2.3. Вывод с использованием метода __write__  объекта __sys.stdout__.
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы выводят символьное представление данных. Обычно это – экран дисплея. Объект находится в модуле sys, который надо импортировать. Например:
+```py
+import sys
+sys.stdout.write('Функция write')
+```
+_Вывод:_
+```py
+Функция write
+```
+
+Этот метод после вывода строки не осуществляет переход на новую строку. Если это требуется, то следует в конце строки добавить один или несколько символов “\n”:
+
+```py
+sys.stdout.write('Функция write\n')
+```
+_Вывод:_
+```py
+Функция write
+
+```
+
+## 3. Ввод данных с клавиатуры.
+Для ввода используйте уже знакомую функцию _input__. Например:
+
+```py
+psw=input('Введите пароль:')
+```
+
+_Вывод:_
+```py
+Введите пароль:12345
+
+```
+Посмотрим тип данной переменной:
+```py
+print(type(psw))
+```
+
+_Вывод:_
+```py
+<class 'str'>
+```
+
+_Пример 1._ Ввод с контролем значения. Пусть вводится число, которое должно находиться в интервале значений от 17.5 до 23.8.
+```py
+while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach<17.5 or znach>23.8:
+		print('Ошибка!')
+	else:
+		break
+```
+
+_Вывод:_
+```py
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+```
+
+_Пример 2_. Ввод и обработка выражения, подлежащего расчету.
+```py
+import math
+print(eval(input('введите выражение для расчета = ')))
+```
+
+_Вывод:_
+```py
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## 4. Ввод-вывод при работе с файлами.
+#### 4.1. Функции для работы с путем к файлу.
+
+Как и в других системах, в среде __Python__ в любой момент времени подразумевается некоторый рабочий каталог. Какой рабочий каталог установлен в текущий момент времени? Это  можно узнать с помощью функцииos.getcwd (cwd = current working directory):
+```py
+import os
+os.getcwd()
+```
+
+_Вывод:_
+'C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6'
+```
+
+Сохраним этот путь в переменной с именем, совпадающим с моей фамилией в латинской транскрипции. Отобразите её значение с помощью функции __print__.
+
+```py
+import os
+ZelenkinaKs = os.getcwd()
+print(ZelenkinaKs)
+```
+
+_Вывод:_
+```py
+'C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6'
+```
+
+Изменить расположение рабочего каталога можно обращением к уже многократно применявшейся функции __os.chdir__, аргументом которой будет символьная строка с указанием пути к каталогу, назначаемому в качестве рабочего, например:
+
+```py
+os.chdir('C:\Users\user\OneDrive\Documents\ZelenkinaKs\python-labs\TEMA5')
+print(os.getcwd())
+```
+_Вывод:_
+```py
+'C:\Users\user\OneDrive\Documents\ZelenkinaKs\python-labs\TEMA5'
+```
+
+Самостоятельно изучим и попробуем использовать следующие функции из модуля __os__: _mkdir, rmdir, listdir и функцию isdir из вложенного в os модуля os.path_.
+```py
+import os
+from os.path import isdir
+# Создание папки
+os.mkdir("test_folder")
+# Проверка существования папки
+print(isdir("test_folder"))
+# Просмотр содержимого текущей директории
+print(os.listdir())
+# Просмотр содержимого конкретной папки
+print(os.listdir("test_folder"))
+# Удаление папки (должна быть пустой)
+os.rmdir("test_folder")
+# Проверка после удаления
+print(isdir("test_folder"))
+```
+_Вывод:_
+```py
+True
+['.gitkeep', 'protocol6.py', 'test_folder']
+[]
+False
+```
+
+Изучили и выяснили, что:
+__mkdir()__ - создает одну папку
+__rmdir()__ - удаляет только пустые папки
+__listdir()__ - возвращает список содержимого
+__isdir()__ - проверяет, является ли путь папкой
+
+Пусть в рабочем каталоге находится файл Отчет6.md. С помощью функции __os.path.abspath__ получим символьную строку, содержащую имя файла вместе с полным  путем доступа к нему:
+
+```py
+fil=os.path.abspath("Отчет6.md")
+print(fil)
+```
+_Вывод:_
+```py
+C:\Users\user\OneDrive\Documents\ZelenkinaKs\python-labs\TEMA6\Отчет6.md
+```
+Выделим путь доступа к файлу из строки, содержащей и этот путь, и имя файла  с помощью функции __os.path.dirname__:
+```py
+drkt=os.path.dirname(fil)
+print(drkt))
+```
+_Вывод:_
+```py
+C:\Users\user\OneDrive\Documents\ZelenkinaKs\python-labs\TEMA6
+```
+Наоборот, выделим имя файла из этой строки с отбрасыванием пути с помощью функции __os.path.basename__. 
+```py
+nameFile = os.path.basename(fil)
+print(nameFile)
+```
+_Вывод:_
+```py
+Отчет6.md
+```
+
+Самостоятельно изучим функцию __os.path.split__:
+```py
+SplitFile = os.path.split(fil)
+print(SplitFile)
+```
+_Вывод:_
+```py
+('C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6', 'Отчет6.md')
+```
+__os.path.split(path)__ - возвращает кортеж (путь, имя_файла)
+
+С помощью функции __os.path.exists__ можно проверить существует ли путь, заданный в символьной строке – аргументе функции.
+```py
+print(os.path.exists("\\python-labs\\TEMA6"))
+print(os.path.exists("C:\\Users\\user\\"))
+print(os.path.exists("Отчет6.md"))
+print(os.path.exists("."))
+```
+_Вывод:_
+```py
+False
+True
+True
+True
+```
+__os.path.exists()__ - проверяет существование пути.
+
+Проверим наличие файла с известным расположением с помощью функции __os.path.isfile__, аргументом которой должна быть символьная строка с путем и именем интересующего файла.
+```py
+exists = os.path.isfile("C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6\\Отчет6.md")
+print(exists)
+```
+_Вывод:_
+```py
+True
+```
+
+#### 4.2. Общая схема работы с файлом.
+Для обмена данными с файлом необходимо выполнить следующие операции:
+	• Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+	• Выполнение одной или нескольких операций обмена данными с файлом;
+	• Закрытие файла.
+
+#### 4.3. Открытие файла для записи или чтения данных – функция __open__.
+При открытии файла необходимо указать имя файлы (с путем, если он не в рабочем каталоге) и цель работы с ним. Для открытия используется функция __open__. 
+Открываем файл zapis1.txt для записи разными способами:
+```py
+fp=open(file=drkt+'\\zapis1.txt',mode='w')
+print(type(fp))
+```
+_Вывод:_
+```py
+<class '_io.TextIOWrapper'>
+```
+
+Более короткая запись (без имен аргументов):
+```py
+fp = open(drkt + '\\zapis1.txt', 'w')
+```
+
+Если файл в рабочем каталоге - путь можно опустить:
+Более короткая запись (без имен аргументов):
+```py
+fp = open('zapis1.txt', 'w')
+```
+
+Разные режимы открытия файла:
+	__w__ – запись с созданием нового файла или перезапись существующего файла,
+	__w+__ - чтение и запись/перезапись файла,
+	__r__ – только чтение (это значение - по умолчанию),
+	__r+__ - чтение и/или запись в существующий файл,
+	__a__ – запись в конец существующего файла или, если его нет, запись с созданием файла,
+	__a+__ - то же, что и в «a», но с возможностью чтения из файла.
+
+Бинарные файлы:
+fp_bin = open('data.bin', 'wb+') 
+
+Символьные файлы (по умолчанию):
+fp_text = open('data.txt', 'wt')
+
+#### 4.4. Закрытие файла.
+
+Сразу после завершения работы с файлом его следует закрыть для обеспечения сохранности его содержимого. Это делается с помощью метода __close__, применяемого к объекту – файловой переменной. Например:
+```py
+fp.close()
+```
+
+#### 4.5 Запись информации в файл с помощью метода __write__.
+Метод __write__ относится к объекту – файловой переменной.
+_Рассмотрим его применение  на следующем примере:_ создадим список с элементами-числами от 1 до 12 и запишите их в файл по 4 числа на строке:
+```py
+sps=list(range(1,13))
+fp2=open('zapis3.txt','w')
+fp2.write(str(sps[:4])+'\n')
+fp2.write(str(sps[4:8])+'\n')
+fp2.write(str(sps[8:])+'\n')
+fp2.close()
+```
+В файле появилась следующая запись:
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+Ещё один пример. Создадим список с элементами-списками:
+```py
+sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+```
+Пусть его элементы требуется построчно записать в файл zapis4.txt.
+Первая попытка:
+```py
+fp3=open('zapis4.txt','w')
+for i in range(len(sps3)):
+	stroka4=sps3[i][0]+' '+str(sps3[i][1])
+	fp3.write(stroka4)
+fp3.close()
+```
+В файле появилась следующая запись:
+<img src = "./photo1.png" width="500" height="300" align="center">
+
+Тогда попробуйте  сделать так:
+```py
+gh = open('zapis5.txt', 'w')
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+gh.close()
+```
+
+_Вывод:_
+
+<img src = "./photo2.png" width="500" height="300" align="center">
+
+#### 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)
+```
+_Вывод:_
+```py
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+```
+Обратим внимание, что в функции открытия файла использован только один аргумент, остальные – со значениями «по умолчанию».
+Здесь, перед занесением строки в список с помощью метода __rstrip__, из неё удаляется символ конца строки, а с помощью метода __replace__ – скобки.
+
+Список sps1 отличается от записи в файле тем, что:
+sps1 - это список строк, а содержимое zapis3.txt - это вывод нескольких списков целых чисел. Такде в sps1 каждый элемент это _строка_, а в содержимом zapis3.txt - это целые числа.
+ Подумаем, как сделать так, чтобы список, полученный при чтении из файла, совпал с исходным:
+```py
+sps1 = []
+fp = open('zapis3.txt')
+for stroka in fp:
+    stroka = stroka.rstrip('\n')
+    stroka = stroka.replace('[','')
+    stroka = stroka.replace(']','')
+    chisla_str = stroka.split(',')
+    chisla = [int(x) for x in chisla_str if x]
+    sps1.append(chisla)
+fp.close()
+for podspisok in sps1:
+    print(f"[{', '.join(map(str, podspisok))}]")
+```
+_Вывод:_
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+#### 4.7. Чтение информации из файла с помощью метода __read__.
+Метод __read()__ читает данные из файла (текстового или бинарного) и возвращает строку или байтовую последовательность. Можно указать, сколько символов/байт прочитать; если не указать - прочитает всё до конца файла. Например:
+```py
+fp=open('zapis3.txt')
+stroka1=fp.read(12)
+stroka2=fp.read()
+fp.close()
+print(stroka1)
+print(stroka2)
+```
+_Вывод:_
+```py
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+#### 4.8. Чтение информации с помощью методов __readline__ и __readlines__.
+__readline()__ читает одну строку из файла, начиная с текущей позиции. 
+__readlines()__ читает все строки, возвращая их в виде списка.
+```py
+fp=open('zapis3.txt')
+stroka3=fp.readline(5)
+stroka4=fp.readlines()
+print(stroka3)
+print(stroka4)
+```
+_Вывод:_
+```py
+[1, 2
+[', 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+```
+
+#### 4.9. Ввод-вывод объектов с использованием функций из модуля __pickle__.
+В модуле __pickle__ содержатся функции для работы с бинарными файлами, в которые могут последовательно записываться или считываться целиком один или несколько объектов из оперативной памяти. Рассмотрите этот способ работы с файлами на следующем примере:
+```py
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+fp=open('zapis6.mnz','wb')  # Бинарный файл – на запись
+pickle.dump(mnoz1,fp)  #dump – метод записи объекта в файл
+fp.close()
+```
+_Вывод:_
+<img src = "./photo3.png" width="500" height="300" align="center">
+
+Теперь прочитаем данные из файла в объект __mnoz2__:
+```py
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+fp.close()
+print(mnoz2)
+```
+_Вывод:_
+```py
+{'book', 'pen', 'iPhone', 'table'}
+```
+Данные переменные имеют тип данных set, что является неупорядоченной коллекцией.
+__mnoz1__ и __mnoz2__ — это одно и то же множество, просто при его выводе на экран элементы могут быть показаны в разном порядке.
+
+А теперь с использованием тех же функций запишим в файл, а затем прочитаем два объекта разных типов: то же множество 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)  # Первое обращение к load читает первый объект
+obj2 = pickle.load(fp)  # Второе – читает второй
+fp.close()
+print(obj1)
+print(mnoz1)
+print(obj2)
+print(sps3)
+```
+_Вывод:_
+```py
+{'book', 'table', 'iPhone', 'pen'}
+{'book', 'table', 'iPhone', 'pen'}
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+obj1 совпадает с mnoz1, а obj2 c sps3.
+
+#### 5.Перенаправление потоков ввода и вывода данных.
+```py
+import sys
+vr_out=sys.stdout  #Запоминаем текущий поток вывода
+fc=open('Stroka.txt','w') #Откроем файл вывода
+sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+sys.stdout=vr_out  #Восстановление текущего потока
+print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+fc.close()
+```
+_Вывод:_
+```py
+запись строки на экран
+```
+В результате создан файл Stroka.txt в текущем каталоге с содержанием
+__'запись строки в файл'__
+Точно также можно перенаправить поток ввода – sys.stdin – вместо клавиатуры – из файла.
+```py
+import sys
+tmp_in = sys.stdin #Запоминаем текущий поток ввода
+fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+print(sys.stdin)
+while True:
+    try:
+        line = input () #Считываем из файла строку
+        print(line)  # Отображаем считанное
+    except EOFError:
+        break
+fd.close()
+sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+```
+_Вывод:_
+```py
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+запись строки в файл
+```
+## Завершение работы.

TEMA6/report.py

@@ -0,0 +1,183 @@
+# ТЕМА 6 "Зеленкина Ксения Михайловна"
+
+## 2.2.
+fff=234.5;gg='Значение температуры = '
+print(gg, fff)
+print(gg, fff, sep="/")
+print(gg, fff,sep='/',end='***'); print('____')
+
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+
+## 2.3.
+import sys
+sys.stdout.write('Функция write')
+sys.stdout.write('Функция write\n')
+
+# 3.
+#psw=input('Введите пароль:')
+#print(type(psw))
+
+# Пример 1
+#while True:
+#	znach=float(input('Задайте коэф.усиления = '))
+#	if znach<17.5 or znach>23.8:
+#		print('Ошибка!')
+#	else:
+#		break
+
+#Пример 2
+#import math
+#print(eval(input('введите выражение для расчета = ')))
+
+## 4.1.
+import os
+ZelenkinaKs = os.getcwd()
+print(ZelenkinaKs)
+os.chdir('C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA5')
+print(os.getcwd())
+os.chdir('C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6')
+
+import os
+from os.path import isdir
+# Создание папки
+os.mkdir("test_folder")
+# Проверка существования папки
+print(isdir("test_folder"))
+# Просмотр содержимого текущей директории
+print(os.listdir())
+# Просмотр содержимого конкретной папки
+print(os.listdir("test_folder"))
+# Удаление папки (должна быть пустой)
+os.rmdir("test_folder")
+# Проверка после удаления
+print(isdir("test_folder"))
+
+fil=os.path.abspath("Отчет6.md")
+print(fil)
+drkt=os.path.dirname(fil)
+print(drkt)
+nameFile = os.path.basename(fil)
+print(nameFile)
+SplitFile = os.path.split(fil)
+print(SplitFile)
+print(os.path.exists("\\python-labs\\TEMA6"))
+print(os.path.exists("C:\\Users\\user\\"))
+print(os.path.exists("Отчет6.md"))
+print(os.path.exists("."))
+
+exists = os.path.isfile("C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6\\Отчет6.md")
+print(exists)
+
+fp=open(file=drkt+'\\zapis1.txt',mode='w')
+print(type(fp))
+fp.close()
+
+sps=list(range(1,13))
+fp2=open('zapis3.txt','w')
+fp2.write(str(sps[:4])+'\n')
+fp2.write(str(sps[4:8])+'\n')
+fp2.write(str(sps[8:])+'\n')
+fp2.close()
+
+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)
+fp3.close()
+
+gh = open('zapis5.txt', 'w')
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+gh.close()
+
+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)
+
+sps1 = []
+fp = open('zapis3.txt')
+for stroka in fp:
+    stroka = stroka.rstrip('\n')
+    stroka = stroka.replace('[','')
+    stroka = stroka.replace(']','')
+    chisla_str = stroka.split(',')
+    chisla = [int(x) for x in chisla_str if x]
+    sps1.append(chisla)
+fp.close()
+for podspisok in sps1:
+    print(f"[{', '.join(map(str, podspisok))}]")
+
+fp=open('zapis3.txt')
+stroka1=fp.read(12)
+stroka2=fp.read()
+fp.close()
+print(stroka1)
+print(stroka2)
+
+fp=open('zapis3.txt')
+stroka3=fp.readline(5)
+stroka4=fp.readlines()
+print(stroka3)
+print(stroka4)
+
+## 4.9.
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+fp=open('zapis6.mnz','wb')  # Бинарный файл – на запись
+pickle.dump(mnoz1,fp)  #dump – метод записи объекта в файл
+fp.close()
+
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+fp.close()
+print(mnoz2)
+print(mnoz1)
+
+fp = open('zapis7.2ob', 'wb')
+pickle.dump(mnoz1, fp)
+pickle.dump(sps3, fp)
+fp.close()
+fp = open('zapis7.2ob', 'rb')
+obj1 = pickle.load(fp)  # Первое обращение к load читает первый объект
+obj2 = pickle.load(fp)  # Второе – читает второй
+fp.close()
+print(obj1)
+print(mnoz1)
+print(obj2)
+print(sps3)
+
+## 5.
+import sys
+vr_out=sys.stdout  #Запоминаем текущий поток вывода
+fc=open('Stroka.txt','w') #Откроем файл вывода
+sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+sys.stdout=vr_out  #Восстановление текущего потока
+print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+fc.close()
+
+import sys
+tmp_in = sys.stdin #Запоминаем текущий поток ввода
+fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+print(sys.stdin)
+while True:
+    try:
+        line = input () #Считываем из файла строку
+        print(line)  # Отображаем считанное
+    except EOFError:
+        break
+fd.close()
+sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода

TEMA6/zapis2.bin

@@ -0,0 +1 @@
+Тут какое то значение

TEMA6/zapis3.txt

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

TEMA6/zapis4.txt

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

TEMA6/zapis5.txt

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

TEMA7/Task.md

@@ -0,0 +1,102 @@
+# Общее контрольное задание по теме 7
+Зеленкина Ксения, А-02-23
+
+## Задание 
+
+-	Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+-	Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+-	Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+
+#### Решение
+##### 1
+_Код:_
+```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]
+
+
+delay = 3
+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, delay, output_signal, input_history)
+    output_signal.append(y)
+
+print("Входной сигнал:", input_signal)
+print("Выходной сигнал (задержка 3):", output_signal)
+```
+
+_Вывод:_
+```py
+Входной сигнал: [1, 2, 3, 4, 5, 6, 7]
+Выходной сигнал (задержка 3): [0, 0, 1, 2, 3, 4, 5]
+```
+
+##### 2
+_Код:_
+```py
+def raschet_giostogrammy(viborka, kol_int):
+    minn = min(viborka)
+    maxx = max(viborka)
+    shirina_intervala = (minn - maxx) / kol_int
+
+    w = [0] * kol_int
+
+    for znachenie in viborka:
+        num_int = int((znachenie - maxx) / shirina_intervala)
+        if num_int == kol_int:
+            num_int = kol_int - 1
+        w[num_int] += 1
+
+    print("Гистограмма:")
+    for i in range(kol_int):
+        start = maxx + i * shirina_intervala
+        end = maxx + (i + 1) * shirina_intervala
+        print(f"[{start:.2f}, {end:.2f}]: {w[i]}")
+
+    return w
+
+
+import random
+
+rand = [random.gauss(0, 1) for _ in range(100)]
+kol_int = 5
+res = raschet_giostogrammy(rand, kol_int)
+```
+_Вывод:_
+```py
+Гистограмма:
+[3.43, 2.27]: 2
+[2.27, 1.11]: 9
+[1.11, -0.05]: 37
+[-0.05, -1.20]: 37
+[-1.20, -2.36]: 15
+```
+
+##### 3
+
+_Код:_
+```py
+anonim_func = lambda b1, b2, X: b1 + b2 * X
+print(anonim_func (2, 3, 5))
+```
+
+_Вывод:_
+```py
+17
+```

TEMA7/Test.md

@@ -0,0 +1,38 @@
+# Индивидуальные контрольные задания по теме 7
+Зеленкина Ксения А-02-23
+
+## Задача
+Разработайте анонимную функцию, вычисляющую значение a*sin(x)/x, где a,x – аргументы функции. Рассчитайте эту функцию в интервале значений х:  0<x≤50 с шагом 0.5 и при некото-ром значении коэффициента a. Обеспечьте запись рассчитанных значений в текстовый файл по одному значению на строке. Отобразите рассчитанные значения в виде графика.
+
+## Решение
+_Код:_
+```py
+import math
+anfun = lambda a, x: a * math.sin(x)/x
+
+with open('test.txt', 'w') as fl:
+    for i in range(1, 101):
+        x = i * 0.5
+        fl.write(f"{anfun(2,x)} \n")
+
+
+x = []
+y = []
+with open('test.txt', 'r') as fl:
+    l = fl.readlines()
+    for i in range(len(l)):
+      x.append((i + 1) * 0.5 )
+      y.append(l[i].strip())
+
+print(x)
+print(y)
+
+import matplotlib.pyplot as plt
+plt.figure(figsize=(10, 5))
+plt.plot(x, y, 'r-', label='График', linewidth=2)
+plt.xlabel('x')
+plt.ylabel('y')
+plt.show()
+```
+
+<img src = "./testphoto.png" width="500" height="300" align="center">

TEMA7/Test.py

@@ -0,0 +1,36 @@
+# Вычислим анонимную функцию
+'''## Задача
+Разработайте анонимную функцию, вычисляющую значение a*sin(x)/x,
+где a,x – аргументы функции. Рассчитайте эту функцию в интервале значений х:
+0<x≤50 с шагом 0.5 и при некото-ром значении коэффициента a.
+Обеспечьте запись рассчитанных значений
+в текстовый файл по одному значению на строке. Отобразите рассчитанные значения в виде графика.'''
+import math
+anfun = lambda a, x: a * math.sin(x)/x
+
+with open('test.txt', 'w') as fl:
+    for i in range(1, 101):
+        x = i * 0.5
+        fl.write(f"{anfun(2,x)} \n")
+
+
+x = []
+y = []
+with open('test.txt', 'r') as fl:
+    lines = fl.readlines()
+    for i in range(len(lines)):
+        x.append((i + 1) * 0.5 )
+        y.append(lines[i].strip())
+
+print(x)
+print(y)
+
+import matplotlib.pyplot as plt
+plt.figure(figsize=(10, 5))
+plt.plot(x, y, 'r-', label='График', linewidth=2)
+plt.xlabel('x')
+plt.ylabel('y')
+plt.show()
+
+
+

TEMA7/report.md

@@ -0,0 +1,719 @@
+# Отчет по Теме 7
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+
+## 2. Создание пользовательской функции.
+#### 2.1. Первый пример: функция – без аргументов.
+Проверим функцию:
+_Код:_
+```py
+def uspeh():
+    """Подтверждение успеха операции"""
+    print('Выполнено успешно!')
+uspeh()
+```
+_Вывод:_
+```py
+Выполнено успешно!
+```
+Определим класс объекта с именем __uspeh__.
+_Код:_
+```py
+print(type(uspeh))
+```
+_Вывод:_
+```py
+<class 'function'>
+```
+С помощью инструкции _dir()_ убедимся, что имя функции появилось в пространстве имен.
+_Код:_
+```py
+if 'uspeh' in dir():
+    print("Функция 'uspeh' присутствует в пространстве имен")
+```
+_Вывод:_
+```py
+Функция 'uspeh' присутствует в пространстве имен
+```
+Введём инструкцию _help(uspeh):_
+_Код:_
+```py
+help(uspeh)
+```
+_Вывод:_
+```py
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+Помощь организуется через docstring - строку документации в тройных кавычках сразу после объявления функции. Python автоматически использует ее для вывода в 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)
+```
+_Вывод:_
+```py
+16  больше  5
+```
+Проверим, можно ли эту функцию выполнить с аргументами - символьными строками:
+_Код:_
+```py
+sravnenie("прога", "математика")
+sravnenie("физика", "физика")
+sravnenie("элтех", "элтехи")
+```
+_Вывод:_
+```py
+прога  больше  математика
+физика  равно  физика
+элтех  меньше  элтехи
+```
+Да, эту функцию можно выполнить с символьными строками. Сравнение строк происходит по алфавиту на основе кодов символов в Unicode.
+
+#### 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)
+print(z)
+```
+_Вывод:_
+```py
+0.6681877721681662
+```
+#### 2.4 Сложение для разных типов аргументов.
+_Код:_
+```py
+def slozh(a1,a2,a3,a4):
+	""" Сложение значений четырех аргументов"""
+	return a1+a2+a3+a4
+print(slozh(1,2,3,4))   # Сложение чисел
+print(slozh('1','2','3','4'))  # Сложение строк
+b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+q=slozh(b1,b2,b3,b4)  #Сложение списков
+print(q)
+```
+_Вывод:_
+```py
+10
+'1234'
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+ Изучим возможность применения этой функции для сложения кортежей, словарей и множеств.
+ __Кортежи:__
+ _Код:_
+ ```py
+ t1 = (1, 2); t2 = (3, 4); t3 = (5,); t4 = (6, 7)
+print(slozh(t1, t2, t3, t4))
+ ```
+ _Вывод:_
+ ```py
+ (1, 2, 3, 4, 5, 6, 7)
+ ```
+ 
+  __Множества:__
+ _Код:_
+ ```py
+s1 = {1, 2}; s2 = {2, 3}; s3 = {4}; s4 = {1, 5}
+print(slozh(s1, s2, s3, s4))
+ ```
+ _Вывод:_
+ ```py
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+ ```
+ 
+   __Словари:__
+ _Код:_
+ ```py
+d1 = {'a': 1}; d2 = {'b': 2}; d3 = {'c': 3}; d4 = {'a': 10}
+print(slozh(d1, d2, d3, d4))
+ ```
+ _Вывод:_
+ ```py
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+ ```
+ Функция __не__ работает с множествами и словарями, так как оператор "+"" не поддерживается для них.
+ 
+ #### 2.5 Модель устройства обработки сигнала
+ Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
+ ```py
+ def inerz(x,T,ypred):
+	""" Модель устройства с памятью:
+    x- текущее значение вх.сигнала,
+	T -постоянная времени,
+	ypred - предыдущее значение выхода устройства"""
+	y=(x+T*ypred)/(T+1)
+	return y
+ ```
+Создадим список с измерениями значений входного сигнала – в виде «ступеньки»:
+```py
+sps=[0]+[1]*100
+spsy=[] #Заготовили список для значений выхода
+TT=20 #Постоянная времени
+yy=0  #Нулевое начальное условие
+for xx in sps:
+	yy=inerz(xx,TT,yy)
+	spsy.append(yy)
+```
+Представим выходной сигнал в виде графика.
+```py
+import matplotlib.pyplot as plt
+plt.figure(figsize=(10, 5))
+
+plt.plot(sps, 'r-', label='Вход', linewidth=2)
+plt.plot(spsy, 'b-', label='Выход', linewidth=2)
+
+plt.xlabel('Время')
+plt.ylabel('Значение')
+plt.legend()
+plt.grid(True)
+plt.show()
+```
+<img src = "./photo1.png" width="500" height="300" align="center">
+
+## 3.	Функции как объекты.
+#### 3.1. Получение списка атрибутов объекта-функции.
+_Код:_
+```py
+print(dir(inerz))
+```
+_Вывод:_
+```py
+['__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
+print(inerz.__doc__)
+```
+_Вывод:_
+```py
+ Модель устройства с памятью:
+	x- текущее значение вх.сигнала,
+	T -постоянная времени,
+	ypred - предыдущее значение выхода устройства
+```
+Даннаяя функция берется непосредственно из строки документации в тройных кавычках внутри функции.
+
+Для сравнения, введём инструкцию:
+_Код:_
+```py
+help(inerz)
+```
+_Вывод:_
+```py
+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)
+```
+_Вывод:_
+```py
+16  меньше  23
+```
+Создали вторую переменную для функции (псевдоним) и применили её. Произошло сравнения числа 16 (записанного в переменную v) и сравнили с числом 23.
+
+#### 3.3. Возможность альтернативного определения функции в программе.
+_Код:_
+```py
+typ_fun=8
+if typ_fun==1:
+	def func():
+		print('Функция 1')
+else:
+	def func():
+		print('Функция 2')
+
+func()
+```
+_Вывод:_
+```py
+Функция 2
+```
+Выводится "Функция 2", потому что условие typ_fun==1 ложно.
+
+## 4.	Аргументы функции.
+#### 4.1. Использование функции в качестве аргумента другой функции
+_Код:_
+```py
+def fun_arg(fff,a,b,c):
+	"""fff-имя функции, используемой
+	в качестве аргумента функции fun_arg"""
+	return a+fff(c,b)
+
+zz=fun_arg(logistfun,-3,1,0.7)
+print(zz)
+```
+_Вывод:_
+```py
+-2.3318122278318336
+```
+#### 4.2. Обязательные и необязательные аргументы
+Переопределим вычисление логистической функции следующим образом:
+_Код:_
+```py
+def logistfun(a,b=1):   #Аргумент b – необязательный; значение по умолчанию=1
+	"""Вычисление логистической функции"""
+	import math
+	return b/(1+math.exp(-a))
+
+print(logistfun(0.7))    #Вычисление со значением b по умолчанию
+print(logistfun(0.7,2))  #Вычисление с заданным значением b
+```
+_Вывод:_
+```py
+0.6681877721681662
+1.3363755443363323
+```
+#### 4.3. Обращения к функции с произвольным (непозиционным) расположением аргументов 
+Изучим возможность обращения к функции с произвольным (непозиционным) расположением аргументов. При этом надо в обращении к функции указывать имена аргументов:
+_Код:_
+```py
+print(logistfun(b=0.5, a=0.8))  # Аргументы поменялись местами
+print(logistfun(a=0.8, b=0.5))  # То же самое, но в другом порядке
+```
+_Вывод:_
+```py
+0.34498724056380625
+0.34498724056380625
+```
+Все вызовы работают корректно, так как при именованном указании аргументов их порядок не имеет значения.
+
+#### 4.4 Пример со значениями аргументов функции, содержащимися в списке или кортеже.
+_Код:_
+```py
+b1234 = [b1, b2, b3, b4]  # Список списков из п.2.4
+qq = slozh(*b1234)  # Перед ссылкой на список или кортеж надо ставить звездочку
+print(qq)
+```
+_Вывод:_
+```py
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+#### 4.5. Пример со значениями аргументов функции, содержащимися в словаре
+_Код:_
+```py
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+print(qqq)
+```
+_Вывод:_
+```py
+10
+```
+
+#### 4.6. Смешанные ссылки
+_Код:_
+```py
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+print(qqqq)
+```
+_Вывод:_
+```py
+17
+```
+
+#### 4.7. Переменное число аргументов у функции
+_Код:_
+```py
+def func4(*kort7):
+	"""Произвольное число аргументов в составе кортежа"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return smm
+
+print(func4(-1,2))  #Обращение к функции с 2 аргументами
+print(func4(-1,2,0,3,6))  #Обращение к функции с 5 аргументами
+```
+_Вывод:_
+```py
+1
+10
+```
+
+#### 4.8. Комбинация аргументов
+_Код:_
+```py
+def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+	"""Кортеж - сборка аргументов - должен быть последним!"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return a*smm+b
+
+print(func4(-1,2,0,3,6))
+```
+_Вывод:_
+```py
+-7
+```
+Для словаря:
+_Код:_
+```py
+def func4_dict(a, b=7, **slovar):  # a-позиционный, b- по умолчанию, **slovar-словарь
+    """Словарь - сборка именованных аргументов - должен быть последним!"""
+    smm = 0
+    for key, value in slovar.items():
+        smm += value
+    return a * smm + b
+
+# Вызов функции:
+print(func4_dict(-1, 2, x=0, y=5, z=6))
+```
+_Вывод:_
+```py
+-9
+```
+Функция func4_dict принимает позиционный аргумент a, необязательный b и произвольные именованные аргументы **slovar, которые автоматически собираются в словарь, где ключи - имена аргументов, а значения - их значения, затем суммирует все значения словаря, умножает на a и прибавляет b.
+
+#### 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
+Такое изменение возможно только у объектов изменяемого типа.
+Пример с числовым объектом^
+_Код:_
+```py
+a=90    # Числовой объект – не изменяемый тип
+def func3(b):
+	b=5*b+67
+
+print(func3(a))
+```
+_Вывод:_
+```py
+None
+```
+Исходное значение a осталось 90 - неизменяемые объекты не меняются при передаче в функцию.
+Пример со списком:
+_Код:_
+```py
+sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+def func2(sps):
+	sps[1]=99
+print(func2(sps1))
+print(sps1)
+```
+_Вывод:_
+```py
+None
+[1, 99, 3, 4]
+```
+Список изменился, так как списки - изменяемый тип объекта.
+
+Кортеж:
+_Код:_
+```py
+kort = (1, 2, 3, 4)  # Кортеж – неизменяемый тип объекта
+print(func2(kort))
+```
+_Вывод:_
+```py
+TypeError: 'tuple' object does not support item assignment
+```
+Кортеж не изменится и возникнет ошибка.
+
+## 5.	Специальные типы  пользовательских функций
+#### 5.1. Анонимные функции.
+Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени.
+_Код:_
+```py
+import math
+anfun1 = lambda: 1.5 + math.log10(17.23)  # Анонимная функция без аргументов
+print(anfun1())  # Обращение к объекту-функции
+anfun2 = lambda a, b: a + math.log10(b)  # Анонимная функция с 2 аргументами
+print(anfun2(17, 234))
+anfun3 = lambda a, b=234: a + math.log10(b)  # Функция с необязательным вторым аргументом
+print(anfun3(100))
+```
+_Вывод:_
+```py
+2.7362852774480286
+19.369215857410143
+102.36921585741014
+```
+
+#### 5.2. Функции-генераторы.
+Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. 
+_Код:_
+```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)
+```
+_Вывод:_
+```py
+1
+4
+7
+```
+Здесь при каждом обращении к функции будет генерироваться только одно очередное значение.
+При программировании задач у таких функций часто используют метод __next__, активирующий очередную итерацию выполнения функции. Например:
+_Код:_
+```py
+alp=func5(7,3)
+print(alp.__next__())
+print(alp.__next__())
+print(alp.__next__())
+```
+_Вывод:_
+```py
+1
+4
+7
+```
+попрогбуем вызвать ещё раз
+_Код:_
+```py
+alp=func5(7,3)
+print(alp.__next__())
+print(alp.__next__())
+print(alp.__next__())
+print(alp.__next__())
+```
+_Вывод:_
+```py
+StopIteration
+```
+При четвертом вызове alp.__next__() возникнет ошибка StopIteration, потому что генератор func5(7,3) уже исчерпал все свои значения (1, 4, 7) и не может произвести следующее значение.
+
+## 6.	Локализация объектов в функциях.
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции. Они определены в пространствах имен вне функции.
+Локализация может быть переопределена путем прямого объявления объектов как глобальных с помощью дескриптора __global.__
+
+#### 6.1. Примеры на локализацию объектов
+ Пример 1. Одноименные локальный и глобальный объекты.
+ _Код:_
+ ```py
+ glb=10
+def func7(arg):
+	loc1=15
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+print(res)
+ ```
+_Вывод:_
+```py
+150
+```
+При вычислении результата использовались локальная переменная loc1=15 и глобальная переменная glb=10 (переданная как аргумент arg), результат 150, при этом значение глобальной переменной glb не изменилось и осталось 10, так как внутри функции glb=8 создала новую локальную переменную, а не изменила глобальную.
+
+Пример 2. Ошибка в использовании локального объекта.
+ _Код:_
+ ```py
+def func8(arg):
+	loc1=15
+	print(glb)
+	glb=8
+	return loc1*arg
+
+res=func8(glb)
+print(res)
+ ```
+_Вывод:_
+```py
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+Ошибка возникает потому что Python обнаруживает операцию присваивания glb=8 внутри функции и поэтому считает glb локальной переменной, но при этом выполняется попытка печати значения print(glb) до инициализации этой локальной переменной.
+
+Пример 3. Переопределение локализации объекта
+ _Код:_
+ ```py
+glb=11
+def func7(arg):
+	loc1=15
+	global glb
+	print(glb)
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+print(res)
+ ```
+_Вывод:_
+```py
+11
+165
+```
+Значение изменилось
+
+#### 6.2. Выявление локализации объекта с помощью функций __locals()__ и __globals()__ из __builtins__.
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
+Примеры.
+В командной строке введем инструкции:
+ _Код:_
+ ```py
+print(globals().keys())  #Перечень глобальных объектов
+print(locals().keys())  #Перечень локальных объектов
+ ```
+_Вывод:_
+```py
+#Перечень глобальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 't1', 't2', 't3', 't4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func4_dict', 'a', 'func3', 'sps1', 'func2', 'math', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res'])
+#Перечень локальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 't1', 't2', 't3', 't4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func4_dict', 'a', 'func3', 'sps1', 'func2', 'math', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res'])
+```
+Различий в перечнях нет - в основном режиме выполнения (не внутри функции) глобальная и локальная области видимости совпадают, поэтому globals().keys() и locals().keys() показывают одинаковый набор объектов, так как выполняются в одной области видимости.
+
+_Код:_
+```py
+def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+	return loc1*arg
+
+hh=func8(glb)
+```
+_Вывод:_
+```py
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 't1', 't2', 't3', 't4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func4_dict', 'a', 'func3', 'sps1', 'func2', 'math', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+```
+__Глобальные объекты__ - все переменные модуля уровня
+__Локальные объекты__ - только параметры функции (arg) и переменные, созданные внутри функции (loc1, glb)
+
+Проверка наличия объекта __glb__ в перечне глобальных объектов:
+_Код:_
+```py
+print('glb' in globals().keys())
+```
+_Вывод:_
+```py
+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)
+print(kk)
+```
+_Вывод:_
+```py
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'uspeh', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'typ_fun', 'func', 'a', 'func3', '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__', '__file__', '__cached__', 'uspeh', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'typ_fun', 'func', 'a', 'func3', 'func9'])
+85
+```
+Каждая функция имеет свою локальную область видимости: вложенная функция func9_1 видит только свои локальные объекты (arg1, loc1, glb1) и глобальные объекты модуля, но не видит локальные объекты внешней функции func9 (arg2, arg3, loc1), при этом переменная loc1 существует независимо в обеих функциях со своими значениями.
+
+#### 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)
+```
+_Вывод:_
+```py
+k1,T,k2,Xm,A,F,N=1.5,0.1,0.8,0.2,1.0,10,50
+Входной сигнал: [0.0, 0.5877852522924731, 0.9510565162951535, 0.9510565162951536, 0.5877852522924732, 1.2246467991473532e-16, -0.587785252292473, -0.9510565162951535, -0.9510565162951536, -0.5877852522924734, -2.4492935982947064e-16, 0.5877852522924722, 0.9510565162951535, 0.9510565162951536, 0.5877852522924734, 3.6739403974420594e-16, -0.5877852522924728, -0.9510565162951534, -0.9510565162951538, -0.5877852522924735, -4.898587196589413e-16, 0.5877852522924727, 0.9510565162951529, 0.9510565162951538, 0.5877852522924736, 6.123233995736766e-16, -0.5877852522924726, -0.9510565162951534, -0.9510565162951538, -0.5877852522924737, -7.347880794884119e-16, 0.5877852522924725, 0.9510565162951533, 0.9510565162951539, 0.5877852522924738, 8.572527594031472e-16, -0.5877852522924725, -0.9510565162951533, -0.9510565162951539, -0.5877852522924739, -9.797174393178826e-16, 0.5877852522924695, 0.9510565162951533, 0.9510565162951539, 0.5877852522924769, 1.102182119232618e-15, -0.5877852522924722, -0.9510565162951543, -0.951056516295154, -0.587785252292477]
+y= [0, 0.6015253440351906, 1.096895249493391, 0.14963802472452992, -1.4055603261317517, -2.5023946767056238, -1.3746543603374242, 0.7777548679354078, 2.3930377777245795, 1.589728806501168, -0.18435823514401645, -1.262236228089791, -0.1499221532340092, 1.1432335494953787, 0.9284774407601177, -1.092316839336339, -3.1053851997702706, -1.9708827095800603, 1.4179982683905918, 4.178467267009747, 2.8704598657124154, -0.9554762632284055, -3.6907891747930823, -2.0460936031856565, 1.5516985830908399, 3.050939390566601, 0, -3.803109375076022, -3.7144283665966316, 1.1278012079884292, 6.1915501329945455, 5.067998743352809, -1.4695723076381413, -7.114338992237411, -5.15766901200028, 2.1332451522780023, 6.998570550403378, 3.258668282071149, -4.636620081834843, -7.5743517324240575, -0.7423964478503129, 8.407306390701049, 9.309658304307437, -0.5482852890529228, -11.499859882265268, -10.552533675209967, 2.0050221789726197, 13.153568445829352, 9.570130082024441, -5.115533432227267]
+```
+# Завершение работы

TEMA7/report.py

@@ -0,0 +1,357 @@
+# 2.1
+def uspeh():
+    """Подтверждение успеха операции"""
+    print('Выполнено успешно!')
+
+# Проверьте функцию, запустив ее из командной строки:
+uspeh()
+
+# Определите класс объекта с именем uspeh.
+print(type(uspeh))
+
+if 'uspeh' in dir():
+    print("Функция 'uspeh' присутствует в пространстве имен")
+
+help(uspeh)
+
+# 2.2
+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)
+
+# С символьными строками
+sravnenie("прога", "математика")
+sravnenie("физика", "физика")
+sravnenie("элтех", "элтехи")
+
+# 2.3
+def logistfun(b,a):
+	"""Вычисление логистической функции"""
+	import math
+	return a/(1+math.exp(-b))
+
+v,w=1,0.7;z=logistfun(w,v)
+print(z)
+
+# 2.4
+def slozh(a1,a2,a3,a4):
+	""" Сложение значений четырех аргументов"""
+	return a1+a2+a3+a4
+slozh(1,2,3,4)   # Сложение чисел
+slozh('1','2','3','4')  # Сложение строк
+b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+q=slozh(b1,b2,b3,b4)  #Сложение списков
+print(q)
+
+# Кортежи
+t1 = (1, 2); t2 = (3, 4); t3 = (5,); t4 = (6, 7)
+print(slozh(t1, t2, t3, t4))
+
+# Множества
+#s1 = {1, 2}; s2 = {2, 3}; s3 = {4}; s4 = {1, 5}
+#print(slozh(s1, s2, s3, s4))
+
+# Словари
+#d1 = {'a': 1}; d2 = {'b': 2}; d3 = {'c': 3}; d4 = {'a': 10}
+#print(slozh(d1, d2, d3, d4))
+
+# 2.5
+def inerz(x,T,ypred):
+	""" Модель устройства с памятью:
+	x- текущее значение вх.сигнала,
+	T -постоянная времени,
+	ypred - предыдущее значение выхода устройства"""
+	y=(x+T*ypred)/(T+1)
+	return y
+# Создаем список с измерениями значений входного сигнала – в виде «ступеньки»:
+sps=[0]+[1]*100
+spsy=[] #Заготовили список для значений выхода
+TT=20 #Постоянная времени
+yy=0  #Нулевое начальное условие
+for xx in sps:
+	yy=inerz(xx,TT,yy)
+	spsy.append(yy)
+
+# Выходной сигнал в виде графика
+import matplotlib.pyplot as plt
+plt.figure(figsize=(12, 6))
+
+# График входного сигнала
+plt.subplot(1, 2, 1)
+plt.plot(sps, 'r-', linewidth=2, label='Входной сигнал')
+plt.title('Входной сигнал')
+plt.xlabel('Время, отсчеты')
+plt.ylabel('Амплитуда')
+plt.grid(True, alpha=0.3)
+plt.legend()
+
+# График выходного сигнала
+plt.subplot(1, 2, 2)
+plt.plot(spsy, 'b-', linewidth=2, label='Выходной сигнал')
+plt.title(f'Выходной сигнал (T={TT})')
+plt.xlabel('Время, отсчеты')
+plt.ylabel('Амплитуда')
+plt.grid(True, alpha=0.3)
+plt.legend()
+
+plt.tight_layout()
+plt.show()
+
+# 3.1
+print(dir(inerz))
+print(inerz.__doc__)
+help(inerz)
+
+# 3.2
+fnkt=sravnenie
+v=16
+fnkt(v,23)
+
+# 3.3
+typ_fun=8
+if typ_fun==1:
+	def func():
+		print('Функция 1')
+else:
+	def func():
+		print('Функция 2')
+
+func()
+
+# 4.1
+def fun_arg(fff,a,b,c):
+	"""fff-имя функции, используемой
+	в качестве аргумента функции fun_arg"""
+	return a+fff(c,b)
+
+zz=fun_arg(logistfun,-3,1,0.7)
+print(zz)
+
+# 4.2
+def logistfun(a,b=1):   #Аргумент b – необязательный; значение по умолчанию=1
+	"""Вычисление логистической функции"""
+	import math
+	return b/(1+math.exp(-a))
+
+print(logistfun(0.7))    #Вычисление со значением b по умолчанию
+print(logistfun(0.7,2))  #Вычисление с заданным значением b
+
+# 4.3
+print(logistfun(b=0.5, a=0.8))  # Аргументы поменялись местами
+print(logistfun(a=0.8, b=0.5))  # То же самое, но в другом порядке
+
+# 4.4
+b1234 = [b1, b2, b3, b4]  # Список списков из п.2.4
+qq = slozh(*b1234)  # Перед ссылкой на список или кортеж надо ставить звездочку
+print(qq)
+
+# 4.5
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+print(qqq)
+
+# 4.6
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+print(qqqq)
+
+# 4.7
+def func4(*kort7):
+	"""Произвольное число аргументов в составе кортежа"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return smm
+
+print(func4(-1,2))  #Обращение к функции с 2 аргументами
+print(func4(-1,2,0,3,6))  #Обращение к функции с 5 аргументами
+
+# 4.8
+def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+	"""Кортеж - сборка аргументов - должен быть последним!"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return a*smm+b
+
+print(func4(-1,2,0,3,6))
+
+# Словарь
+def func4_dict(a, b=7, **slovar):  # a-позиционный, b- по умолчанию, **slovar-словарь
+    """Словарь - сборка именованных аргументов - должен быть последним!"""
+    smm = 0
+    for key, value in slovar.items():
+        smm += value
+    return a * smm + b
+
+# Вызов функции:
+print(func4_dict(-1, 2, x=0, y=5, z=6))
+
+# 4.9
+a=90    # Числовой объект – не изменяемый тип
+def func3(b):
+	b=5*b+67
+
+print(func3(a))
+
+# Список
+sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+def func2(sps):
+	sps[1]=99
+print(func2(sps1))
+print(sps1)
+
+# Кортеж
+#kort = (1, 2, 3, 4)  # Кортеж – неизменяемый тип объекта
+#print(func2(kort))
+
+# 5.1
+import math
+anfun1 = lambda: 1.5 + math.log10(17.23)  # Анонимная функция без аргументов
+print(anfun1())  # Обращение к объекту-функции
+anfun2 = lambda a, b: a + math.log10(b)  # Анонимная функция с 2 аргументами
+print(anfun2(17, 234))
+anfun3 = lambda a, b=234: a + math.log10(b)  # Функция с необязательным вторым аргументом
+print(anfun3(100))
+
+# 5.2
+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)
+
+alp=func5(7,3)
+print(alp.__next__())
+print(alp.__next__())
+print(alp.__next__())
+
+# 6.1
+glb=10
+def func7(arg):
+	loc1=15
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+print(res)
+
+'''def func8(arg):
+	loc1=15
+	print(glb)
+	glb=8
+	return loc1*arg	
+
+res=func8(glb)
+print(res)'''
+
+glb=11
+def func7(arg):
+	loc1=15
+	global glb
+	print(glb)
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+print(res)
+
+# 6.2
+print(globals().keys())  #Перечень глобальных объектов
+print(locals().keys())  #Перечень локальных объектов
+
+def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+	return loc1*arg
+
+hh=func8(glb)
+
+print('glb' in globals().keys())
+
+# 6.3
+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)
+print(kk)
+
+# 6.4
+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)
+

TEMA7/task.py

@@ -0,0 +1,60 @@
+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]
+
+# Проверка работы функции
+delay = 3
+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, delay, output_signal, input_history)
+    output_signal.append(y)
+
+print("Входной сигнал:", input_signal)
+print("Выходной сигнал (задержка 3):", output_signal)
+
+
+# 2
+def raschet_giostogrammy(viborka, kol_int):
+    minn = min(viborka)
+    maxx = max(viborka)
+    shirina_intervala = (minn - maxx) / kol_int
+
+    w = [0] * kol_int
+
+    for znachenie in viborka:
+        num_int = int((znachenie - maxx) / shirina_intervala)
+        if num_int == kol_int:
+            num_int = kol_int - 1
+        w[num_int] += 1
+
+    print("Гистограмма:")
+    for i in range(kol_int):
+        start = maxx + i * shirina_intervala
+        end = maxx + (i + 1) * shirina_intervala
+        print(f"[{start:.2f}, {end:.2f}]: {w[i]}")
+
+    return w
+
+
+import random
+
+rand = [random.gauss(0, 1) for _ in range(100)]
+kol_int = 5
+res = raschet_giostogrammy(rand, kol_int)
+
+# 3
+anonim_func = lambda b1, b2, X: b1 + b2 * X
+print(anonim_func (2, 3, 5))

TEMA7/test.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/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,24 @@
+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

@@ -7,3 +7,5 @@ print('tt=',tt)
 from Mod2 import beta
 qq=beta(float(tt))
 print('qq=',qq)
+perm1 = Mod1.perm1*3
+print("perm1*3= ", perm1)

TEMA8/Task.md

@@ -0,0 +1,69 @@
+# Общее контрольное задание по теме 8
+
+Зеленкина Ксения, А-02-23
+
+## Задание
+Разработайте программу, состоящую из трех модулей:
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Получен-ный список должен возвращаться в вызывающую программу.
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. За-тем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы
+
+## Решение
+__Модуль1__
+_Код:_
+```py
+def mod1(filename):
+    numbers = []
+    
+    with open(filename, 'r') as f:
+        for i in f:
+            stroka = i.strip().split()
+            for el in stroka:
+                number = float(el)
+                numbers.append(number)
+    return numbers
+```
+__Модуль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]
+    
+    try:
+        correlation = statistics.correlation(x, y)
+    except statistics.StatisticsError:
+        correlation = 0.0
+    
+    return correlation
+```
+
+__Модуль3__
+_Код:_
+```py
+import TaskMod1
+import TaskMod2
+
+file1 = input("Первый файл: ")
+file2 = input("Второй файл: ")
+
+list1 = TaskMod1.mod1(file1)
+list2 = TaskMod1.mod1(file2)
+
+result = TaskMod2.mod2(list1, list2)
+
+print(f"Коэффициент корреляции: {result:.3f}")
+```
+
+_Вывод:_
+```py
+Первый файл: task1.txt
+Второй файл: task2.txt
+Результат: 0.842
+```

TEMA8/TaskMod1.py

@@ -0,0 +1,10 @@
+def mod1(filename):
+    numbers = []
+    
+    with open(filename, 'r') as f:
+        for i in f:
+            stroka = i.strip().split()
+            for el in stroka:
+                number = float(el)
+                numbers.append(number)
+    return numbers

TEMA8/TaskMod2.py

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

TEMA8/TaskMod3.py

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

TEMA8/Test/Mod1.py

@@ -0,0 +1,26 @@
+import math
+
+f = lambda x, a, b, c, d: a / (1 + math.exp(-b - c * x - d * x * x))
+
+def func1(a, b, c, d):
+    """
+    Рассчитывает значения анонимной функции в диапазоне значений входного параметра х:  -20 ≤ x ≤ 20 
+    с шагом 2 при некоторых положительных значениях параметров a,b,c,d. 
+    """
+    res = []
+    for x in range(-20, 21, 2): 
+        res.append(f(x, a, b, c, d))
+    return res
+
+
+def wf (data, filename):
+    """
+    Записывает данные в файл по 3 значения в строке
+    """
+    with open(filename, 'w') as file:
+        i = 0
+        while i < len(data):
+            a = data[i:i+3]
+            s = list(map(str, a))
+            file.write(" ".join(s) + "\n")
+            i += 3 

TEMA8/Test/Mod2.py

@@ -0,0 +1,17 @@
+import Mod1
+
+print("Введите параметры:")
+a = float(input("a = "))
+b = float(input("b = "))
+c = float(input("c = "))
+d = float(input("d = "))
+
+
+x = -20
+res = Mod1.func1(a, b, c, d)
+for y in res:
+    print(f"f({x}) = {y}")
+    x += 2
+
+filename = input("Имя файла для сохранения: ")
+Mod1.wf(res, filename)

TEMA8/Test/Test.md

@@ -0,0 +1,105 @@
+# Индивидуальные контрольные задания по теме 8
+Зеленкина Ксения А-02-23
+
+## Задача
+_Задание из ЛР 7_
+_(Вариант 11)_ Разработайте анонимную функцию с 5 аргументами: х, a,b,c,d, вычисляющую значение a/(1+exp(-b-c*x-d*x2)). Рассчитайте значения этой функции в диапазоне значений входного па-раметра х:  -20 ≤ x ≤ 20 с шагом 2 при некоторых положительных значениях параметров a,b,c,d. Обеспечьте запись рассчитанных значений в текстовый файл по три значения на строке, разде-ленных пробелами.
+
+## Решение
+Содержимое __Mod1.py__
+```py
+import math
+
+f = lambda x, a, b, c, d: a / (1 + math.exp(-b - c * x - d * x * x))
+
+def func1(a, b, c, d):
+    """
+    Рассчитывает значения анонимной функции в диапазоне значений входного параметра х:  -20 ≤ x ≤ 20 
+    с шагом 2 при некоторых положительных значениях параметров a,b,c,d. 
+    """
+    res = []
+    for x in range(-20, 21, 2): 
+        res.append(f(x, a, b, c, d))
+    return res
+
+
+def wf (data, filename):
+    """
+    Записывает данные в файл по 3 значения в строке
+    """
+    with open(filename, 'w') as file:
+        i = 0
+        while i < len(data):
+            a = data[i:i+3]
+            s = list(map(str, a))
+            file.write(" ".join(s) + "\n")
+            i += 3 
+```
+
+Содержимое __Mod2.py__
+```py
+import Mod1
+
+print("Введите параметры:")
+a = float(input("a = "))
+b = float(input("b = "))
+c = float(input("c = "))
+d = float(input("d = "))
+
+
+x = -20
+res = Mod1.func1(a, b, c, d)
+for y in res:
+    print(f"f({x}) = {y}")
+    x += 2
+
+filename = input("Имя файла для сохранения: ")
+Mod1.wf(res, filename)
+```
+
+_Вывод:_
+```py
+Введите параметры:
+a = 1
+b = 0.5
+c = 0.2
+d = 0.01 
+f(-20) = 0.6224593312018546
+f(-18) = 0.5349429451582144
+f(-16) = 0.4650570548417855
+f(-14) = 0.4158094770645926
+f(-12) = 0.38698582386066444
+f(-10) = 0.3775406687981454
+f(-8) = 0.38698582386066455
+f(-6) = 0.4158094770645926
+f(-4) = 0.4650570548417855
+f(-2) = 0.5349429451582145
+f(0) = 0.6224593312018546
+f(2) = 0.7190996574163839
+f(4) = 0.8115326747861805
+f(6) = 0.8869541699279211
+f(8) = 0.9393460966843479
+f(10) = 0.9706877692486436
+f(12) = 0.9871312358039476
+f(-2) = 0.5349429451582145
+f(0) = 0.6224593312018546
+f(2) = 0.7190996574163839
+f(4) = 0.8115326747861805
+f(6) = 0.8869541699279211
+f(8) = 0.9393460966843479
+f(10) = 0.9706877692486436
+f(12) = 0.9871312358039476
+f(14) = 0.9948315469697114
+f(16) = 0.9980924000956662
+f(18) = 0.9993513704723885
+f(20) = 0.9997965730219448
+Имя файла для сохранения: test
+```
+
+Файл появился. В него записались значения:
+
+<img src = "./photo1.png" width="500" height="300" align="center">
+
+Содержимое файла:
+
+<img src = "./photo2.png" width="500" height="300" align="center">

TEMA8/Test/test

@@ -0,0 +1,7 @@
+0.622459 0.534943 0.465057
+0.415809 0.386986 0.377541
+0.386986 0.415809 0.465057
+0.534943 0.622459 0.719100
+0.811533 0.886954 0.939346
+0.970688 0.987131 0.994832
+0.998092 0.999351 0.999797

TEMA8/report.md

@@ -0,0 +1,592 @@
+# Отчет по Теме 8
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+Начинём сеанс работы с IDLE со следующих инструкций:
+
+```py
+import os,sys,imp    #Импорт трёх важных вспомогательных модулей
+os.chdir('<Путь к рабочему каталогу>')  #Делаем рабочий каталог текущим
+os.getcwd()  #Контролируем корректность установки текущего каталога
+```
+
+_В новых версиях Python вместо модуля imp используется importlib._
+
+## 2. Создание и использование модулей в среде Python.
+Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле .  В языке Python модули также являются объектами класса __module__.
+#### 2.1. Запуск модуля на выполнение путем его импорта.
+
+С помощью текстового редактора оболочки IDLE создайте в своем текущем каталоге  файл с именем Mod1.py и запишите в него программу со следующим содержанием:
+
+_Код:_
+```py
+perm1=input('Mod1:Введите значение = ')
+print('Mod1:Значение perm1=',perm1)
+```
+
+Обратим внимание на заголовок окна редактора с текстом модуля: пока введенный или измененный текст в этом окне не сохранен в файле, в заголовке перед именем файла стоит символ «*». 
+
+Запустим модуль по следующей инструкции:
+_Код:_
+```py
+import Mod1
+```
+
+_Вывод:_
+```py
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+```
+
+Определим класс модуля __Mod1__. 
+_Код:_
+```py
+type(Mod1)
+```
+_Вывод:_
+```py
+<class 'module'>
+```
+
+Получим список атрибутов.
+_Код:_
+```py
+dir(Mod1)
+```
+_Вывод:_
+```py
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+```
+
+Получим доступ к значению созданного в модуле объекта __perm1__ – атрибута модуля __Mod1__ - с помощью инструкции:
+_Код:_
+```py
+Mod1.perm1
+```
+_Вывод:_
+```py
+'5'
+```
+
+Попробуем повторно выполнить модуль с помощью инструкции импорта:
+_Код:_
+```py
+import Mod1
+```
+_Вывод:_
+```py
+(пусто)
+```
+
+Запуск программы не происходит!
+
+Для повторного выполнения ранее импортированного модуля следует применить функцию __reload__ из модуля __imp__/__implib__:
+_Код:_
+```py
+importlib.reload(Mod1)
+```
+_Вывод:_
+```py
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA8\\Mod1.py'>
+```
+Проверим, что это значение стало значением объекта __perm1__.
+_Код:_
+```py
+Mod1.perm1
+```
+_Вывод:_
+```py
+'3'
+```
+#### 2.2 Атрибут sys.modules
+Импортированные модули заносятся в словарь – значение атрибута __sys.modules__.  Их можно увидеть по инструкции
+_Код:_
+```py
+print(sorted(sys.modules.keys()))
+```
+_Вывод:_
+```py
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+Видим в словаре __Mod1__. Для обеспечения возможности повторного импорта и, следовательно, выполнения программы из модуля, его надо удалить из этого словаря:
+
+_Код:_
+```py
+sys.modules.pop('Mod1')
+```
+Еще раз отобразим словарь м убедимся, что модуль __Mod1__ из него исчез.
+_Код:_
+```py
+print(sorted(sys.modules.keys()))
+```
+
+_Вывод:_
+```py
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+__Mod1__ нет в словарь.
+
+Повторим импорт и проверим, что записанная в нем программа будет снова выполнена:
+_Код:_
+```py
+import Mod1
+```
+_Вывод:_
+```py
+Mod1:Введите значение = 4
+Mod1:Значение perm1= 4
+```
+
+_Код:_
+```py
+Mod1.perm1
+```
+_Вывод:_
+```py
+'4'
+```
+Данная программа снова выполнилась. Снова удалим __Mod1__ из словаря:
+
+_Код:_
+```py
+sys.modules.pop('Mod1')
+'Mod1' in sys.modules
+```
+
+_Вывод:_
+```py
+False
+```
+#### 2.3. Запуск модуля на выполнение с помощью функции exec().
+Запуск модуля на выполнение может быть произведен с использованием ранее изученной функции exec. При этом модуль не требуется импортировать. Функция exec действует так, как будто на месте обращения к ней в программу вставлен код из объекта-аргумента функции. 
+__Внимание:__ объект-модуль при этом не создается! Созданные при выполнении модуля объекты становятся объектами главной программы!
+
+_Пример._
+_Код:_
+```py
+exec(open('Mod1.py').read())
+```
+
+Эту функцию можно вызывать любое число раз и каждый раз будет выполняться программа из модуля.
+Попробуем запустить модуль на выполнение 3 раза, каждый раз задавая разные значения в ответ на запрос программы.
+
+_Код:_
+```py
+exec(open('Mod1.py').read())
+```
+_Вывод:_
+```py
+Mod1:Введите значение = 2
+Mod1:Значение perm1= 2
+```
+_Код:_
+```py
+exec(open('Mod1.py').read())
+```
+_Вывод:_
+```py
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+```
+_Код:_
+```py
+exec(open('Mod1.py').read())
+```
+_Вывод:_
+```py
+Mod1:Введите значение = 20
+Mod1:Значение perm1= 20
+```
+Выводим на экран значение объекта perm1.
+ perm1
+_Код:_
+```py
+perm1
+```
+_Вывод:_
+```py
+'20'
+```
+
+#### 2.4 Использование инструкции from … import …
+В одном модуле может содержаться несколько программных единиц (например, функций или пользовательских объектов). Тогда можно осуществлять импорт модуля не целиком, а только часть содержащихся в нем объектов.
+__Пример 1.__
+_Код:_
+```py
+from Mod1 import perm1
+```
+_Вывод:_
+```py
+Mod1:Введите значение = 30
+Mod1:Значение perm1= 30
+```
+
+Проверим, появился ли в памяти объект __Mod1__.
+ _Код:_
+ ```py
+print(sorted(sys.modules.keys()))
+ ```
+ _Вывод:_
+ ```py
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+ ```
+_Код:_
+```py
+perm1
+```
+_Вывод:_
+```py
+'30'
+```
+
+Проверьте, появился ли в памяти объект Mod1?  - ДА
+Вызвалась ли на выполнение программа из этого модуля? - ДА
+Какое значение имеет объект perm1 и почему? - Имеет значение '30'. perm1 имеет значение '30', потому что мы его ввели при выполнении модуля во время импорта.
+ 
+__Пример 1.__
+С помощью текстового редактора создадим еще один модуль __Mod2__, содержащий две функции:
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+Сохраним модуль в текущем каталоге в файле __Mod2.py__.
+Импортируйте из этого модуля только функцию __beta__ с помощью инструкции:
+
+_Код:_
+```py
+from Mod2 import beta
+```
+Теперь можно использовать эту функцию:
+_Код:_
+```py
+g=beta(2)
+```
+_Вывод:_
+```py
+****BETA****
+```
+
+Выведим на экран значение объекта __g__.
+_Код:_
+```py
+g
+```
+_Вывод:_
+```py
+535.4916555247646
+```
+Проверим, появился ли в памяти объект __Mod2__.
+_Код:_
+```py
+print(sorted(sys.modules.keys()))
+```
+_Вывод:_
+```py
+['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_operator', '_pickle', '_queue', '_random', '_sha2', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_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', 'typing.io', 'typing.re', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+Объект __Mod2__ появился.
+ 
+ Убедимся, что функция __alpha__ не была импортирована, попробовав запустить ее на выполнение:
+_Код:_
+```py
+alpha()
+```
+_Вывод:_
+```py
+Traceback (most recent call last):
+  File "<pyshell#71>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+```
+
+_Код:_
+```py
+from Mod2 import alpha as al
+al()
+```
+_Вывод:_
+```py
+****ALPHA****
+Значение t=7
+'7'
+```
+
+Удалим импортированные объекты:
+_Код:_
+```py
+del al,beta
+```
+
+_Код:_
+```py
+from Mod2 import alpha as al, beta as bt
+bt(2)
+al()
+```
+_Вывод:_
+```py
+****BETA****
+535.4916555247646
+****ALPHA****
+Значение t=8
+'8'
+```
+
+Вновь удалим импортированные объекты:
+_Код:_
+```py
+del al,bt
+```
+Теперь сделаем импорт всего содержимого модуля __Mod2__ инструкцией.
+_Код:_
+```py
+from Mod2 import *
+tt=alpha()  
+uu=beta(float(tt))
+```
+
+_Вывод:_
+```py
+****ALPHA****
+Значение t=30
+>> uu=beta(float(tt))
+****BETA****
+>> uu
+8.536711709556478e+40
+```
+
+
+## 3. Создание многомодульных программ.
+#### 3.1. Пример простой многомодульной программы.
+С помощью редактора создадим ещё один модуль:
+```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)
+```
+
+Перед проверкой такой программы удалите из словаря sys.modules имена всех этих модулей.
+
+```py
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA8\\Mod2.py'>
+```
+
+Запустим программу на выполнение инструкцией:
+_Код:_
+```py
+import Mod0
+```
+
+_Вывод:_
+```py
+Mod1:Введите значение = 7
+Mod1:Значение perm1= 7
+perm1= 7
+****ALPHA****
+Значение t=3
+tt= 3
+****BETA****
+qq= 12391.647807916694
+```
+
+Отобразим в командном окне значения объектов, созданных во время выполнения программы:
+_Код:_
+```py
+import Mod0Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+```
+
+_Вывод:_
+```py
+'3'
+12391.647807916694
+'7'
+```
+
+#### 3.2. Еще пример.
+Создадим модуль __MM1__, включив в него (скопировать из текста _темы 7_) разработанные при вы-полнении предыдущей темы функции, реализующие усилитель, реальный двигатель, тахогенера-тор и нелинейное звено типа «зона нечувствительности». Затем создадим модуль __ММ2__, включив в него инструкции, обеспечивающие ввод параметров задачи, формирование входного сигнала, им-порт модуля __ММ1__ и реализацию модели при расчете выходного сигнала:
+
+_Код в MM1:_
+```py
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+    #Модель реального двигателя
+    yp=kk1*xtt  #усилитель
+    yti1=yp+yti1  #Интегратор
+    ytin1=(yti1+TT*ytin1)/(TT+1)
+    return [yti1,ytin1]
+
+def tahogen(xtt,kk2,yti2):
+    #Модель тахогенератора
+    yp=kk2*xtt   #усилитель
+    yti2=yp+yti2 #интегратор
+    return yti2
+
+def nechus(xtt,gran):
+    #зона нечувствительности
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt
+```
+
+_Код в MM2:_
+```py
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1=float(znach[0])
+T=float(znach[1])
+k2=float(znach[2])
+Xm=float(znach[3])
+A=float(znach[4])
+F=float(znach[5])
+N=int(znach[6])
+
+import math
+vhod=[]
+for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+import MM1 as mod
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+	xt1=xt-yi2   #отрицательная обратная связь
+	[yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
+	yi2=mod.tahogen(yin1,k2,yi2)
+	yt=mod.nechus(yin1,Xm)
+	vyhod.append(yt)
+```
+
+Cоздадим главную программу – модуль __ММ0__, запускающую на выполнение модуль __ММ2__ и выводящую полученный выходной сигнал.
+_Код в MM0:_
+```py
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+import MM2
+print('y=',MM2.vyhod)
+```
+
+Запустим модуль:
+_Код:_
+```py
+import MM0
+```
+_Вывод:_
+```py
+k1,T,k2,Xm,A,F,N=2.0,0.5,0.1,0.3,1.0,10,50
+y= [0, 0.4837136697232975, 1.9085317587281618, 3.252580419663127, 3.6116668632828017, 2.337163316303042, -0.017205672773565883, -3.9735974048495555, -7.694183730612065, -9.785915404851563, -9.20619313821322, -5.684780136463871, 0, 6.0648659051821046, 11.557535237484812, 14.327930282057972, 13.456796190056922, 9.053217875186638, 2.2250624360017253, -4.663598684084722, -10.92690153687042, -14.501117759249846, -14.721127718256962, -11.820251893705713, -6.747408907477821, -0.7946360160839683, 4.213684642786436, 8.621001586440592, 11.43851708016392, 12.64532483189202, 12.372900361759408, 10.7013921058286, 7.581031992524821, 2.9269169944267426, -2.5530669165299082, -9.51164521262539, -16.238582611807068, -21.167523715780103, -22.634796225912915, -19.405844689307024, -11.200325508823996, 0.3811399571845728, 14.28146387608062, 26.81054542912841, 34.78344511767276, 35.77611116596963, 28.84817084233142, 14.909243930400418, -2.7945777016815705, -21.65639219491944]
+```
+Колебания с каждым разом становятся все сильнее и сильнее.
+
+
+#### 3.3. Области действия объектов в модулях.
+В ранее созданных модулях вводятся и используются следующие объекты:
+__Mod1: perm1__
+__Mod2:__ функции __alpha, beta;__ переменные __t, expi__
+__Mod0:__ переменные __tt,qq__
+
+Проведите следующие эксперименты:
+- Попробуйте вставить в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
+- Попробуйте отобразить на экране в модуле Mod0 значения объектов t и expi.
+- Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+- Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq.
+
+_Код:_
+```py
+>> import Mod1
+#Модуль Mod0
+import Mod1
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+print(f't = {al.t}, expi = {beta.expi}')
+# Новые строчки:
+perm1 = Mod1.perm1*3
+print("perm1*3= ", perm1)
+```
+
+_Вывод:_
+```py
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=3
+tt= 3
+****BETA****
+qq= 12391.647807916694
+
+Traceback (most recent call last):
+  File "c:\Users\user\OneDrive\Documents\ZelenkinaKs\python-labs\TEMA8\report.py", line 59, in <module>
+    print(f't = {al.t}, expi = {beta.expi}')
+                 ^^^^
+AttributeError: 'function' object has no attribute 't'
+
+perm1*3=  555
+```
+
+При импорте __Mod1__ выполнился его код с вводом значения 5, затем функция __alpha__ вернула tt=3, которая передалась в __beta__ для вычисления __qq__=12391.6, а умножение __perm1__ создало новую переменную со значением 15 в модуле __Mod0__, не изменяя оригинальный __perm1__=5 в модуле __Mod1__.
+
+_Код:_
+```py
+import Mod1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+>> Mod1.perm1
+'5'
+>> Mod1.perm1 = Mod1.perm1 * 2
+>> Mod1.perm1
+'55'
+>> from Mod2 import alpha as al
+>> al()
+****ALPHA****
+Значение t=9
+'9'
+qq= 573502.6262733063
+>> perm1 = perm1*2
+>> tt
+'44'
+>> tt = tt * 2
+'4444'
+>> qq
+	573502.6262733063
+>> qq = qq * 2
+	1147005.2525466126
+
+>> perm1 = 8
+>> perm1 = perm1 * 8
+>> perm1
+64
+```
+
+Переменные из разных модулей и основного кода не связаны между собой. Переменная __Mod1.perm1__ из модуля и __perm1__ в основном коде - это совершенно разные переменные.
+
+__Mod1.perm1__ была строкой "5".
+__tt__ тоже была строка "44"
+__qq__ было числом. 
+__perm1__ в основном коде создалась тоже как число.
+
+# Завершение работы

TEMA8/report.py

@@ -0,0 +1,60 @@
+ # 1
+'''import os,sys,importlib    #Импорт трёх важных вспомогательных модулей(imp - устарел)
+os.chdir('C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA8')  #Делаем рабочий каталог текущим
+os.getcwd()  #Контролируем корректность установки текущего каталога
+
+#Записываем значение "5"
+import Mod1
+print(type(Mod1))
+print(dir(Mod1))
+print(Mod1.perm1)
+
+#Записываем значение "3"
+import Mod1
+importlib.reload(Mod1)
+print(Mod1.perm1)
+
+# 2
+print(sorted(sys.modules.keys()))
+sys.modules.pop('Mod1')
+print(sorted(sys.modules.keys()))
+exec(open('Mod1.py').read())
+exec(open('Mod1.py').read())
+exec(open('Mod1.py').read())
+print(perm1)
+
+from Mod1 import perm1
+print(sorted(sys.modules.keys()))
+print(perm1)
+
+from Mod2 import beta
+g=beta(2)
+print(g)
+print(sorted(sys.modules.keys()))
+print(alpha())
+
+from Mod2 import alpha as al
+print(al())
+del al,beta
+
+from Mod2 import *
+tt=alpha()
+uu=beta(float(tt))
+
+#3
+sys.modules.pop('Mod1')
+sys.modules.pop('Mod2')
+import Mod0
+
+import Mod0Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+'''
+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(f't = {al.t}, expi = {beta.expi}')
+ 

TEMA8/task1.txt

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

TEMA8/task2.txt

@@ -0,0 +1 @@
+12 45 23 67 34 89 56 102 78 145