diff --git a/TEMA7/Figure_1.png b/TEMA7/Figure_1.png new file mode 100644 index 0000000..65d1db5 Binary files /dev/null and b/TEMA7/Figure_1.png differ diff --git a/TEMA7/report.md b/TEMA7/report.md new file mode 100644 index 0000000..536f799 --- /dev/null +++ b/TEMA7/report.md @@ -0,0 +1,620 @@ +# Отчёт по теме 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() +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 +