diff --git a/TEMA7/6.4.py b/TEMA7/6.4.py new file mode 100644 index 0000000..a4749de --- /dev/null +++ b/TEMA7/6.4.py @@ -0,0 +1,61 @@ +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]) + +print(f"Параметры системы: k1={k1}, T={T}, k2={k2}, Xm={Xm}") +print(f"Входной сигнал: A={A}, F={F}, N={N}") + +# Создание входного сигнала (синусоида) +vhod = [] +for i in range(N): + vhod.append(A * math.sin((2 * i * math.pi) / F)) + +print("Входной сигнал:", vhod[:10]) # Покажем первые 10 значений + +# Функции компонентов системы +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) diff --git a/TEMA7/Figure_1.png b/TEMA7/Figure_1.png new file mode 100644 index 0000000..013df20 Binary files /dev/null and b/TEMA7/Figure_1.png differ diff --git a/TEMA7/control.py b/TEMA7/control.py new file mode 100644 index 0000000..2f6d711 --- /dev/null +++ b/TEMA7/control.py @@ -0,0 +1,176 @@ +def signal_delay(input_signal, delay_time): + """ + Реализация устройства задержки сигнала + + Args: + input_signal: список входного сигнала + delay_time: время задержки (количество тактов) + + Returns: + list: задержанный сигнал + """ + # Инициализируем выход нулями для первых delay_time тактов + output = [0] * delay_time + + # Добавляем входной сигнал со сдвигом + output.extend(input_signal[:-delay_time] if delay_time > 0 else input_signal) + + return output + +# Проверка функции задержки +print("=== ПРОВЕРКА ФУНКЦИИ ЗАДЕРЖКИ ===") +test_signal = [1, 2, 3, 4, 5, 6, 7, 8] +delay = 3 +delayed_signal = signal_delay(test_signal, delay) + +print(f"Исходный сигнал: {test_signal}") +print(f"Задержка: {delay} тактов") +print(f"Задержанный сигнал: {delayed_signal}") + +# Визуализация +import matplotlib.pyplot as plt +plt.figure(figsize=(10, 4)) +plt.plot(test_signal, 'bo-', label='Входной сигнал', markersize=8) +plt.plot(delayed_signal, 'ro-', label=f'Выход (задержка {delay})', markersize=6) +plt.title('Устройство задержки сигнала') +plt.xlabel('Время (такты)') +plt.ylabel('Амплитуда') +plt.legend() +plt.grid(True, alpha=0.3) +plt.show() + +def calculate_histogram(data, num_bins): + """ + Расчет гистограммы для выборки данных + + Args: + data: список значений выборки + num_bins: количество интервалов разбиения + + Returns: + tuple: (границы интервалов, частоты) + """ + if not data: + return [], [] + + min_val = min(data) + max_val = max(data) + bin_width = (max_val - min_val) / num_bins + + # Создаем границы интервалов + bins = [min_val + i * bin_width for i in range(num_bins + 1)] + + # Инициализируем счетчики + frequencies = [0] * num_bins + + # Подсчитываем элементы в каждом интервале + for value in data: + for i in range(num_bins): + if bins[i] <= value < bins[i + 1]: + frequencies[i] += 1 + break + else: + # Обработка максимального значения + if value == bins[-1]: + frequencies[-1] += 1 + + return bins, frequencies + +def print_histogram_table(bins, frequencies): + """Вывод гистограммы в виде таблицы""" + print("\nГИСТОГРАММА:") + print("Интервал\t\tКоличество элементов") + print("-" * 45) + + for i in range(len(frequencies)): + lower = bins[i] + upper = bins[i + 1] + count = frequencies[i] + print(f"{lower:8.3f} - {upper:8.3f}\t\t{count:4d}") + + total = sum(frequencies) + print("-" * 45) + print(f"Всего:\t\t\t\t{total:4d}") + +# Проверка функции гистограммы +print("\n=== ПРОВЕРКА ФУНКЦИИ ГИСТОГРАММЫ ===") +import random + +# Генерируем тестовые данные (нормальное распределение) +test_data = [random.gauss(0, 1) for _ in range(1000)] +bins, freq = calculate_histogram(test_data, 10) + +print_histogram_table(bins, freq) + +# Визуализация гистограммы +plt.figure(figsize=(12, 5)) + +plt.subplot(1, 2, 1) +plt.hist(test_data, bins=10, alpha=0.7, edgecolor='black') +plt.title('Гистограмма (matplotlib)') +plt.xlabel('Значение') +plt.ylabel('Частота') +plt.grid(True, alpha=0.3) + +plt.subplot(1, 2, 2) +# Рисуем нашу гистограмму +bin_centers = [(bins[i] + bins[i+1])/2 for i in range(len(bins)-1)] +plt.bar(bin_centers, freq, width=(bins[1]-bins[0])*0.8, + alpha=0.7, edgecolor='black') +plt.title('Наша гистограмма') +plt.xlabel('Значение') +plt.ylabel('Частота') +plt.grid(True, alpha=0.3) + +plt.tight_layout() +plt.show() + +# Анонимная функция для расчета линейной регрессии +linear_regression = lambda b1, b2, X: b1 + b2 * X + +# Проверка анонимной функции +print("\n=== ПРОВЕРКА АНОНИМНОЙ ФУНКЦИИ ЛИНЕЙНОЙ РЕГРЕССИИ ===") + +# Тестовые параметры модели +b1_test = 2.5 # intercept +b2_test = 1.8 # slope +X_values = [0, 1, 2, 3, 4, 5] + +print(f"Параметры модели: b1 = {b1_test}, b2 = {b2_test}") +print("Расчет значений Y = b1 + b2*X:") +print("X\tY") +print("-" * 12) + +for X in X_values: + Y = linear_regression(b1_test, b2_test, X) + print(f"{X}\t{Y:.2f}") + +# Визуализация линейной регрессии +plt.figure(figsize=(10, 6)) + +# Генерируем больше точек для плавного графика +X_smooth = [i/10 for i in range(0, 51)] +Y_smooth = [linear_regression(b1_test, b2_test, x) for x in X_smooth] + +plt.plot(X_smooth, Y_smooth, 'b-', linewidth=2, label=f'Y = {b1_test} + {b2_test}*X') +plt.plot(X_values, [linear_regression(b1_test, b2_test, x) for x in X_values], + 'ro', markersize=8, label='Расчетные точки') + +plt.title('Линейная регрессия: Y = b1 + b2*X') +plt.xlabel('X') +plt.ylabel('Y') +plt.legend() +plt.grid(True, alpha=0.3) +plt.show() + +# Дополнительная проверка с разными параметрами +print("\n=== ПРОВЕРКА С РАЗНЫМИ ПАРАМЕТРАМИ ===") +test_cases = [ + (0, 1, 10), # Y = X + (5, 0.5, 10), # Y = 5 + 0.5*X + (-2, 2, 10) # Y = -2 + 2*X +] + +for b1, b2, X in test_cases: + Y = linear_regression(b1, b2, X) + print(f"b1={b1}, b2={b2}, X={X} -> Y = {Y}") diff --git a/TEMA7/report.md b/TEMA7/report.md new file mode 100644 index 0000000..c89634f --- /dev/null +++ b/TEMA7/report.md @@ -0,0 +1,445 @@ +# Отчёт по теме 7. Создание пользовательских функций + +Выполнил Огарков Илья, А-03-23 + +## 1. Начало работы + +Создание текстового файла `report.md` + +import os +os.getcwd() +'C:\\Users\\Ilya\\AppData\\Local\\Programs\\Python\\Python313' +os.chdir('C:\\Users\\Ilya\\Desktop\\python-labs\\TEMA7') +os.getcwd() +'C:\\Users\\Ilya\\Desktop\\python-labs\\TEMA7' + + +## 2. Создание пользовательской функции +2.1. Первый пример: функция – без аргументов + + +def uspeh(): + """Подтверждение успеха операции""" + print('Выполнено успешно!') + +uspeh() +Выполнено успешно! +type(uspeh) + +dir(uspeh) +['__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__'] + +help(uspeh) +Help on function uspeh in module __main__: + +uspeh() + Подтверждение успеха операции + +2.2. Пример функции с аргументами + +def sravnenie(a,b): + """Сравнение a и b""" + if a>b: + print(a,' больше ',b) + elif a", line 1, in + slozh(d1,d2,d3,d4) + File "", line 3, in slozh + return a1+a2+a3+a4 +TypeError: unsupported operand type(s) for +: 'dict' and 'dict' +s1={1,2};s2={3,4};s3={5,6};s4={7,8} +slozh(s1,s2,s3,s4) +Traceback (most recent call last): + File "", line 1, in + slozh(s1,s2,s3,s4) + File "", line 3, in slozh + return a1+a2+a3+a4 +TypeError: unsupported operand type(s) for +: 'set' and 'set' + +2.5. + +def inerz(x,T,ypred): + """ Модель устройства с памятью: +x- текущее значение вх.сигнала, +T -постоянная времени, +ypred - предыдущее значение выхода устройства""" + y=(x+T*ypred)/(T+1) + return y + +sps=[0]+[1]*100;sps +[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, 1] +spsy=[] +TT=20 +yy=0 +for xx in sps: + yy=inerz(xx,TT,yy) + spsy.append(yy) + + +3. Функции как объекты. +3.1. Получение списка атрибутов объекта-функции. + +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__ #__doc__ - атрибут, который выводит документационную строку (docstring) функции +'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства' +help(inerz) +Help on function inerz in module __main__: + +inerz(x, T, ypred) + Модель устройства с памятью: + x- текущее значение вх.сигнала, + T -постоянная времени, + ypred - предыдущее значение выхода устройства + +3.2. Сохранение ссылки на объект-функцию в другой переменной + +fnkt=sravnenie +v=16 +fnkt(v,23) +16 меньше 23 + +3.3. Возможность альтернативного определения функции в программе + +typ_fun=8 +if typ_fun==1: + def func(): + print('Функция 1') +else: + def func(): + print('Функция 2') + +func() +Функция 2 + + +4. Аргументы функции +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);zz +-2.3318122278318336 + +4.2. Обязательные и необязательные аргументы + +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. Изучите возможность обращения к функции с произвольным (непозиционным) расположением аргументов + +logistfun(b=0.5,a=0.8) +0.34498724056380625 + +4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже + +b1234=[b1,b2,b3,b4] +qq=slozh(*b1234) ;qq # Оператор * распаковывает элементы +[1, 2, -1, -2, 0, 2, -1, -1] +uslovniy_list = [1,2,3,4] +slozh(*uslovniy_list) +10 + +4.5. Пример со значениями аргументов функции, содержащимися в словаре + +dic4={"a1":1,"a2":2,"a3":3,"a4":4} +qqq=slozh(**dic4);qqq # Распаковываем значения словаря +10 +qqq_usl=slozh(*dic4);qqq_usl # Распаковываем ключи словаря +'a1a2a3a4' + +4.6. Смешанные ссылки + +e1=(-1,6);dd2={'a3':3,'a4':9} +qqqq=slozh(*e1,**dd2) +qqqq +17 + +4.7. Переменное число аргументов у функции + +def func4(*kort7): + """Произвольное число аргументов в составе кортежа""" + smm=0 + for elt in kort7: + smm+=elt + return smm + +func4(-1,2) +1 +func4(-1,2,0,3,6) +10 + +4.8. Комбинация аргументов + +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 + +4.9. Изменение значений объектов, используемых в качестве аргументов функции + +a=90 +def func3(b): + a=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] + +5. Специальные типы пользовательских функций +5.1. Анонимные функции. + +anfun1=lambda: 1.5+math.log10(17.23) +anfun1() +2.7362852774480286 +anfun2(17,234) +19.369215857410143 +anfun3=lambda a,b=234: a+math.log10(b) +anfun3(100) +102.36921585741014 + +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) +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. Примеры на локализацию объектов + +glb=10 +def func7(arg): + loc1=15 + glb=8 + return loc1*arg + +res=func7(glb);res +150 + +def func8(arg): + loc1=15 + print(glb) + glb=8 + return loc1*arg + +res=func8(glb);res +Traceback (most recent call last): + File "", line 1, in + res=func8(glb);res + File "", line 3, in func8 + print(glb) +UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value + +glb=11 +def func7(arg): + loc1=15 + global glb + print(glb) + glb=8 + return loc1*arg +res=func7(glb);res +11 +165 + +6.2. Выявление локализации объекта с помощью функций locals() и globals() из builtins + +globals().keys() +dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) +locals().keys() +dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'anfun1', 'math', 'anfun2', 'anfun3', '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) +dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) +dict_keys(['arg', 'loc1', 'glb']) +hh +120 +'glb' in globals().keys() +True + +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) +glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '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__', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) + +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]) + +print(f"Параметры системы: k1={k1}, T={T}, k2={k2}, Xm={Xm}") +print(f"Входной сигнал: A={A}, F={F}, N={N}") + +# Создание входного сигнала (синусоида) +vhod = [] +for i in range(N): + vhod.append(A * math.sin((2 * i * math.pi) / F)) + +print("Входной сигнал:", vhod[:10]) # Покажем первые 10 значений + +# Функции компонентов системы +def realdvig(xtt, kk1, TT, yti1, ytin1): + """Модель реального двигателя""" + yp = kk1 * xtt # усилитель + yti1 = yp + yti1 # Интегратор + ytin1 = (yti1 + TT * ytin1) / (TT + 1) # Инерционное звено + return [yti1, ytin1] + +def tahogen(xtt, kk2, yti2): + """Модель тахогенератора""" + yp = kk2 * xtt # усилитель + yti2 = yp + yti2 # интегратор + return yti2 + +def nechus(xtt, gran): + """Зона нечувствительности""" + if xtt < gran and xtt > (-gran): + ytt = 0 + elif xtt >= gran: + ytt = xtt - gran + elif xtt <= (-gran): + ytt = xtt + gran + return ytt + +# Моделирование системы +yi1 = 0 # состояние интегратора двигателя +yin1 = 0 # состояние инерционного звена +yi2 = 0 # состояние интегратора тахогенератора + +vyhod = [] # выход системы + +for xt in vhod: + xt1 = xt - yi2 # отрицательная обратная связь + [yi1, yin1] = realdvig(xt1, k1, T, yi1, yin1) + yi2 = tahogen(yin1, k2, yi2) + yt = nechus(yin1, Xm) + vyhod.append(yt) + +print('Выход системы y=', vyhod) +k1,T,k2,Xm,A,F,N=1,2,3,4,5,6,7 +Параметры системы: k1=1.0, T=2.0, k2=3.0, Xm=4.0 +Входной сигнал: A=5.0, F=6.0, N=7 +Входной сигнал: [0.0, 4.330127018922193, 4.330127018922194, 6.123233995736766e-16, -4.330127018922193, -4.330127018922193, -1.2246467991473533e-15] +Выход системы y= [0, 0, 0, 0, -3.430711797903516, -4.909726376383112, 0] + + + + + + + +