lab7 is done

3 недель назад · a5d8cf70cb
--- a/TEMA7/figure1.png
+++ b/TEMA7/figure1.png
--- a/TEMA7/report.md
+++ b/TEMA7/report.md
@ -0,0 +1,643 @@
 # Отчёт по ТЕМЕ №7
 Степанищев Виктор, А-03-23
 ## 1. Начало работы
 ```py
 >>> import os
 >>> os.chdir(r"C:\Users\alexv\Desktop\4\python-labs\TEMA7")
 >>> os.getcwd()
 'C:\\Users\\byvs\\Desktop\\4\\python-labs\\TEMA7'
 ```
 ## 2. Создание пользовательских функций.
 ### 2.1. Функция без аргументов.
 ```py
 >>> def uspeh(): # Аргументы отсутствуют
 ...     """Подтверждение успеха операции"""
 ...     print("Выполнено успешно!")
 ...   
 >>> uspeh()
     Выполнено успешно!
 >>> type(uspeh) # Определение класса пользовательской функции
    <class 'function'>
 >>> dir() # Проверка появления имени функции в пространстве имен
    ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
 >>> help(uspeh) # Получение справки о пользовательской функции
    Help on function uspeh in module __main__:
    uspeh()
         Подтверждение успеха операции
 ```
 ### 2.2. Функция с аргументами.
 ```py
 >>> def sravnenie(a, b):
 ...     """Сравнение a и b"""
 ...     if a > b:
 ...         print(a, "больше", b)
 ...     elif a < b:
 ...         print(a, "меньше", b)
 ...     else:
 ...         print(a, "равно", b)
 ...        
 >>> n, m = 16, 5
 >>> sravnenie(n, m)
    16 больше 5
 ```
 ```py
 >>> sravnenie("Text", "Text but bigger")
    Text меньше Text but bigger
 >>> sravnenie("abc", "ABC")
    abc больше ABC
 ```
 ### 2.3. Функция, возвращающая значение.
 ```py
 >>> def logistfun(b, a):
 ...     """Вычисление логистической функции"""
 ...     import math
 ...     return a / (1 + math.exp(-b))
 ...
 >>> v, w = 1, 0.7
 >>> z = logistfun(w, v)
 >>> z
    0.6681877721681662
 ```
 ### 2.4. Функция, работающая с разными типами аргументов.
 ```py
 >>> def slozh(a1, a2, a3, a4):
 ...     """ Сложение значений четырех аргументов"""
 ...     return a1 + a2 + a3 + a4
 ...
 >>> slozh(1, 2, 3, 4)
    10
 >>> slozh("1", "2", "3", "4")
    '1234'
 >>> b1 = [1, 2]; b2 = [-1, -2]; b3 = [0, 2]; b4 = [-1, -1]
 >>> q = slozh(b1, b2, b3, b4)
 >>> q
    [1, 2, -1, -2, 0, 2, -1, -1]
 ```
 Данная функция может работать и с кортежами, но вот при работе со словарями и множествами уже получается ошибка: 
 ```py
 >>> slozh((1, 2), (3, 4), (5, 6), (7, 8)) # Сложение кортежей
    (1, 2, 3, 4, 5, 6, 7, 8)
 >>> slozh({"A" : 1, "B" : 2}, {"C" : 3, "D" : 4}, {"E" : 5, "F" : 6}, {"G" : 7, "H" : 8}) # Сложение словарей
    Traceback (most recent call last):
      File "<pyshell#44>", line 1, in <module>
        slozh({"A" : 1, "B" : 2}, {"C" : 3, "D" : 4}, {"E" : 5, "F" : 6}, {"G" : 7, "H" : 8})
      File "<pyshell#37>", line 3, in slozh
        return a1 + a2 + a3 + a4
    TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
 >>> slozh({1, 2}, {3, 4}, {5, 6}, {7, 8}) # Сложение множеств
    Traceback (most recent call last):
      File "<pyshell#45>", line 1, in <module>
        slozh({1, 2}, {3, 4}, {5, 6}, {7, 8})
      File "<pyshell#37>", line 3, in slozh
        return a1 + a2 + a3 + a4
    TypeError: unsupported operand type(s) for +: 'set' and 'set'
 ```
 ### 2.5. Функция, реализующая некоторую модель.
 ```py
 >>> def inerz(x, T, ypred):
 ...     """Модель устройства с памятью:
 ...     x - текущее значение вх. сигнала,
 ...     T - постоянная времени,
 ...     ypred - предыдущее значение выхода устройства"""
 ...     y = (x + T * ypred) / (T + 1)
 ...     return y
 ...
 >>> sps = [0] + [1] * 100
 >>> spsy = [] # Подготовлен список для значений выходного сигнала
 >>> TT = 20 # Постоянная времени
 >>> yy = 0 # Нулевое начальное условие
 >>> for xx in sps:
 ...     yy = inerz(xx, TT, yy)
 ...     spsy.append(yy)
 ...
 >>> import pylab
 >>> pylab.plot(spsy)
    [<matplotlib.lines.Line2D object at 0x00000215E7CF4950>]
 >>> pylab.xlabel("Время, сек.")
    Text(0.5, 0, 'Время, сек.')
 >>> pylab.ylabel("Выходной сигнал")
 ... Text(0, 0.5, 'Выходной сигнал')
 >>> pylab.grid(True)
 >>> pylab.show()
 ```
 Полученный график выходного сигнала:
 <image src = "figure1.png">
 ## 3. Функции как объекты.
 ### 3.1. Атрибуты объекта-функции.
 Так как функции являются объектами, то у них есть некоторые атрибуты. Получить их список можно с помощью инструкции dir().
 ```py
 >>> dir(inerz) # Получение списка атрибутов объекта-функции
    ['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
 >>> inerz.__doc__ # Использование атрибута объекта-функции
    'Модель устройства с памятью:\n    x - текущее значение вх. сигнала,\n    T - постоянная времени,\n    ypred - предыдущее значение выхода устройства'
 >>> help(inerz) # Получение помощи по объекту-функции
    Help on function inerz in module __main__:
    inerz(x, T, ypred)
        Модель устройства с памятью:
        x - текущее значение вх. сигнала,
        T - постоянная времени,
        ypred - предыдущее значение выхода устройства
 ```
 #### 3.2. Ссылка на объект-функцию.
 Ссылку на объект-функцию можно присваивать переменным, а затем обращаться к ним как к самой функции:
 ```py
 >>> fnkt = sravnenie
 >>> v = 16
 >>> fnkt(v, 23)
 >>> 16 меньше 23
 ```
 #### 3.3. Альтернативное определение функций.
 Функции могут быть определены разным образом в зависимости от особенностей реализации кода:
 ```py
 >>> typ_fun = 8
 >>> if typ_fun == 1:
 ...     def func():
 ...         print("Функция 1")
 ... else:
 ...     def func():
 ...         print("Функция 2")
 ...       
 >>> func()
    Функция 2
 ```
 ## 4. Аргументы функции.
 ### 4.1. Использование фунции в качестве аргумента.
 В качестве аргумента функции может выступать и другая функция:
 ```py
 >>> def fun_arg(fff, a, b, c):
 ...     """fff - имя функции, используемой в качестве аргумента"""
 ...     return(a + fff(c, b))
 ...
 >>> zz = fun_arg(logistfun, -3, 1, 0.7)
 >>> zz
    -2.3318122278318336
 ```
 ### 4.2. Обязательные и необязательные аргументы.
 Аргументы функции могут быть необязательными, т.е. иметь некоторое значение, заданное по умолчанию:
 ```py
 >>> def logistfun(a, b = 1):
 ...     """Вычисление логистической функции"""
 ...     import math
 ...     return b / (1 + math.exp(-a))
 ... 
 >>> logistfun(0.7)
    0.6681877721681662
 >>> logistfun(0.7, 2)
    1.3363755443363323
 ```
 ### 4.3. Расположение аргументов функции.
 К функции можно обращаться с произвольным (непозиционным) расположением аргументов, при этом необходимо указывать их имена:
 ```py
 >>> logistfun(b = 0.5, a = 0.8)
    0.34498724056380625
 >>> logistfun(0.8, 0.5)
    0.34498724056380625
 ```
 ### 4.4. Аргументы функции, содержащиеся в списке или кортеже.
 Аргументы функции могут содержаться в списке или кортеже, в таком случае при их передаче в функцию необходима распаковка с помощью оператора " __*__ ".
 ```py
 >>> b1234 = [b1, b2, b3, b4]
 >>> slozh(*b1234)
    [1, 2, -1, -2, 0, 2, -1, -1]
 >>> slozh(b1, b2, b3, b4)
    [1, 2, -1, -2, 0, 2, -1, -1]
 ```
 ### 4.5. Аргументы функции, содержащиеся в словаре.
 Аналогичная ситуация происходит и с аргументами, представленными в виде словаря. Однако распаковка в таком случае проводится с помощью оператора " __**__ ". Важно также заметить, что имена ключей словаря с аргументами не должны совпадать с именами остальных переданных аргументов, иначе произойдет ошибка.
 ```py
 >>> dic4 = {"a1" : 1, "a2" : 2, "a3" : 3, "a4" : 4}
 >>> slozh(**dic4)       
    10
 ```
 ### 4.6. Смешанные ссылки.
 Данные способы передачи аргументов в функцию можно комбинировать:
 ```py
 >>> e1 = (-1, 6)      
 >>> dd2 = {"a3" : 3, "a4" : 4}
 >>> slozh(*e1, **dd2)        
    12
 ```
 ### 4.7. Переменное число аргументов у функции.
 Число аргументов у функции может быть произвольным, что осуществляется с помощью того же оператора " __*__ ".
 ```py
 >>> def func4(*kort7):
 ...     """Произвольное число элементов в составе кортежа"""
 ...     smm = 0
 ...     for el in kort7:
 ...         smm += el
 ...     return smm
 ... 
 >>> func4(-1, 2)
    1
 >>> func4(-1, 2, 0, 3, 6)
    10
 ```
 ### 4.8. Комбинация аргументов.
 Данные способы передачи аргументов также можно комбинировать:
 ```py
 >>> def func4(a, b = 7, *kort7):
 ...     """Кортеж - сборка аргументов - должен быть последним!"""
 ...     smm = 0
 ...     for el in kort7:
 ...         smm += el
 ...     return a * smm + b
 ... 
 >>> func4(-1, 2, 0, 3, 6)
    -7
 ```
 Пример реализации аналогичной функции для произвольного количества аргументов, переданного в виде словаря:
 ```py
 >>> def func4(a, b = 7, **dict7):
 ...     """Словарь - сборка аргументов - должен быть последним!"""
 ...     smm = 0
 ...     for el in dict7.values():
 ...         smm += el
 ...     return a * smm + b
 ... 
 >>> func4(-1, 2, **{"a1" : 0, "a2" : 3, "a3" : 6})
    -7
 ```
 ### 4.9. Изменение значений объектов с помощью функций.
 С помощью функций можно изменять значения переменных - объектов изменяемого типа:
 ```py
 >>> a = 90
 >>> def func3(b):
 ...     b = 5 * b + 67
 ...  
 >>> func3(a)
 >>> a # Числовой объект является неизменяемым
    90
 >>> sps1 = [1, 2, 3, 4]
 >>> def func2(sps):
 ...     sps[1] = 99
 ...    
 >>> func2(sps1)
 >>> sps1 # Список - изменяемый объект
    [1, 99, 3, 4]
 >>> kort = (1, 2, 3, 4)
 >>> func2(kort) # Кортеж также является неизменяемым
    Traceback (most recent call last):
      File "<pyshell#55>", line 1, in <module>
        func2(kort)
      File "<pyshell#51>", line 2, in func2
        sps[1] = 99
    TypeError: 'tuple' object does not support item assignment
 ```
 ## 5. Специальные типы пользовательских функций.
 ### 5.1. Анонимные функции.
 Анонимные функции - лямбда-функциями - это функции без имени , определяемые по следующей схеме:<br>
 __lambda [[<Список аргументов >]]: <Возвращаемое значение или выражение>__<br>
 __lambda [<Список аргументов >]: <Возвращаемое значение или выражение>__<br>
 Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
 ```py
 >>> anfun1 = lambda: 1.5 + math.log10(12.23)
 >>> anfun1()
    2.5874264570362855
 >>> anfun2 = lambda a, b: a + math.log10(b)
 >>> anfun2(17, 234)
    19.369215857410143
 >>> anfun3 = lambda a, b = 234: a + math.log10(b)
 >>> anfun3(100)
    102.36921585741014
 ```
 ### 5.2. Функции-генераторы.
 Функции-генераторы - функции, использующиеся в итерационных процессах, позволяющие на каждой из итераций получать значение с помощью инструкции __yield__, приостанавливающей выполнение функции.
 ```py
 >>> def func5(diap, shag):
 ...     """Итератор, возвращающий значения из диапазона от 1 до diap с шагом shag"""
 ...     for i in range(1, diap + 1, shag):
 ...         yield i
 ...       
 >>> for mm in func5(7, 3):
 ...     print(mm)
 ...   
    1
    4
    7
 ```
 При работе с такими функциями часто используют метод __/_/_next/_/___, активирующий очередную итерацию выполнения функции:
 ```py
 >>> alp = func5(7, 3)
 >>> print(alp.__next__())
    1
 >>> print(alp.__next__())
    4
 >>> print(alp.__next__())
    7
 >>> print(alp.__next__()) # При отсутствии следующих итераций будет ошибка
    Traceback (most recent call last):
      File "<pyshell#78>", line 1, in <module>
        print(alp.__next__())
    StopIteration
 ```
 ## 6. Локализация объектов.
 По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции. Они определены в пространствах имен вне функции.
 ### 6.1. Примеры на локализацию объектов в функциях.
 Локальный и глобальный объекты могут иметь одинаоковое имя:
 ```py
 >>> glb = 10
 >>> def func7(arg):
 ...     loc1 = 15
 ...     glb = 8
 ...     return loc1 * arg
 ... 
 >>> func7(glb)
    150
 >>> glb # Значение не измени лось, т.к. операции проводились над локальной переменной
    10
 ```
 При использовании локального объекта до его определения будет ошибка:
 ```py
 >>> def func8(arg):
 ...     loc1 = 15
 ...     print(glb)
 ...     glb = 8
 ...     return loc1 * arg
 ... 
 >>> func8(glb)
    Traceback (most recent call last):
       File "<pyshell#97>", line 1, in <module>
         func8(glb)
       File "<pyshell#96>", line 3, in func8
         print(glb)
     UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
 ```
 Локализацию объекта можно переопределить с помощью дескриптора __global__:
 ```py
 >>> glb = 11
 >>> def func7(arg):
 ...     loc1 = 15
 ...     global glb
 ...     print(glb)
 ...     glb = 8
 ...     return loc1 * arg
 ... 
 >>> func7(glb)
    11
    165
 >>> glb # Значение изменилось, т.к. была переопределена локализация объекта
    8
 ```
 ### 6.2. Функции для выявления локализации объектов.
 Чтобы узнать текущую локализацию объекта можно использовать функции __globals()__ и __locals()__, которые возвращают словари с ключами - именами объектов, являющихся, соответственно, глобальными или локальными на уровне вызова этих функций.
 ```py
 >>> globals().keys()
    dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
 >>> locals().keys()
    dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
 ```
 Пример просмотра локальных и глобальных объектов изнутри функциии:
 ```py
 >>> def func8(arg):
 ...     loc1 = 15
 ...     glb = 8
 ...     print(globals().keys())
 ...     print(locals().keys())
 ...     return loc1 * arg
 ... 
 >>> func8(glb)
    dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
    dict_keys(['arg', 'loc1', 'glb'])
    150
 >>> "glb" in globals().keys()
    True
 ```
 ### 6.3. Локализация объектов во вложенных функциях.
 Локальные переменные будут различаться на разных уровнях вложенных функций:
 ```py
 >>> def func9(arg2, arg3):
 ...     def func9_1(arg1):
 ...         loc1 = 15
 ...         glb1 = 8
 ...         print("glob_func9_1:", globals().keys())
 ...         print("locl_func9_1:", locals().keys())
 ...         return loc1 * arg1
 ...     loc1 = 5
 ...     glb = func9_1(loc1)
 ...     print("glob_func9:", globals().keys())
 ...     print("locl_func9:", locals().keys())
 ...     return arg2 + arg3 * glb
 ... 
 >>> func9(10, 1)
    glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8', 'func9'])
    locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
    glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8', 'func9'])
    locl_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
    85
 ```
 ### 6.4. Моделирование некоторой системы с помощью нескольких функций.
 Моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа "зона нечувствительности", при подаче на нее синусоидального входного сигнала.
 Этап 1 - запрос и обработка введенных параметров системы:
 ```py
 >>> znach = input("k1, T, k2, Xm, A, F, N = ").split(",")
 >>> k1, T, k2, Xm, A, F, N = 7, 4, 2, 5, 2, 0.01, 100
 >>> 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])
 ```
 Этап 2 - реализация входного сигнала:
 ```py
 >>> import math
 >>> vhod = []
 >>> for i in range(N):
 ...     vhod.append(A * math.sin((2 * i * math.pi) / F))
 ...
 >>> vhod
    [0.0, 7.857546894913888e-15, 1.5715093789827776e-14, -2.038010347584904e-13, 3.143018757965555e-14, -6.428332918551267e-13, -4.076020695169808e-13, -1.081865548951763e-12, ..., -7.666359036382766e-12, -6.521633112271693e-12, -5.376907188160619e-12, -1.8784096492416397e-11, -3.0874553399384703e-12]
 ```
 Этап 3 - создание функций, реализующих компоненты системы:
 ```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):
 ...         return 0
 ...     elif xtt >= gran:
 ...         return xtt - gran
 ...     elif xtt <= (-gran):
 ...         return xtt + gran
 ```
 Этап 4 - соединение компонент в соответствии с заданием и получение выходного сигнала:
 ```py
 >>> yi1 = 0; yin1 = 0; yi2 = 0
 >>> vyhod = []
 >>> for xt in vhod:
 ...     xt1 = xt - yi2
 ...     [yi1, yin1] = realdvig(xt1, k1, T, yi1, yin1)
 ...     yi2 = tahogen(yin1, k2, yi2)
 ...     yt = nechus(yin1, Xm)
 ...     vyhod.append(yt)
 ...    
 >>> print("y =", vyhod)
    y = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2.0750309723388316, 0, -12.800524758874488, 11.328734010636943, 37.9986846091337, -51.695128234754044, -93.73359277523646, 176.80628109766909, 206.3512386278131, -546.6832050741272, -399.06819555417735, 1598.4573240949626, 604.2307443815814, -4487.243599090263, -296.234076116122, 12162.217953139934, -2805.586281370296, -31870.75393905672, 17036.29869407474, 80623.4912164512, -69802.97975583967, -195996.03820751337, 245998.54033834403, 453751.31553486304, -796405.0354457049, -982958.5881199688, 2433666.144586724, 1918572.300755354, -7113910.846421458, -3041359.0662945407, 20031038.041300073, 2216408.8952286365, -54513798.16041583, 10262153.3054456, 143509014.33326405]
 ```
 ## 7. Завершение работы со средой.
 Сохранил файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.
--- a/TEMA7/task.md
+++ b/TEMA7/task.md
@ -0,0 +1,101 @@
 # Общее контрольное задание по теме 7
 Степанищев Виктор, А-03-23
 ## Задание
 1.Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
 2.Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
 3.Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика 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)
 Входной сигнал: [1, 2, 3, 4, 5, 6, 7]
 print("Выходной сигнал (задержка 3):", output_signal)
 Выходной сигнал (задержка 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)
 Гистограмма:
 [2.17, 1.24]: 12
 [1.24, 0.32]: 26
 [0.32, -0.61]: 33
 [-0.61, -1.54]: 22
 [-1.54, -2.47]: 7
 ```
 ### 3 задание
 ```py
 anonim_func = lambda b1, b2, X: b1 + b2 * X
 print(anonim_func (2, 3, 5))
 17
 ```