diff --git a/TEMA7/figure1.png b/TEMA7/figure1.png new file mode 100644 index 0000000..12f6694 Binary files /dev/null and b/TEMA7/figure1.png differ diff --git a/TEMA7/report.md b/TEMA7/report.md new file mode 100644 index 0000000..ba1bc32 --- /dev/null +++ b/TEMA7/report.md @@ -0,0 +1,974 @@ +\# Отчет по теме 7 + +Бережков Дмитрий, А-01-23 + +\## 1.Начало работы, настройка текущего каталога + +```py + +>>> import os + +>>> os.chdir('C:\\\\MPEI\\\\PO\_ASY\\\\BerezhkovGit\\\\python-labs\\\\Tema7') + +``` + +\## 2. Создание пользовательской функции + +\# 2.1 Функция без аргументов + +```py + +>>> def uspeh(): + +... """Подтверждение успеха операции""" + +... print('Выполнено успешно!') + +... + +>>> uspeh() + +Выполнено успешно! + +>>> type(uspeh) + + + +>>> 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>> n,m=16,5;sravnenie(n,m) + +16 больше 5 + +>>> n,m='3', '5';sravnenie(n,m) + +3 меньше 5 + +``` + +Функцию можно выполнить с аргументами в виде символьной строки. + + + +\# 2.3 Функция, содержащая return + +```py + +>>> def logistfun(b,a): + +... """Вычисление логистической функции""" + +... import math + +... return a/(1+math.exp(-b)) + +>>> v,w=1,0.7;z=logistfun(w,v) + +>>> z + +0.6681877721681662 + +``` + +\# 2.4 Сложение для разных типов аргументов + +```py + +>>> def slozh(a1,a2,a3,a4): + +... """ Сложение значений четырех аргументов""" + +... return a1+a2+a3+a4 + +... + +>>> slozh(1,2,3,4) # Сложение чисел + +10 + +>>> slozh('1','2','3','4') # Сложение строк + +'1234' + +>>> b1=\[1,2];b2=\[-1,-2];b3=\[0,2];b4=\[-1,-1] + +>>> q=slozh(b1,b2,b3,b4) #Сложение списков + +>>> qq + +>>> 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 "", line 1, in + +  slozh({"A" : 1, "B" : 2}, {"C" : 3, "D" : 4}, {"E" : 5, "F" : 6}, {"G" : 7, "H" : 8}) # Сложение словарей + +  File "", 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 "", line 1, in + +  slozh({1, 2}, {3, 4}, {5, 6}, {7, 8}) # Сложение множеств + +  File "", 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) + +\[] + +>>> pylab.xlabel("Время, сек.") + +Text(0.5, 0, 'Время, сек.') + +>>> pylab.ylabel("Выходной сигнал") + +Text(0, 0.5, 'Выходной сигнал') + +>>> pylab.grid(True) + +>>> pylab.show() + +``` + +Полученный график: + + + + + + + +\## 3. Функции как объекты + +\# 3.1 Атрибуты объекта-функции + +```py + +>>> dir(inerz) + +\['\_\_annotations\_\_', '\_\_builtins\_\_', '\_\_call\_\_', '\_\_class\_\_', '\_\_closure\_\_', '\_\_code\_\_', '\_\_defaults\_\_', '\_\_delattr\_\_', '\_\_dict\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_get\_\_', '\_\_getattribute\_\_', '\_\_getstate\_\_', '\_\_globals\_\_', '\_\_gt\_\_', '\_\_hash\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_', '\_\_kwdefaults\_\_', '\_\_le\_\_', '\_\_lt\_\_', '\_\_module\_\_', '\_\_name\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_qualname\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_', '\_\_setattr\_\_', '\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', '\_\_type\_params\_\_'] + +>>> inerz.\_\_doc\_\_ # Использование атрибута объекта-функции + +'Модель устройства с памятью:\\nx- текущее значение вх.сигнала,\\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-имя функции, используемой + +... в качестве аргумента функции fun\_arg""" + +... return a+fff(c,b) + +... + +>>> zz=fun\_arg(logistfun,-3,1,0.7) + +>>> zz + +-2.3318122278318336 + +``` + +\# 4.2 Обязательные и необязательные аргументы + +```py + +>>> def logistfun(a,b=1): #Аргумент b – необязательный; значение по умолчанию=1 + +... """Вычисление логистической функции""" + +... import math + +... return b/(1+math.exp(-a)) + +... + +>>> logistfun(0.7) #Вычисление со значением b по умолчанию + +0.6681877721681662 + +>>> logistfun(0.7,2) #Вычисление с заданным значением b + +1.3363755443363323 + +``` + +\## 4.3 Обращения к функции с произвольным (непозиционным) расположением аргументов + +```py + +>>> logistfun(b=0.5,a=0.8) # Ссылки на аргументы поменялись местами + +0.34498724056380625 + +``` + +\## 4.4 Аргументы функции, содержащиеся в списке или кортеже + +```py + +>>> b1234=\[b1,b2,b3,b4] # Список списков из п.2.4 + +>>> qq=slozh(\*b1234) #Перед ссылкой на список или кортеж надо ставить звездочку + +>>> qq + +\[1, 2, -1, -2, 0, 2, -1, -1] + +``` + +\## 4.5 Аргументы функции, содержащиеся в словаре + +```py + +>>> dic4={"a1":1,"a2":2,"a3":3,"a4":4} + +>>> qqq=slozh(\*\*dic4) #Перед ссылкой на словарь надо ставить две звездочки + +>>> qqq + +10 + +``` + +\## 4.6 Смешанные ссылки + +```py + +>>> e1=(-1,6);dd2={'a3':3,'a4':9} + +>>> qqqq=slozh(\*e1,\*\*dd2) + +>>> qqqq + +17 + +``` + +\## 4.7 Переменное число аргументов у функции + +```py + +>>> def func4(\*kort7): + +... """Произвольное число аргументов в составе кортежа""" + +... smm=0 + +... for elt in kort7: + +... smm+=elt + +... return smm + +... + +>>> func4(-1,2) #Обращение к функции с 2 аргументами + +1 + +>>> func4(-1,2,0,3,6) #Обращение к функции с 5 аргументами + +10 + +``` + +\## 4.8 Комбинация аргументов + +```py + +>>> def func4(a,b=7,\*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж + +... """Кортеж - сборка аргументов - должен быть последним!""" + +... smm=0 + +... for elt in kort7: + +... smm+=elt + +... return a\*smm+b + +... + +>>> func4(-1,2,0,3,6) + +-7 + +``` + +```py + +>>> def func4(a, b = 7, \*\*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) + +>>> print(sps1) + +\[1, 99, 3, 4] + +>>> kort=(1,2,3,4) #Кортеж – неизменяемый тип объекта + +>>> func2(kort) + +Traceback (most recent call last): + +  File "", line 1, in + +  func2(kort) + +  File "", line 2, in func2 + +  sps\[1]=99 + +TypeError: 'tuple' object does not support item assignment + +``` + +\# 5. Специальные типы пользовательских функций. + +\## 5.1 Анонимные функции + + + +Анонимные функции - лямбда-функциями - это функции без имени , определяемые по следующей схеме: + +lambda <Список аргументов >: <Возвращаемое значение или выражение> + +lambda \[<Список аргументов >]: <Возвращаемое значение или выражение> + +Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту. + + + +```py + +>>> import math + +>>> anfun1=lambda: 1.5+math.log10(17.23) #Анонимная функция без аргументов + +>>> anfun1() # Обращение к объекту-функции + +2.7362852774480286 + +>>> anfun2=lambda a,b : a+math.log10(b) #Анонимная функция с 2 аргументами + +>>> anfun2(17,234) + +19.369215857410143 + +>>> anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом + +>>> anfun3(100) + +102.36921585741014 + +``` + +\## 5.2 Функции-генераторы + +Функции-генераторы – функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. Для этого в функцию включают инструкцию yield приостанавливающую её выполнение и возвращающую очередное значение. + +```py + +>>> def func5(diap,shag): + +... """ Итератор, возвращающий значения + +... из диапазона от 1 до diap с шагом shag""" + +... for j in range(1,diap+1,shag): + +... yield j + +... + +>>> for mm in func5(7,3): + +... print(mm) + +... + +1 + +4 + +7 + +>>> 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 "", line 1, in + +  print(alp.\_\_next\_\_()) + +StopIteration + +``` + +Выводится ошибка, потому что функция отработала все итерации. + + + +\# 6. Локализация объектов + +\## 6.1 Примеры на локализацию объектов + +```py + +>>> glb=10 + +>>> def func7(arg): + +... loc1=15 + +... glb=8 + +... return loc1\*arg + +... + +>>> res=func7(glb) + +>>> res + +150 + +>>> glb + +10 + +>>> + +``` + +```py + +>>> def func8(arg): + +... loc1=15 + +... print(glb) + +... glb=8 + +... return loc1\*arg + +>>> res=func8(glb) + +Traceback (most recent call last): + +  File "", line 1, in + +  res=func8(glb) + +  File "", line 3, in func8 + +  print(glb) + +UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value + +``` + +Причина ошибки: использование локального объекта до его определения. + + + +```py + +>>> glb=11 + +>>> def func7(arg): + +... loc1=15 + +... global glb + +... print(glb) + +... glb=8 + +... return loc1\*arg + +... + +>>> res=func7(glb) + +11 + +>>> res + +165 + +>>> glb + +8 + +``` + +Значение изменилось, т.к. была переопределена локализация объекта. + + + +\# 6.2 Функции для выявления локализации объектов + +```py + +>>> def func8(arg): + +... loc1=15 + +... glb=8 + +... print(globals().keys()) #Перечень глобальных объектов «изнутри» функции + +... print(locals().keys()) #Перечень локальных объектов «изнутри» функции + +... return loc1\*arg + +... + +>>> hh=func8(glb) + +dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) + +dict\_keys(\['arg', 'loc1', 'glb']) + +>>> 'glb' in globals().keys() + +True + +``` + +\# 6.3 Локализация объектов при использовании вложенных функций + +```py + +>>> def func9(arg2,arg3): + +... def func9\_1(arg1): + +... loc1=15 + +... glb1=8 + +... print('glob\_func9\_1:',globals().keys()) + +... print('locl\_func9\_1:',locals().keys()) + +... return loc1\*arg1 + +... loc1=5 + +... glb=func9\_1(loc1) + +... print('loc\_func9:',locals().keys()) + +... print('glob\_func9:',globals().keys()) + +... return arg2+arg3\*glb + +... + +>>> kk=func9(10,1) + +glob\_func9\_1: dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) + +locl\_func9\_1: dict\_keys(\['arg1', 'loc1', 'glb1']) + +loc\_func9: dict\_keys(\['arg2', 'arg3', 'func9\_1', 'loc1', 'glb']) + +glob\_func9: dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) + +>>> kk + +85 + +``` + +\# 6.4 Моделирование некоторой системы с помощью нескольких функций + + + +Запрос и обработка введенных параметров + + + +```py + +>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',') + +k1,T,k2,Xm,A,F,N=5,2,7,1,3,0.1,50 + +>>> k1=float(znach\[0]) + +>>> T = float(znach\[1]) + +>>> k2 = float(znach\[2]) + +>>> Xm = float(znach\[3]) + +>>> A = float(znach\[4]) + +>>> F = float(znach\[5]) + +>>> N = int(znach\[6]) + +``` + +Реализация входного сигнала + + + +```py + +>>> import math + +>>> vhod=\[] + +>>> for i in range(N): + +... vhod.append(A\*math.sin((2\*i\*math.pi)/F)) + +... + +>>> vhod + +\[0.0, -7.34788079488412e-15, -1.469576158976824e-14, -6.467620653025836e-14, -2.939152317953648e-14, -1.6463709641123863e-13, -1.2935241306051673e-13, -9.406772970979485e-14, -5.878304635907296e-14, -2.3498363008351057e-14, -3.2927419282247726e-13, -2.9398950947175535e-13, -2.5870482612103345e-13, 1.1764037039453651e-13, -1.881354594195897e-13, -4.939112892337158e-13, -1.1756609271814592e-13, -8.228140936742402e-14, -4.6996726016702114e-14, -6.938330689956763e-13, -6.585483856449545e-13, 5.885732403546355e-14, -5.879790189435107e-13, -5.526943355927888e-13, -5.174096522420669e-13, -4.82124968891345e-13, 2.3528074078907303e-13, -4.115556021899013e-13, -3.762709188391794e-13, -3.409862354884575e-13, -9.878225784674317e-13, -9.525378951167099e-13, -2.3513218543629184e-13, -8.819685284152661e-13, -1.6456281873484803e-13, -8.113991617138223e-13, -9.399345203340423e-14, -7.408297950123785e-13, -1.3876661379913526e-12, -6.702604283109348e-13, -1.317096771289909e-12, -1.9639331142688832e-12, 1.177146480709271e-13, -5.291216949080472e-13, -1.1759580378870214e-12, -4.585523282066034e-13, -1.1053886711855776e-12, -3.879829615051596e-13, -1.0348193044841338e-12, -1.6816556474631084e-12] + +``` + +Создание функций, реализующих компоненты системы + + + +```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): + +... ytt=0 + +... elif xtt>=gran: + +... ytt=xtt-gran + +... elif xtt<=(-gran): + +... ytt=xtt+gran + +... return ytt + +``` + +Соединение компонент в соответствии с заданием и получение выходного сигнала + + + +```py + +>>> yi1=0;yin1=0;yi2=0 + +>>> vyhod=\[] + +>>> for xt in vhod: + +... xt1=xt-yi2 #отрицательная обратная связь + +... \[yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1) + +... yi2=tahogen(yin1,k2,yi2) + +... yt=nechus(yin1,Xm) + +... vyhod.append(yt) + +... + +... + +>>> print('y=',vyhod) + +y= \[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.6089539155942427, -13.036146587349938, 121.44813795602693, -1067.2095969566972, 9317.816619654644, -81294.22842535547, 709200.0106510338, -6186906.685120374, 53973168.988947384, -470849610.29481155, 4107584498.8890133, -35833629291.65392, 312604400058.94775, -2727089409189.0786, 23790505329708.062, -207542936412563.75, 1810557189004300.2, -1.579488751252292e+16, 1.3779099221408792e+17, -1.2020571542715681e+18, 1.0486472148269562e+19, -9.148158864631634e+19, 7.980644913680371e+20, -6.962132400705417e+21, 6.073605340072578e+22, -5.298474620106407e+23, 4.622268278560269e+24, -4.032361306008378e+25, 3.517739932494396e+26, -3.0687959965857205e+27, 2.677147557631607e+28, -2.335482401993116e+29, 2.037421521451343e+30, -1.7774000148879483e+31] + +``` + + + + + + + + + + + + + + + + + + + + + diff --git a/TEMA7/task.md b/TEMA7/task.md new file mode 100644 index 0000000..b1cfe16 --- /dev/null +++ b/TEMA7/task.md @@ -0,0 +1,118 @@ +\# Общее контрольное задание по теме 7 + +Бережков Дмитрий А-01-23 + +\## Задание: + +1\.Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т. + + + +2\.Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения. + + + +3\.Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х + +Y=b1+b2\*X + +и имеющую аргументы b1, b2 и X. + + + +\## Решение: + +1\. + +```py + +>>> def crDelay(x,T): + +... """Функция для реализации задержки сигнала в определенный момент времени x - исходный сигнал T - заданная задержка""" + +... return\[0] \*T+x + +... + +>>> x=\[1,2,3,4] + +>>> y=crDelay(x,4) + +>>> print(y) + +\[0, 0, 0, 0, 1, 2, 3, 4] + +``` + +2\. + +```py + +>>> def raschet\_gistogrammy(viborka,kol\_int): + +... Min=min(viborka) + +... Max=max(viborka) + +... shirina\_int=(Max-Min)/kol\_int + +... x=\[0]\*kol\_int + +... for znach in viborka: + +... num\_int=int((znach-Max)/shirina\_int) + +... if num\_int == kol\_int: + +... num\_int = kol\_int - 1 + +... x\[num\_int] += 1 + +... print("Гистограмма:") + +... for i in range(kol\_int): + +... start = Max + i \* shirina\_int + +... end = Max + (i + 1) \* shirina\_int + +... print(f"\[{start:.2f}, {end:.2f}]: {x\[i]}") + +... return x + +... + +>>> import random + +>>> rand=\[random.gauss(0, 1) for \_ in range(100)] + +>>> kol\_int=5 + +res = raschet\_gistogrammy(rand, kol\_int) + +Гистограмма: + +\[2.31, 3.30]: 8 + +\[3.30, 4.30]: 5 + +\[4.30, 5.30]: 21 + +\[5.30, 6.29]: 44 + +\[6.29, 7.29]: 22 + +``` + +3\. + +```py + +anonim\_f = lambda b1, b2, X: b1 + b2 \* X + +print(anonim\_f(3,8,2)) + +19 + +``` +