# Отчёт по теме 7. Создание пользовательских функций 

Выполнил Огарков Илья, А-03-23

## 1. Начало работы

Создание текстового файла `report.md`
```python
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. Первый пример: функция – без аргументов**
```python
def uspeh():
    """Подтверждение успеха операции"""
    print('Выполнено успешно!')

uspeh()
Выполнено успешно!
type(uspeh)
<class 'function'>
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. Пример функции с аргументами**
```python
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
n,m = 'sasa','ss'; sravnenie(n,m)
sasa  меньше  ss
```

**2.3. Пример функции, содержащей return**
```python
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. Сложение для разных типов аргументов**
```python
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]
t1=(1,2);t2=(3,4);t3=(5,6);t4=(7,8)
slozh(t1,t2,t3,t4)
(1, 2, 3, 4, 5, 6, 7, 8)
d1={'a':1};d2={'b':2};d3={'c':3};d4={'d':4}
slozh(d1,d2,d3,d4)
Traceback (most recent call last):
  File "<pyshell#54>", line 1, in <module>
    slozh(d1,d2,d3,d4)
  File "<pyshell#44>", 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 "<pyshell#57>", line 1, in <module>
    slozh(s1,s2,s3,s4)
  File "<pyshell#44>", line 3, in slozh
    return a1+a2+a3+a4
TypeError: unsupported operand type(s) for +: 'set' and 'set'
```

**2.5.**
```python
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. Получение списка атрибутов объекта-функции.**
```python
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. Сохранение ссылки на объект-функцию в другой переменной**
```python
fnkt=sravnenie
v=16
fnkt(v,23)
16  меньше  23
```

**3.3. Возможность альтернативного определения функции в программе**
```python
typ_fun=8
if typ_fun==1:
    def func():
        print('Функция 1')
else:
    def func():
        print('Функция 2')

func()
Функция 2
```

## 4. Аргументы функции
**4.1. Изучите возможность использования функции в качестве аргумента другой функции**
```python
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. Обязательные и необязательные аргументы**
```python
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. Изучите возможность обращения к функции с произвольным (непозиционным) расположением аргументов**
```python
logistfun(b=0.5,a=0.8)
0.34498724056380625
```

**4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже**
```python
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. Пример со значениями аргументов функции, содержащимися в словаре**
```python
dic4={"a1":1,"a2":2,"a3":3,"a4":4}
qqq=slozh(**dic4);qqq # Распаковываем значения словаря
10
qqq_usl=slozh(*dic4);qqq_usl # Распаковываем ключи словаря
'a1a2a3a4'
```

**4.6. Смешанные ссылки**
```python
e1=(-1,6);dd2={'a3':3,'a4':9}
qqqq=slozh(*e1,**dd2)
qqqq
17
```

**4.7. Переменное число аргументов у функции**
```python
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. Комбинация аргументов**
```python
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. Изменение значений объектов, используемых в качестве аргументов функции**
```python
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. Анонимные функции**
```python
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. Функции-генераторы**
```python
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 "<pyshell#26>", line 1, in <module>
    print(alp.__next__())
StopIteration
```

## 6. Локализация объектов в функциях
**6.1. Примеры на локализацию объектов**
```python
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 "<pyshell#40>", line 1, in <module>
    res=func8(glb);res
  File "<pyshell#39>", 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**
```python
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. Локализация объектов при использовании вложенных функций**
```python
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.**
```python
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]
```