From 046ca688502a250b9596ccc6626464c2fc547499 Mon Sep 17 00:00:00 2001 From: TimoshenkoAA Date: Sat, 25 Oct 2025 11:22:23 +0000 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5?= =?UTF-8?q?=D0=BD=20=D0=BE=D1=82=D1=87=D0=B5=D1=82=20=D0=9B=D0=A07?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA7/report.md | 743 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 743 insertions(+) create mode 100644 TEMA7/report.md diff --git a/TEMA7/report.md b/TEMA7/report.md new file mode 100644 index 0000000..aae06c3 --- /dev/null +++ b/TEMA7/report.md @@ -0,0 +1,743 @@ +# Тема 7. Создание пользовательских функций +Выполнил: Тимошенко А.А. +Проверил: Козлюк Д.А. + +# Пункт 1. +``` +>>> import os +>>> os.chdir("C:/Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА7") +``` +# Пункт 2. Создание пользовательской функции. + +Общий вид: +def <Имя функции>([<Список аргументов >]): +[<отступы> """<Комментарий по назначению функции>"""] +<отступы> <Блок инструкций – тело функции> +[<отступы> return <Значение или вычисляемое выражение>] + +Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем +в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то +выполнение функции прекращается с возвратом значения, следующего за этой инструкцией. +В Python, если функция не содержит оператора return, она автоматически возвращает значение +None. + +## Пункт 2.1. Функция без аргументов. +``` +>>> def uspeh(): + """Подтверждение успеха операции""" + print('Выполнено успешно!') +>>> uspeh() +Выполнено успешно! +``` +Функция является объектом класса function: +``` +>>> type(uspeh) + +``` +Видно, что такой объект появился в рабочем пространстве: +``` +>>> dir() +['__annotations__', '__builtins__', + '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh'] +``` +Вызовем помощь по этой функции: +``` +>>> help(uspeh) +Help on function uspeh in module __main__: + +uspeh() + Подтверждение успеха операции +``` +Видно, что help вернуло имя функции и то описание, которое было указано в тройных кавычках +при её определении. Это называется docstring или документ-строка. Они используются +для написания документации. Она должна быть первой строкой внутри блока. + +## Пункт 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) +16 больше 5 +``` +Так как при описании функции мы не конкретизировали, какой тип данных хотим получить, то +python сможет принять любые данные, которые можно сравнить. Если что-то нельзя сравнить, +вернется TypeError. +``` +>>> sravnenie("house", "building") +house больше building +``` +## Пункт 2.3. Функция с return. +``` +>>> 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. Сложение для разных типов аргументов. +``` +>>> 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] +``` +Для кортежей: +``` +>>> slozh((1, 2), (3, 4), (-5, 0), (-7, -3)) +(1, 2, 3, 4, -5, 0, -7, -3) +``` +Для множеств: +``` +>>> slozh({1,1,1,1}, {2}, {"hehe", True, None}, {6, 6, "a"}) +... +TypeError: unsupported operand type(s) for +: 'set' and 'set' +``` +Как видно, операция сложения для множеств не применима. Если нужно объединить два множества, +для этого есть специальная операция set union вида set1 | set2 | set3 + +Для словарей: +``` +>>> dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4} +>>> slozh(dict1, dict2, dict3, dict4) +... +TypeError: unsupported operand type(s) for +: 'dict' and 'dict' +``` +Словари тоже нельзя сложить плюсом. Для объединения словарей есть оператор распаковывания +**dict1. + +Комбинирование типов: +``` +Число и строка: +>>> slozh(1, "а", 2, "б") +... +TypeError: unsupported operand type(s) for +: 'int' and 'str' +``` +С коллекциями без явного преобразования тоже не сработает. + +Число и логический тип: +``` +>>> slozh(1, True, 2, False) +4 +``` +Целое число и число с плавающей точкой: +``` +>>> slozh(1, 3.44, 2.0, 7) +13.44 +``` +## Пункт 2.5. Функция, реализующая модель некоторого устройства, +на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y: +``` +>>> 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 as plt +>>> plt.plot(spsy, label = "Выходной сигнал") +[] +>>> plt.show() +``` +График сохранен в файле с именем Figure_1. + + +# Пункт 3. Функции как объекты. + +## Пункт 3.1. Получение списка атрибутов объекта-функции. +``` +>>> 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__ +' Модель устройства с памятью:\nx- текущее значение вх.сигнала,\n\tT -постоянная времени,\n\typred - предыдущее значение выхода устройства' +>>> help(inerz) +Help on function inerz in module __main__: +```` +Этот атрибут содержит значение docstring, если при инициализации функции она была задана. +Если не была, то inerz.__doc__ будет иметь значение None. +```` +inerz(x, T, ypred) + Модель устройства с памятью: + x- текущее значение вх.сигнала, + T -постоянная времени, + ypred - предыдущее значение выхода устройства +``` +Примеры других атрибутов функций: +``` +>>> def f(a : int, b : int, c = 10): + return + +>>> f.__annotations__ +{'a': , 'b': } # Возвращает типы аргументов, если они заданы + +>>> f.__defaults__ # Возвращает значения по умолчанию, если они заданы +(10,) +>>> f.__name__ # Возвращает имя функции (для функций, определенных внутри других, возвращает +полный путь +'f' +``` +## Пункт 3.2. Сохранение ссылки на объект-функцию в другой переменной. +``` +>>> n, m = 16, 5; sravnenie(n, m) +16 больше 5 +>>> fnkt = sravnenie +>>> v = 16 +>>> fnkt(v, 23) +16 меньше 23 +``` +Здесь происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в +переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую +функцию, что и sravnenie. + +## Пункт 3.3. Возможность альтернативного определения функции в программе. +``` +>>> typ_fun = 8 +>>> if typ_fun == 1: + def func(): + print("Функция 1") + + +>>> if typ_fun == 1: + def func(): + print('Функция 1') +else: + def func(): + print('Функция 2') + +>>> func() +Функция 2 +``` +Программа выводит сообщение "Функция 2", потому что переменная typ_fun не равна 1, и +выполняется блок else, в котором функция 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) +>>> print(zz) +-2.3318122278318336 +``` +Python передаёт ссылку на объект функции logistfun в переменную fff. Внутри +функции выполняется операция: a + fff(c, b), что эквивалентно -3 + logistfun(0.7, 1) + +## Пункт 4.2. Обязательные и необязательные аргументы. +``` +>>> def logistfun(a,b=1): #Аргумент 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 +``` +Но при этом нельзя сделать так: +``` +>>> logistfun(b = 2, 0.7) +SyntaxError: positional argument follows keyword argument +``` +Python ожидает, что все позиционные аргументы будут переданы первыми, а затем уже +могут следовать именованные аргументы. + +## Пункт 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже. +``` +>>> b1234 = [b1, b2, b3, b4] +>>> b1234 +[[1, 2], [-1, -2], [0, 2], [-1, -1]] +>>> qq = slozh(*b1234) +>>> qq +[1, 2, -1, -2, 0, 2, -1, -1] +``` +Со звёздочкой коллекции передаются как набор аргументов функции, Она также называется +"оператор распаковки". Это было бы эквивалентно записи slozh(b1,b2,b3,b4) + +## Пункт 4.5. Пример со значениями аргументов функции, содержащимися в словаре +``` +>>> dic4 = {"a1": 1, "a2": 2, "a3": 3, "a4": 4} +>>> qqq = slozh(**dic4) +>>> qqq +10 +``` +В данном случае распаковка произошла так, что ключи на входе функции восприниимаются как +значения позиционных переменных, а значения, соответственно, как значения. + +Примечание: Если поставить только одну звездочку, python попытается интерпретировать +ключи, а не значения словаря как позиционные аргументы. Получается так: +``` +>>> slozh(*dic4) +'a1a2a3a4' +``` +## Пункт 4.6. Смешанные ссылки +``` +>>> e1 = (-1, 6); dd2 = {'a3': 3, 'a4': 9} +>>> qqqq = slozh(*e1,**dd2) +>>> qqqq +17 +То есть (-1) + 6 + 3 + 9 = 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): #Аргументы: a - позиционный, b - по умолчанию + кортеж + """Кортеж - сборка аргументов - должен быть последним!""" + smm=0 + for elt in kort7: + smm += elt + return a * smm + b + +>>> func4(-1,2,0,3,6) +-7 +``` +То есть -1 * 9 + 2 = -7. + +Если захочется НЕ передавать b, придется переопределить функцию так, чтобы +именованный параметр b был в конце, а позиционный кортеж - перед ним. Например, +так: +``` +>>> def func4(a, *kort7, b = 7): + smm = 0 + for elt in kort7: + smm += elt + return a * smm + b + +>>> func4(5, *[1, 2, 3]) +37 +``` +Примечание: + +В общем виде *args и **kwargs - способы передать не уточненное заранее число +элементов, причем: + + *args — переменное количество позиционных аргументов. Переданные с одной + звездочкой аргументы собираются в кортеж. + + **kwargs — переменное количество именованных аргументов. Все переданные аргументы, + которые указываются по имени, собираются в словарь. + + Как и всегда, *args всегда должно идти перед **kwargs. + +## Пункт 4.9. Изменение значений объектов, используемых в качестве аргументов функции. +``` +>>> a = 90 +>>> def func3(b): + b = 5*b+67 + + +>>> func3(a) +>>> a +90 +``` +Поскольку функция ничего не возвращает (то есть, формально, является процедурой), то вычисленное +значение b = 5*b+67 существует только локально внутри нее и не выносится в глобальную область видимости +Для наглядности: +``` +>>> def func3(b): + b = 5*b+67 + print(b) + + +>>> func3(a) +517 +>>> a +90 +``` +Пример со списком: +``` +>>> sps1=[1,2,3,4] +>>> def func2(sps): + sps[1] = 99 +>>> func2(sps1) +>>> print(sps1) +[1, 99, 3, 4] +``` +В отличие от предыдущего примера с переменной численного типа, список передается по ссылке, а не по +значению, поэтому изменяется именно тот объект, который был передан. +Для наглядности: +``` +>>> def func3(b): + b = 5*b+67 + print(id(b)) + +>>> func3(a) +1832324289488 +>>> id(a) +140726606630600 # Разные адреса + +>>> def func3(b): + b = 5*b+67 + print(id(b)) + +>>> func3(a) +1832324289488 +>>> id(a) +1832324289488 # Одинаковые адреса +``` +Кортеж: +``` +>>> 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. Анонимные функции (лямбда-функции). +``` +>>> anfun1 = lambda: 1.5 + math.log10(17.23) +>>> type(anfun1) + + +>>> 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 +``` +Вызов лямбда-функции создает объект класса "функция", который потом можно положить в другую переменную +и далее вызывать. Но это делать необязательно: если она используется один раз, можно вызвать ее сразу, +например: +``` +>>> r = (lambda a, b: a**2 + b)(5, 2) # Это результат функции, а не объект класса "функция" +>>> r +27 +``` +Внутри лямбда-функции не могут использоваться многострочные выражения, например: +``` +>>> r1 = lambda: (for i in range(5): print(i)) +SyntaxError: invalid syntax +``` +Но при этом: +``` +>>> r1 = lambda: (print(i) for i in range(5)) +>>> +``` +Аналогично нельзя использовать if-else, но можно использовать тернарный оператор. + +## Пункт 5.2. Функции-генераторы + +Иногда в циклах на каждой итерации нужно получать одно из значений. Для этого есть оператор yield. +Это похоже на return, но в отличие от return не останавливает полностью выполнение программы. +Когда выполнение генератора возобновляется после yield, оно продолжается с того места, где было +приостановлено, до следующего оператора yield (или до конца функции). +Вместе с yield, можно использовать next(). Например: +``` +>>> def test(): + for i in range(3): + yield i + + +>>> l = test() +>>> l + +>>> next(l) +0 +>>> next(l) +1 +``` +Аналогично, можно использовать и метод __next__ +``` +>>> print(l.__next__()) +2 +``` +Другой пример: +``` +>>> alp=func5(7,3) +>>> print(alp.__next__()) +1 +>>> print(alp.__next__()) +5 +>>> print(alp.__next__()) +4 +... +``` +__next__ помогает вывести значение, которое yield передает на каждй итерации цикла. Если функция +отработала последнюю итерацию, но мы все попытаемся сделать вызов, вернется ошибка: +``` +>>> 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 +``` +Проверим: +``` +>>> glb +10 +``` +Посмотрим подробнее, что происходит внутри функции: +``` +>>> def func7(arg): + loc1=15 + glb=8 + print(glb, arg) + return loc1*arg + +>>> res=func7(glb) +8 10 +``` +Видно, что внутри объект с именем glb принял значение 8, но глобальная переменная при этом после выполнения +функции значения не поменяла. Это происходит потому, что технически, локальный glb и глобальный glb - +это два разных объекта. В этом можно убедиться: +``` +>>> res=func7(glb) #При определенении func7 добавлена строка print(id(glb)) +8 10 +>>> id(glb) +140726606628040 +``` +Пример 2. +``` +>>> 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: local variable 'glb' referenced before assignment +``` +Ошибка возникает, потому что когда python видит внутри функции переменную, он по умолчанию считает ее +локальной. И получается, что вызов локальной переменной glb происходит раньше объявления локальной +переменной glb, на что нам и указывает ошибка. Можно исправить эту проблему, переопределив лоаклизацию +glb внутри func8(): +``` +>>> glb=11 +>>> def func7(arg): + loc1=15 + global glb + print(glb) + glb=8 + return loc1*arg + +>>> res=func7(glb) +11 +>>> glb +8 +``` +Здесь мы явно указали, что в функции имеем в виду глобальную переменную, так что она изменилась. + +## Пункт 6.2. locals() и globals() + +Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, +локальными или глобальными на уровне вызова этих функций. +``` +>>> globals().keys() +dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8']) +>>> locals().keys() +dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8']) +``` +Сейчас различий нет, потому что эти методы возвращают объекты на уровне вызова этих функций, но мы +вызвали обе самом внешнем уровне, не внутри какой-либо функции, а в самом рабочем пространстве, где +локальная и глобальная области видимости совпадают. +``` +>>> glb = 10 +>>> def func8(arg): + loc1=15 + glb=8 + print(globals().keys()) #Перечень глобальных объектов «изнутри» функции + print(locals()) #Перечень локальных объектов «изнутри» функции (для наглядности отобразим и значения тоже) + 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', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8']) +{'arg': 10, 'loc1': 15, 'glb': 8} +>>> glb # Снова глобальное glb +10 +``` +## Пункт 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__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) +locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1']) # Содержит только объекты, определенные внутри func9 +а также объект, переданный как аргумент функции + +loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb']) # Содержит все то же, что и locl_func9_1, но еще и arg3, переданный func9, и саму func9_1 + +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', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) +``` +## Пункт 6.4. Моделирование САУ +``` +>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',') +k1,T,k2,Xm,A,F,N=8,5,3,10,2,0.5,1000 +>>> 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]) +>>> vhod=[] +>>> for i in range(N): + vhod.append(A*math.sin((2*i*math.pi)/F)) + +>>> vhod +[0.0, -9.797174393178826e-16, -1.959434878635765e-15, -2.9391523179536475e-15, -3.91886975727153e-15, + -4.898587196589413e-15, -5.878304635907295e-15, -6.858022075225178e-15, + ... + 1.1010469343064857e-13, + -8.856348540728095e-13, -1.8813744015762676e-12, 7.608648580119871e-13, -2.3487468949147107e-13, -1. + 2306142369949293e-12, -2.226353784498387e-12, 4.1588547508986746e-13, -5.798540724135906e-13, + -1.5755936199170489e-12] + +>>> 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) +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, 0, 0, -1.0183086292055208, 0, 26.39885775889784, + -36.65029553691161, -34.19982663883278, 196.29963397615063, -151.6919482160481, + -388.32493988337274, 1057.8073200868555, -308.3186572590445, + ... + 2.37392249152569e+226, -2.801972415904499e+226, -3.2288710633399875e+226, + 1.321721142591339e+227, -9.144734174579399e+226] +```