diff --git a/TEMA7/Figure_okz.png b/TEMA7/Figure_okz.png new file mode 100644 index 0000000..c116694 Binary files /dev/null and b/TEMA7/Figure_okz.png differ diff --git a/TEMA7/report.md b/TEMA7/report.md new file mode 100644 index 0000000..bf7f9c7 --- /dev/null +++ b/TEMA7/report.md @@ -0,0 +1,346 @@ +# Отчет по теме 7 + +Коваленко Дмитрий, А-01-23 + +## 7 Создание пользовательских функций + +## 7.1 Создание пользовательской функции. + +```py +>>> def uspeh(): +... """Подтверждение успеха операции""" +... print('Выполнено успешно!') +... +>>> uspeh() +Выполнено успешно! +>>> dir() +['PS1', 'REPLHooks', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'get_last_command', 'is_wsl', 'original_ps1', 'platform', 'readline', 'sys', 'uspeh'] + +Help on function uspeh in module __main__: + +uspeh() + Подтверждение успеха операции + + +def sravnenie(a,b): + """Сравнение a и b""" + if a>b: + print(a,' больше ',b) + elif a>> n,m=16,5;sravnenie(n,m) +16 больше 5 + +>>> sravnenie('a', ',') +a больше , + +def logistfun(b,a): + """Вычисление логистической функции""" + import math + return a/(1+math.exp(-b)) + +>>> v,w=1,0.7;z=logistfun(w,v) +>>> z +0.6681877721681662 + + +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) +>>> q +[1, 2, -1, -2, 0, 2, -1, -1] + + +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) + +``` + +## 7.2 Функции как объекты. + +```py +>> dir(inerz) +['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] +>>> inerz.__doc__ +' Модель устройства с памятью:\n x- текущее значение вх.сигнала,\n T -постоянная времени,\n ypred - предыдущее значение выхода устройства' + +>>> fnkt=sravnenie +>>> v=16 +>>> fnkt(v,23) +16 меньше 23 + +typ_fun=8 +if typ_fun==1: + def func(): + print('Функция 1') +else: + def func(): + print('Функция 2') + +func() +Функция 2 +``` + +## 7.3 Аргументы функции + +```py +def fun_arg(fff,a,b,c): + """fff-имя функции, используемой + в качестве аргумента функции fun_arg""" + return a+fff(c,b) + +zz=fun_arg(logistfun,-3,1,0.7) + +def logistfun(a,b=1): + """Вычисление логистической функции""" + import math + return b/(1+math.exp(-a)) + +logistfun(0.7) +logistfun(0.7,2) +>>> logistfun(b=0.5,a=0.8) +0.34498724056380625 + + +>>> b1234=[b1,b2,b3,b4] +>>> qq=slozh(*b1234) +>>> qq +[1, 2, -1, -2, 0, 2, -1, -1] + +dic4={"a1":1,"a2":2,"a3":3,"a4":4} +qqq=slozh(**dic4) +>>> qqq +10 + +>>> e1=(-1,6);dd2={'a3':3,'a4':9} +>>> qqqq=slozh(*e1,**dd2) +>>> qqqq +17 + +def func4(*kort7): + """Произвольное число аргументов в составе кортежа""" + smm=0 + for elt in kort7: + smm+=elt + return smm + +>>> func4(-1,2) +1 +>>> func4(-1,2,0,3,6) +10 + + +def func4(a,b=7,*kort7): + """Кортеж - сборка аргументов - должен быть последним!""" + smm=0 + for elt in kort7: + smm+=elt + return a*smm+b + +>>> func4(-1,2,0,3,6) +-7 + +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 + File "", line 2, in func2 +TypeError: 'tuple' object does not support item assignment +``` + +## 7.4 Анонимные функции + +```py +>>> anfun1=lambda: 1.5+math.log10(17.23) +>>> anfun1() +2.7362852774480286 +>>> anfun2=lambda a,b : a+math.log10(b) +>>> anfun2(17,234) +19.369215857410143 +>>> anfun3=lambda a,b=234: a+math.log10(b) +>>> anfun3(100) +102.36921585741014 + +>>> 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 +StopIteration +``` + +## 7.5 Локализация объектов в функциях + +```py +glb=10 +def func7(arg): + loc1=15 + glb=8 + return loc1*arg + +>>> res=func7(glb) +>>> res +150 +>>> glb +10 + +def func8(arg): + loc1=15 + print(glb) + glb=8 + return loc1*arg + +res=func8(glb) +# получаем ошибку, потому что функция не видит глобальную переменную, а локальная ещё не была объявлена + +glb=11 +def func7(arg): + loc1=15 + global glb + print(glb) + glb=8 + return loc1*arg + +>>> res=func7(glb) +11 +>>> glb +8 + +>>> globals().keys() +dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'platform', 'sys', 'readline', 'original_ps1', 'is_wsl', 'REPLHooks', 'get_last_command', 'PS1', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'math', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) +>>> locals().keys() +dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'platform', 'sys', 'readline', 'original_ps1', 'is_wsl', 'REPLHooks', 'get_last_command', 'PS1', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'math', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) + +def func8(arg): + loc1=15 + glb=8 + print(globals().keys()) + print(locals().keys()) + return loc1*arg + +hh=func8(glb) +>>> 'glb' in globals().keys() +True + +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__', 'platform', 'sys', 'readline', 'original_ps1', 'is_wsl', 'REPLHooks', 'get_last_command', 'PS1', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'math', '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__', 'platform', 'sys', 'readline', 'original_ps1', 'is_wsl', 'REPLHooks', 'get_last_command', 'PS1', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'math', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) + +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=float(znach[6]) + + +import math +vhod=[] +for i in range(N): + vhod.append(A*math.sin((2*i*math.pi)/F)) +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 + +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) + + +``` \ No newline at end of file diff --git a/TEMA7/task.md b/TEMA7/task.md new file mode 100644 index 0000000..b5e2253 --- /dev/null +++ b/TEMA7/task.md @@ -0,0 +1,85 @@ +# Общее контрольное задание по теме 7 + +Коваленко Дмитрий, А-01-23 + +## Задание + +• Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.\ +• Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: вы-борка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.\ +• Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х +Y=b1+b2*X +и имеющую аргументы b1, b2 и X. + + +## Решение + +```py +import random + + +def delay_signal(signal, T): + delayed_signal = signal.copy() + if T < len(signal): + delayed_signal = [0] * T + signal[:-T] + else: + delayed_signal = [0] * len(signal) + return delayed_signal + +y = [random.gauss(3, 1.5) for _ in range(10)] +>>> y +[3.855862654001017, 0.5055896775676754, 0.4154450162502199, 6.550103308532915, 2.5329276972223584, 5.199934653811578, 2.7808708229733328, 3.009437226477874, 2.6526954887061165, 2.2993461230571697] + +yd = delay_signal(y, 3) +>>> yd +[0, 0, 0, 3.855862654001017, 0.5055896775676754, 0.4154450162502199, 6.550103308532915, 2.5329276972223584, 5.199934653811578, 2.7808708229733328] + +import matplotlib.pyplot as plt +import numpy as np + +def calculate_histogram(data, num_bins): + min_val, max_val = min(data), max(data) + bins = np.linspace(min_val, max_val, num_bins + 1) + counts = [0] * num_bins + + for value in data: + for i in range(num_bins): + if bins[i] <= value < bins[i + 1]: + counts[i] += 1 + break + if value == max_val: + counts[-1] += 1 + + return counts, bins + +def plot_histogram(data, bins, counts): + plt.hist(data, bins=bins, alpha=0.7, edgecolor='black') + plt.xlabel('Значения выборки') + plt.ylabel('Число элементов') + plt.title('Гистограмма выборки') + plt.show() + +def histo(data, num_bins): + counts, bins = calculate_histogram(data, num_bins) + plot_histogram(data, bins, counts) + return counts + +sample = [random.gauss(random.random(), random.random()) for _ in range(random.randint(1,100))] +intervals = int(input("Введите количество интервалов разбиения: ")) +output = histo(sample, intervals) + +Введите количество интервалов разбиения: 5 +Список с числами элементов в интервалах: [3, 10, 12, 6, 1] + + +linreg = lambda b1, b2, x: b1 + b2 * x +>>> b1 = float(input("Введите коэффициент b1 линейной регрессии: ")) +Введите коэффициент b1 линейной регрессии: 4 +>>> b2 = float(input("Введите коэффициент b2 линейной регрессии: ")) +Введите коэффициент b2 линейной регрессии: 6 +>>> x_val = float(input("Введите значение x: ")) +Введите значение x: 56 +>>> print(linreg(b1, b2, x_val)) +340.0 +``` + +Созданная гистограмма: ![hist](Figure_okz.png) \ No newline at end of file