форкнуто от main/python-labs
KireevYP
2 недель назад
Родитель
0fa8e09b87
Сommit
21ffbe01b9
|
После Ширина: | Высота: | Размер: 15 KiB |
@ -0,0 +1,492 @@
|
||||
# Отчёт по теме 7
|
||||
Киреев Юрий А-02-23
|
||||
## 1. Запуск инетрактивной оболочки IDLE
|
||||
Создал файл отчёта
|
||||
## 2. Создание пользовательской функции.
|
||||
### 2.1. Функция без аргументов.
|
||||
Пример:
|
||||
```py
|
||||
>>> def uspeh():
|
||||
>>> """Подтверждение успеха операции"""
|
||||
>>> print('Выполнено успешно!')
|
||||
>>> uspeh()
|
||||
Выполнено успешно!
|
||||
```
|
||||
Определим класс объекта:
|
||||
```py
|
||||
>>> type(uspeh)
|
||||
<class 'function'>
|
||||
```
|
||||
Класс - функция. Убедимся, что имя функции появилось в пространстве имен:
|
||||
```py
|
||||
>>> dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'uspeh']
|
||||
```
|
||||
Введём функцию:
|
||||
```py
|
||||
>>> help(uspeh)
|
||||
Help on function uspeh in module __main__:
|
||||
|
||||
uspeh()
|
||||
Подтверждение успеха операции
|
||||
```
|
||||
Функция help вернула описание, которое мы написали в комментарии по назначению функции.
|
||||
### 2.2. Функция с аргументами
|
||||
Пример:
|
||||
```py
|
||||
>>> 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
|
||||
```
|
||||
Проверим, можно ли эту функцию выполнить с аргументами - символьными строками.
|
||||
```py
|
||||
>>> sravnenie('abc','abcde')
|
||||
abc меньше abcde
|
||||
```
|
||||
### 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]
|
||||
>>> slozh((1, 2), (3, 4), (5, 6), (7, -8)) #Сложение кортежей
|
||||
(1, 2, 3, 4, 5, 6, 7, 8)
|
||||
>>> slozh({1,2,3}, {"Oleg", "Horoshaya", "Rabota"}, {True, False}, {16}) #Сложение множеств
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#17>", line 1, in <module>
|
||||
slozh({1,2,3}, {"Oleg", "Horoshaya", "Rabota"}, {True, False}, {16})
|
||||
File "<pyshell#16>", line 3, in slozh
|
||||
return a1+a2+a3+a4
|
||||
TypeError: unsupported operand type(s) for +: 'set' and 'set'
|
||||
```
|
||||
Невозможно выполнить данную функцию для сложения множеств. Для объединения множеств применияется операция union.
|
||||
```py
|
||||
>>> dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4} #Сложение словарей
|
||||
>>> slozh(dict1, dict2, dict3, dict4)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#19>", line 1, in <module>
|
||||
slozh(dict1, dict2, dict3, dict4)
|
||||
File "<pyshell#16>", line 3, in slozh
|
||||
return a1+a2+a3+a4
|
||||
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
|
||||
```
|
||||
Словари также нельзя складывать с использованием данной функции.
|
||||
### 2.5. Функция, реализующая модель устройства.
|
||||
```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="Выходной сигнал")
|
||||
[<matplotlib.lines.Line2D object at 0x000002F63915A440>]
|
||||
plt.show()
|
||||
```
|
||||
Представим выходной сигнал в виде графика:
|
||||
|
||||
## 3. Функции как объекты.
|
||||
### 3.1. Получение списка атрибутов объекта-функции.
|
||||
```py
|
||||
>>> dir(inerz)
|
||||
['__annotations__', '__builtins__', '__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__:
|
||||
|
||||
inerz(x, T, ypred)
|
||||
Модель устройства с памятью:
|
||||
x- текущее значение вх.сигнала,
|
||||
T -постоянная времени,
|
||||
ypred - предыдущее значение выхода устройства
|
||||
```
|
||||
### 3.2. Сохранение ссылки на объект-функцию в другой переменной.
|
||||
```py
|
||||
>>> fnkt = sravnenie
|
||||
>>> v = 16
|
||||
>>> fnkt(v, 23)
|
||||
16 меньше 23
|
||||
```
|
||||
Выполнена операция функции sravnenie, т.к. ссылка на функцию была сохранена в переменной fnkt.
|
||||
|
||||
### 3.3. Возможность альтернативного определения функции в программе.
|
||||
```py
|
||||
>>> typ_fun = 8
|
||||
>>> if typ_fun == 1:
|
||||
>>> def func():
|
||||
>>> print("Функция 1")
|
||||
>>> else:
|
||||
>>> def func():
|
||||
>>> print('Функция 2')
|
||||
|
||||
>>> func()
|
||||
Функция 2
|
||||
```
|
||||
Результат обусловлен тем, что typ_fun не равен единице.
|
||||
|
||||
## 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)
|
||||
>>> print(zz)
|
||||
-2.3318122278318336
|
||||
```
|
||||
### 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]
|
||||
>>> qq = slozh(*b1234)
|
||||
>>> print(qq)
|
||||
[1, 2, -1, -2, 0, 2, -1, -1]
|
||||
```
|
||||
### 4.5. Пример со значениями аргументов функции, содержащимися в словаре
|
||||
```py
|
||||
>>> dic4={"a1":1,"a2":2,"a3":3,"a4":4}
|
||||
>>> qqq=slozh(**dic4) #Перед ссылкой на словарь надо ставить две звездочки
|
||||
>>> print(qqq)
|
||||
10
|
||||
```
|
||||
### 4.6. Смешанные ссылки
|
||||
```py
|
||||
>>> e1 = (-1, 6); dd2 = {'a3': 3, 'a4': 9}
|
||||
>>> qqqq = slozh(*e1,**dd2)
|
||||
>>> print(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
|
||||
```
|
||||
Подобным же образом в списке аргументов функции также можно использовать словарь:
|
||||
```py
|
||||
>>> def func4(a,b=7,**slov7):
|
||||
>>> smm=0
|
||||
>>> for key, value in slov7.items():
|
||||
>>> smm+=value
|
||||
>>> return a*smm+b
|
||||
|
||||
>>> func4(-1,2,x=0,y=3,z=6)
|
||||
-7
|
||||
```
|
||||
### 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
|
||||
```py
|
||||
>>> a=90 # Числовой объект – не изменяемый тип
|
||||
>>> def func3(b):
|
||||
>>> b = 5*b+67
|
||||
|
||||
>>> func3(a)
|
||||
>>> print(a)
|
||||
90
|
||||
```
|
||||
Значение a не изменилось, т.к. все изменения произошли локально внутри функции.
|
||||
Пример со списком:
|
||||
```py
|
||||
>>> sps1=[1,2,3,4] #Список – изменяемый тип объекта
|
||||
>>> def func2(sps):
|
||||
>>> sps[1] = 99
|
||||
|
||||
>>> func2(sps1)
|
||||
>>> print(sps1)
|
||||
[1, 99, 3, 4]
|
||||
```
|
||||
Список sps1 изменился.
|
||||
Попробуем применить эту функцию к кортежу.
|
||||
```py
|
||||
>>> kort = (1,2,3,4) #Кортеж – неизменяемый тип объекта
|
||||
>>> func2(kort)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#78>", line 1, in <module>
|
||||
func2(kort)
|
||||
File "<pyshell#75>", line 2, in func2
|
||||
sps[1]=99
|
||||
TypeError: 'tuple' object does not support item assignment
|
||||
```
|
||||
Кортеж не изменился, более того - эту функцию к кортежу применить нельзя.
|
||||
## 5. Специальные типы пользовательских функций
|
||||
### 5.1. Анонимные функции
|
||||
Примеры:
|
||||
```py
|
||||
>>> 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
|
||||
```
|
||||
### 5.2. Функции-генераторы
|
||||
Пример:
|
||||
```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 "<pyshell#94>", line 1, in <module>
|
||||
print(alp.__next__())
|
||||
StopIteration
|
||||
```
|
||||
После выдачи значения 7 генератор завершил работу, при попытке получить следующее значение возникла ошибка StopIteration - как раз для завершенных итераторов.
|
||||
## 6. Локализация объектов в функциях.
|
||||
|
||||
Все объекты - переменные, коллекции, функции и т.д. - могут быть определены глобально или локально.
|
||||
Глобально - значит вне всяких функций.Локальные переменные определены внутри функции, и если хочется
|
||||
использовать такую переменную в другой функции, то нужно обрабатывать доступ к ним из других функций.
|
||||
|
||||
### 6.1. Примеры на локализацию объектов
|
||||
Пример 1. Одноименные локальный и глобальный объекты.
|
||||
```py
|
||||
>>> glb=10
|
||||
>>> def func7(arg):
|
||||
>>> loc1=15
|
||||
>>> glb=8
|
||||
>>> return loc1*arg
|
||||
|
||||
>>> res=func7(glb)
|
||||
>>> print(res,glb)
|
||||
150 10
|
||||
```
|
||||
При получении результата использовалось глобальное значение glb и локальное loc1. Также видим, что glb не изменилось после выполнения функции.
|
||||
Пример 2. Ошибка в использовании локального объекта.
|
||||
```py
|
||||
>>> def func8(arg):
|
||||
>>> loc1=15
|
||||
>>> print(glb)
|
||||
>>> glb=8
|
||||
>>> return loc1*arg
|
||||
|
||||
>>> res=func8(glb)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#100>", line 1, in <module>
|
||||
res=func8(glb)
|
||||
File "<pyshell#99>", line 3, in func8
|
||||
print(glb)
|
||||
UnboundLocalError: local variable 'glb' referenced before assignment
|
||||
```
|
||||
Внутри функции glb считается локальной переменной, и обращение к ней происходит до того, как её объявили. Вследствие чего и возникла такая ошибка.
|
||||
Пример 3. Переопределение локализации объекта.
|
||||
```py
|
||||
>>> glb=11
|
||||
>>> def func7(arg):
|
||||
>>> loc1=15
|
||||
>>> global glb
|
||||
>>> print(glb)
|
||||
>>> glb=8
|
||||
>>> return loc1*arg
|
||||
|
||||
>>> res=func7(glb)
|
||||
11
|
||||
>>> print(glb)
|
||||
8
|
||||
```
|
||||
Значение glb изменилось после завершения работы функции, так как ключевое слово global позволяет функции изменять глобальную переменную, а не создавать локальную с тем же именем.
|
||||
### 6.2. Выявление локализации объекта с помощью функций locals() и globals().
|
||||
Примеры
|
||||
```py
|
||||
>>> globals().keys() #Перечень глобальных объектов
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
>>> locals().keys()
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', '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__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
dict_keys(['arg', 'loc1', 'glb'])
|
||||
```
|
||||
Полученные списки: первый - глобальные переменные, второй - локальные переменные данной функции.
|
||||
```py
|
||||
>>> 'glb' in globals().keys()
|
||||
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__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', '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__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
|
||||
|
||||
glob_func9_1 и glob_func9: #перечень глобальных переменных.
|
||||
locl_func9_1: #перечень локальных переменных вложенной функции func9_1
|
||||
loc_func9: #перечень локальных переменных функции func9
|
||||
```
|
||||
### 6.4. Моделирование САУ
|
||||
|
||||
>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',')
|
||||
k1,T,k2,Xm,A,F,N=9,8,7,10,5,0.5,100
|
||||
>>> 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, -2.4492935982947065e-15, -4.898587196589413e-15, -7.347880794884118e-15, -9.797174393178826e-15, -1.2246467991473532e-14, -1.4695761589768237e-14, -1.7145055188062946e-14, -1.9594348786357652e-14, -2.2043642384652358e-14, -2.4492935982947064e-14, -9.799650315725178e-14, -2.9391523179536473e-14, 3.921345679817883e-14, -3.429011037612589e-14, -1.0779367755043061e-13, -3.9188697572715304e-14, 2.941628240500001e-14, -4.4087284769304716e-14, -1.1759085194360943e-13, -4.898587196589413e-14, 1.9619108011821187e-14, -1.9599300631450355e-13, -1.2738802633678826e-13, -5.878304635907295e-14, 9.82193361864236e-15, 7.842691359635766e-14, -1.371852007299671e-13, -6.858022075225178e-14, 2.475922546353431e-17, -2.1558735510086123e-13, -1.469823751231459e-13, -7.837739514543061e-14, -9.772415167715291e-15, 5.883256481000002e-14, -1.5677954951632475e-13, -8.817456953860943e-14, -1.9569589560894117e-14, -2.3518170388721885e-13, -1.6657672390950356e-13, -9.797174393178826e-14, -3.13583858258113e-13, 3.9238216023642374e-14, -1.763738983026824e-13, -3.919860126290071e-13, -3.9163938347251766e-14, -2.547760526735765e-13, 9.804602160817887e-14, -1.175660927181459e-13, -3.331782070444707e-13, 1.964386723728472e-14, -1.9596824708904002e-13, 1.5685382719271532e-13, -5.875828713360942e-14, -2.743704014599342e-13, 7.84516728218212e-14, -1.3716044150450357e-13, -3.5277255583082833e-13, 4.951845092706862e-17, -2.155625958753977e-13, -4.3117471020172245e-13, -7.835263591996706e-14, -2.939647502462918e-13, 5.885732403546355e-14, -1.5675479029086122e-13, -3.7236690461718595e-13, -1.9544830335430582e-14, -2.351569446617553e-13, 1.1766512962000005e-13, -9.794698470632473e-14, -3.135590990326495e-13, 3.92629752491059e-14, -1.7634913907721887e-13, -3.919612534035436e-13, -3.9139179121788235e-14, -2.54751293448113e-13, -4.703634077744377e-13, -1.1754133349268239e-13, -3.331534478190071e-13, 1.9668626462748253e-14, -1.9594348786357651e-13, -4.1155560218990125e-13, -6.27167716516226e-13, 2.9408854637360953e-13, 7.847643204728475e-14, -1.3713568227904e-13, -3.527477966053648e-13, -5.683599109316896e-13, -7.839720252580142e-13, 1.3728423763182123e-13, -7.832787669450353e-14, -2.939399910208283e-13, -5.09552105347153e-13, -7.251642196734778e-13, 1.9609204321635773e-13, -1.9520071109967048e-14, -2.351321854362918e-13, -4.5074429976261655e-13, -6.663564140889414e-13, 2.548998488008942e-13]
|
||||
|
||||
>>> 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)
|
||||
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, -11.221682976576965, 56.517593465421044, -198.4938430808908, 643.506543727202, -2038.3616992400925, 6410.418726006248, -20114.26644793458, 63067.832981055835, -197702.20103251687, 619702.3868992503, -1942426.7361789877, 6088395.773097905, -19083589.56721709, 59815939.53001698, -187488089.6939353, 587665784.8763827, -1841989359.093071, 5773561877.442508, -18096747684.33722, 56722744717.96331, -177792707487.408, 557276397506.7018, -1746736340307.673, 5474999221529.676, -17160927945422.51, 53789495857764.4, -168598683814381.4, 528458497902730.1, -1656409040019924.2, 5191875840294872.0, -1.6273501345243368e+16, 5.1007931271830376e+16, -1.5988010185603117e+17, 5.011308306794939e+17, -1.5707527487295396e+18, 4.923393346795263e+18, -1.5431965385305592e+19, 4.837020706628768e+19, -1.5161237556062686e+20, 4.75216332889284e+20, -1.4895259190397258e+21, 4.6687946308614147e+21, -1.4633946966973882e+22, 4.58688849615756e+22, -1.4377219026189537e+23, 4.5064192665721635e+23, -1.4124994944530019e+24, 4.4273617340261656e+24, -1.3877195709376152e+25, 4.349691132673771e+25, -1.3633743694252021e+26, 4.273383131144217e+26, -1.339456263450744e+27, 4.198413824919648e+27, -1.3159577603427e+28, 4.124759728846688e+28, -1.292871498875825e+29, 4.052397769779404e+29, -1.270190246965166e+30, 3.981305279351331e+30, -1.2479068994005175e+31, 3.911459986874298e+31, -1.2260144756206116e+32, 3.8428400123618285e+32, -1.2045061175263658e+33, 3.7754238596749417e+33, -1.1833750873324914e+34]
|
||||
## 7. Завершил сеанс работы с IDLE.
|
||||
@ -0,0 +1,67 @@
|
||||
# Общее контрольное задание по теме 7
|
||||
Киреев Юрий, А-02-23
|
||||
## Задание
|
||||
1) Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с за-держкой на заданное время Т.
|
||||
2) Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в ви-де таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращае-мый результат функции: список с числами элементов выборки в интервалах разбиения.
|
||||
3) Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х
|
||||
Y=b1+b2*X
|
||||
и имеющую аргументы b1, b2 и X.
|
||||
## Решение
|
||||
1)
|
||||
```py
|
||||
>>> def delay(signal, T):
|
||||
>>> output=[]
|
||||
>>> for i in range(len(signal)+T):
|
||||
>>> if i<T:
|
||||
>>> output.append(0)
|
||||
>>> else:
|
||||
>>> output.append(signal[i-T])
|
||||
>>> return output
|
||||
|
||||
>>> x = [0,1,2,3,4,5,6,7,8,9]
|
||||
>>> y=delay(x,5)
|
||||
>>> y
|
||||
[0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
||||
```
|
||||
2)
|
||||
```py
|
||||
>>> def histogram(data, intervals):
|
||||
>>> low_g = min(data)
|
||||
>>> high_g = max(data)
|
||||
>>> bin_width = (high_g - low_g) / intervals
|
||||
>>> hist = [0] * intervals
|
||||
>>> for i in data:
|
||||
>>> bin_index = int((i - low_g) / bin_width)
|
||||
>>> if bin_index == intervals:
|
||||
>>> bin_index = intervals - 1
|
||||
>>> hist[bin_index] += 1
|
||||
>>> for i in range(intervals):
|
||||
>>> min_gran = low_g + i * bin_width
|
||||
>>> max_gran = low_g + (i + 1) * bin_width
|
||||
>>> print(f"{min_gran:.1f} - {max_gran:.1f}\t\t{hist[i]}")
|
||||
>>> print("Возвращаемый список: ")
|
||||
>>> return hist
|
||||
|
||||
>>> data = list(range(1,8))
|
||||
>>> histogram(data,4)
|
||||
1.0 - 2.5 2
|
||||
2.5 - 4.0 1
|
||||
4.0 - 5.5 2
|
||||
5.5 - 7.0 2
|
||||
Возвращаемый список:
|
||||
[2, 1, 2, 2]
|
||||
|
||||
>>> data = list(range(1,9))
|
||||
>>> histogram(data,3)
|
||||
1.0 - 3.3 3
|
||||
3.3 - 5.7 2
|
||||
5.7 - 8.0 3
|
||||
Возвращаемый список:
|
||||
[3, 2, 3]
|
||||
```
|
||||
3)
|
||||
```py
|
||||
>>> linreg = lambda b1, b2, x: b1 + b2 * x
|
||||
>>> linreg(1, 1, 10)
|
||||
11
|
||||
```
|
||||
Загрузка…
Ссылка в новой задаче