# Отчёт по теме 7: Создание пользовательских функций Филиппов Даниил Юрьевич, А-01-23 # 1. Запуск интерактивной оболочки IDLE ```py >>> import os >>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA7') ``` Пользовательская функция – это совокупность инструкций, которая выполняется при обращении к функции из любого места программы. Аргументы функции – это ссылки на объекты-источники данных, которые используются при её выполнении. Возвращаемые данные – это результаты вычисления функции, передаваемые в ту часть программы, из которой была вызвана функция. # 2. Создание пользовательской функции Создание функции предполагает выполнение трех операций: формирование функции, ее сохранение и использование. В общем виде функция в языке Python представляется так: def <Имя функции>([<Список аргументов >]): [<отступы>"""<Комментарий по назначению функции>"""] <отступы><Блок инструкций – тело функции> [<отступы>return <Значение или вычисляемое выражение>] Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то выполнение функции прекращается с возвратом значения, следующего за этой инструкцией. Если функция не содержит оператора return, она автоматически возвращает значение None. ## 2.1 Функция без аргументов ```py >>> def uspeh(): ... """Подтверждение успеха операции""" ... print('Выполнено успешно!') ... ... >>> uspeh() Выполнено успешно! >>> type(uspeh) # Функция является объектом класса function. >>> dir() # Имя функции появилось в пространстве имён ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh'] >>> help(uspeh) Help on function uspeh in module __main__: uspeh() Подтверждение успеха операции ``` help вывело справку по функции uspeh в модуле main. Далее выведена документационная строка функции (то описание, которое было указано в тройных кавычках при её определении). Документационная строка позволяет кратко и понятно описывать назначение функции. ## 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 ``` Так как мы не указали какой тип данных должна принимать функция, то функция сможет работать с любыми данными, которые можно сравнить. Если нельзя сравнить, вернется TypeError. ```py >>> n,m='aaa', 'bbbb';sravnenie(n,m) aaa меньше bbbb ``` ## 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) #Сложение списков >>> q [1, 2, -1, -2, 0, 2, -1, -1] >>> c1=(1,2); c2=(-1,-2); c3= (0,2); c4=(-1,-1) >>> q=slozh(c1,c2,c3,c4) #Сложение кортежей >>> q (1, 2, -1, -2, 0, 2, -1, -1) q = slozh({1,1}, {2,2}, {"abc"}, {3,3}) # Сложение множеств Traceback (most recent call last): File "", line 1, in q = slozh({1,1}, {2,2}, {"abc"}, {3,3}) File "", line 3, in slozh return a1+a2+a3+a4 TypeError: unsupported operand type(s) for +: 'set' and 'set' >>> dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4} >>> slozh(dict1, dict2, dict3, dict4) # Сложение словарей Traceback (most recent call last): File "", line 1, in slozh(dict1, dict2, dict3, dict4) File "", line 3, in slozh return a1+a2+a3+a4 TypeError: unsupported operand type(s) for +: 'dict' and 'dict' slozh(1, "а", 2, "b") # Сложение числа и строки Traceback (most recent call last): File "", line 1, in slozh(1, "а", 2, "b") File "", line 3, in slozh return a1+a2+a3+a4 TypeError: unsupported operand type(s) for +: 'int' and 'str' ``` Как видно сложение для множеств и словарей не применимо. Также нельзя складывать числа и строки, но можно складывать числа и логический тип. ## 2.5 Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y: ```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 as plt >>> plt.plot(spsy, label = "Выходной сигнал") [] >>> plt.show() ``` График сохранён в файле Figure_1.png ![График](Figure_1.png) # 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__ 'Модель устройства с памятью:\n x- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства' >>> help(inerz) Help on function inerz in module __main__: inerz(x, T, ypred) Модель устройства с памятью: x- текущее значение вх.сигнала, T -постоянная времени, ypred - предыдущее значение выхода устройства ``` Атрибут __doc__ содержит значение docstring, если при инициализации функции он был задан. Если не был, то inerz.__doc__ будет иметь значение None. ## 3.2 Сохранение ссылки на объект-функции в другой переменной ```py >>> fnkt=sravnenie >>> v=16 >>> fnkt(v,23) 16 меньше 23 ``` Функции можно передавать в переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую функцию, что и sravnenie. ## 3.3 Возможность альтернативного определения функции в программе ```py >>> typ_fun=8 >>> 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 Возможность использования функции в качестве аргумента другой функции ```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 ``` Python передаёт ссылку на объект функции logistfun в переменную fff. Внутри функции выполняется заданная операция. ## 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 >>> 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 Пример со значениями аргументов функции, содержащимися в словаре ```py >>> dic4={"a1":1,"a2":2,"a3":3,"a4":4} >>> qqq=slozh(**dic4) #Перед ссылкой на словарь надо ставить две звездочки >>> qqq 10 >>> slozh(*dic4) 'a1a2a3a4' ``` Ключи на входе функции воспринимаются как значения позиционных переменных, а значения, как значения. Если поставить только одну звездочку, python попытается интерпретировать ключи, а не значения словаря как позиционные аргументы. ## 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 ``` Если мы не хотим передавать b, придется переопределить функцию так, чтобы именованный параметр b был в конце, а позиционный кортеж - перед ним. Подобным же образом в списке аргументов функции также можно использовать словарь, предварив его имя двумя звездочками. ```py >>> def func4(a,b=7,**dct1): #Аргументы: a-позиционный, b- по умолчанию + словарь ... """Словарь - сборка аргументов - должен быть последним!""" ... smm=0 ... smm = sum (dct1.values()) ... return a*smm + b ... >>> func4(-1,2, x=3, y=4, z=5) -10 ``` *args и **kwargs - способы передать не уточненное заранее число элементов: *args — переменное количество позиционных аргументов. Переданные с одной звездочкой аргументы собираются в кортеж. **kwargs — переменное количество именованных аргументов. Все переданные аргументы, которые указываются по имени, собираются в словарь. *args всегда должно идти перед **kwargs. ## 4.9 Изменение значений объектов, используемых в качестве аргументов функции Такое изменение возможно только у объектов изменяемого типа ```py >>> a=90 # Числовой объект – не изменяемый тип >>> def func3(b): ... b=5*b+67 ... >>> func3(a) >>> a 90 ``` Поскольку функция ничего не возвращает то вычисленное значение b = 5*b+67 существует только локально внутри нее и не выносится в глобальную область видимости. Пример со списком: ```py >>> sps1=[1,2,3,4] #Список – изменяемый тип объекта >>> def func2(sps): ... sps[1]=99 ... >>> func2(sps1) >>> print(sps1) [1, 99, 3, 4] ``` Список передается по ссылке, а не по значению, поэтому изменяется именно тот объект, который был передан. Пример с кортежем: ```py 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 [<Аргумент1>[,<Аргумент2>,…]]:<Возвращаемое значение или выражение> Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту. ```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 ``` Вызов лямбда-функции создает объект класса "функция". Внутри лямбда-функции не могут использоваться многострочные выражения, нельзя использовать if-else. ## 5.2 Функции-генераторы Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. Для этого в функцию включают инструкцию yield приостанавливающую её выполнение и возвращающую очередное значение. Данный оператор в отличие от return не останавливает полностью выполнение программы. Когда выполнение функции возобновляется после yield, оно продолжается с того места, где было приостановлено, до следующего оператора 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 ``` Здесь при каждом обращении к функции будет генерироваться только одно очередное значение. При программировании задач у таких функций часто используют метод __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 "", line 1, in print(alp.__next__()) StopIteration ``` __next__ помогает вывести значение, которое yield передает на каждой итерации цикла. Если функция отработала последнюю итерацию, но мы попытаемся сделать вызов, вернется ошибка. # 6. Локализация объектов в функциях По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Глобальные – это те объекты, значения которых заданы вне функции. Локализация может быть переопределена путем прямого объявления объектов как глобальных с помощью дескриптора global. ## 6.1 Примеры на локализацию объектов Пример 1. Одноименные локальный и глобальный объекты: ```py >>> glb=10 >>> def func7(arg): ... loc1=15 ... glb=8 ... return loc1*arg ... >>> res=func7(glb) >>> res 150 >>> glb 10 ``` Внутри функции glb принял значение 8, но глобальная переменная при этом после выполнения функции значения не поменяла. Это происходит потому, что локальный glb и глобальный glb - это два разных объекта. Пример 2. Ошибка в использовании локального объекта. ```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 ``` Переменной glb присваивается значение внутри функции. Поэтому python решает, что glb - это локальная переменная для всей функции. Но когда выполнение доходит до строки 3 print(glb), локальная переменная glb еще не была инициализирована (это происходит только в строке 4), поэтому выходит ошибка. Пример 3. Переопределение локализации объекта. ```py >>> 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() из builtins Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. ```py >>> globals().keys() #Перечень глобальных объектов dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'glb', 'func7', 'res', 'func8']) >>> locals().keys() #Перечень локальных объектов dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'glb', 'func7', 'res', 'func8']) ``` Сейчас различий нет, потому что эти методы возвращают объекты на уровне вызова этих функций. Сейчас мы работаем в самом рабочем пространстве, где локальная и глобальная области видимости совпадают. ```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', 'glb', 'func7', 'res', 'func8']) # Глобальное glb dict_keys(['arg', 'loc1', 'glb']) # Локальное glb >>> 'glb' in globals().keys() # Глобально glb 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', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1']) # # Содержит только объекты, определенные внутри func9_1, а также объект, переданный как аргумент функции 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', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) ``` ## 6.4 Моделирование системы Моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа «зона нечувствительности», при подаче на неё синусоидального входного сигнала. Реальный двигатель: последовательное соединение усилителя с коэффициентом усиления k1,интегратора: y(t)=x(t)+y(t-1), и инерционного звена: y(t)=(x(t)+T*y(t-1)) / (T+1) с постоянной времени Т. Тахогенератор: последовательное соединение усилителя с коэффициентом усиления k2 и интегратора: y(t)=x(t)+y(t-1). Нелинейное звено типа «зона нечувствительности»: y=0 при -xm≤ x ≤xm, y=x-xm при x>xm, y=x+xm при x<-xm. Таким образом, система характеризуется параметрами: k1, T, k2, xm. Входной сигнал характеризуется параметрами: A (амплитуда синусоиды) и F (период синусоиды). Еще один параметр задачи : N – время (число тактов) подачи сигнала. Решение задачи: ```py >>> 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]) >>> import math >>> 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, -7.83773951454306e-15, -8.817456953860943e-15, -9.797174393178826e-15, -3.919860126290071e-14, -1.175660927181459e-14, 1.5685382719271533e-14, -1.3716044150450356e-14, -4.3117471020172244e-14, -1.567547902908612e-14, 1.1766512962000004e-14, -1.7634913907721887e-14, ...] # Создание функций реализующие компоненты системы >>> 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, -2798.051869998873, 5004.749701095182, 1362.331454336744, ...] ``` # 7. Завершение сеанса работы с IDLE