diff --git a/TEMA6/name.bin b/TEMA6/name.bin index 10065ff..3f41423 100644 Binary files a/TEMA6/name.bin and b/TEMA6/name.bin differ diff --git a/TEMA6/name1.bin b/TEMA6/name1.bin new file mode 100644 index 0000000..6854bd6 Binary files /dev/null and b/TEMA6/name1.bin differ diff --git a/TEMA6/test.py b/TEMA6/test.py index 2798bee..af1eee2 100644 --- a/TEMA6/test.py +++ b/TEMA6/test.py @@ -7,14 +7,23 @@ company = input(" Введите название фирмы (латиницей company = company.replace(' ', '') print(" Название фирмы:", company) -name = dict(zip(spis, kort)) -print(name) +# Создаем словарь с именем компании как ключом +company_dict = { + company: dict(zip(spis, kort)) +} + +print("Словарь фирмы:") +print(company_dict) average_salary = sum(kort) / len(kort) -print(f" Средний оклад сотрудников: {average_salary} рублей") +print(f" Средний оклад сотрудников: {average_salary:.2f} рублей") -fp = open('name.bin', 'wb') -pickle.dump(spis,fp) -pickle.dump(kort,fp) -pickle.dump(name, fp) +# Создаем имя файла из названия компании +filename = f"{company}.bin" +fp = open(filename, 'wb') +pickle.dump(spis, fp) +pickle.dump(kort, fp) +pickle.dump(company_dict, fp) fp.close() + +print(f" Данные сохранены в файл: {filename}") diff --git a/TEMA7/report.md b/TEMA7/report.md index e69de29..c52eff0 100644 --- a/TEMA7/report.md +++ b/TEMA7/report.md @@ -0,0 +1,1051 @@ +\# Отчёт по Теме 7 + + + +Соловьёва Екатерина, А-01-23 + + + +\# 1. Запуск интерактивной оболочки IDLE + + + +\# 2. Создание пользовательской функции + + + +Создание функции предполагает выполнение трех операций: формирование функции, ее сохранение и использование. + +В общем виде функция в языке Python представляется так: + +def <Имя функции>(\[<Список аргументов >]): + +\[<отступы>"""<Комментарий по назначению функции>"""] + +<отступы><Блок инструкций – тело функции> + +\[<отступы>return <Значение или вычисляемое выражение>] + + + +\# 2.1 Функция без аргументов + +```py +def uspeh(): + +  """Подтверждение успеха операции""" + +  print('Выполнено успешно!') + +uspeh() +Выполнено успешно! + + + +type(uspeh) + + + +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", 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' + + +mnoz = slozh({1,3}, {6,9}, {"zxcv"}, {0,9}) + +Traceback (most recent call last): + +  File "", line 1, in + +  mnoz = slozh({1,3}, {6,9}, {"zxcv"}, {0,9}) + +  File "", line 3, in slozh + +  return a1+a2+a3+a4 + +TypeError: unsupported operand type(s) for +: 'set' and 'set' +``` + + + +\## 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 matplotlib.pyplot as plt + +plt.show() + +plt.plot(spsy) + +\[] + +plt.show()``` + + + +!\[График](Рис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\_\_ + +'Модель устройства с памятью:\\nx- текущее значение вх.сигнала,\\nT -постоянная времени,\\nypred - предыдущее значение выхода устройства' + + +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 +``` + +Выполнена операция присваивания функции переменной, а затем вызов функции через эту переменную + + + +\## 3.3 Возможность альтернативного определения функции в программе + + + +```py +typ\_fun=8 + +if typ\_fun==1: + +  def func(): + +  print('Функция 1') + +else: + +  def func(): + +  print('Функция 2') + + + +  + +func() + +Функция 2 +``` + + + +Условие typ\_fun == 1 ложно, поэтому определяется и вызывается функция из блока else + + + +\# 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 +``` + +Функция fun\_arg принимает другую функцию как аргумент (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 + +qq=slozh(\*b1234) #Перед ссылкой на список или кортеж надо ставить звездочку + +qq +\[1, 2, -1, -2, 0, 2, -1, -1] +``` + + + +\## 4.5 Пример со значениями аргументов функции, содержащимися в словаре + + + +```py +dic4={"a1":1,"a2":2,"a3":3,"a4":4} +qqq=slozh(\*\*dic4) #Перед ссылкой на словарь надо ставить две звездочки + +qqq +10 +``` + + + +\## 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 +``` + +a = -1 (первый позиционный) + +b = 2 (второй позиционный, переопределил значение по умолчанию 7) + +\*kort7 = (0, 3, 6) (все остальные аргументы в кортеж) + + + +Подобным же образом в списке аргументов функции также можно использовать словарь, предварив его имя двумя звездочками + + + +```py +def func5(a,b=7,\*\*dict): + +  """Словарь""" + +  smm=0 + +  smm = sum (dict.values()) + +  return a\*smm+b + + + +  + +func5(-1,2,aa=0,bb=3,cc=6) + +-7 + +``` + +\## 4.9 Изменение значений объектов, используемых в качестве аргументов функции. + +Такое изменение возможно только у объектов изменяемого типа + + + +```py +a=90 + +def func3(b): + +  b=5\*b+67 + + + +func3(a) + +a +``` + +значение переменной а не поменялось + + + +Пример со списком: + + + +```py +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 +``` + + + +\## 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 + + +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 + +``` + +Генераторы "запоминают" своё состояние, но когда значения заканчиваются, они сигнализируют об этом через исключение StopIteration + + + +\# 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 и локальная переменная 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 "", 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 +``` + +Ошибка произошла потому что при выполнении print(glb) интерпретатор пытается найти локальную glb, но локальная glb еще не определена (определение на следующей строке) + + + +Пример 3. Переопределение локализации объекта. + + + +```py +glb=11 +def func7(arg): + +  loc1=15 + +  global glb + +  print(glb) + +  glb=8 + +  return loc1\*arg + + + +  + +res=func7(glb) + +11 + +glb + +8 +``` + + + +Здесь мы прямо объявили переменную glb как глобальную, поэтому она изменилась + + + +\## 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins + + + +Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. + + + +```py +globals().keys() #Перечень глобальных объектов +globals().keys() + +dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'n', 'm', 'sravnenie', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kort1', 'kort2', 'kort3', 'kort4', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) + + +locals().keys() #Перечень локальных объектов +dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'n', 'm', 'sravnenie', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kort1', 'kort2', 'kort3', 'kort4', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) +``` + +Различий нет, потому что команды выполнены в глобальной области видимости, где globals() и locals() ссылаются на один и тот же словарь. Различия появляются только при вызове locals() внутри функций или методов. + + + +```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\_\_', '\_\_file\_\_', 'func8', 'glb'])# Глобальное glb + +dict\_keys(\['arg', 'loc1', 'glb'])# Локальное glb + + +'glb' in globals().keys() +True +``` + +locals() внутри функции показывает только её внутренние переменные, а globals() показывает все объекты модуля. + + + +\## 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\_\_', '\_\_file\_\_', '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\_\_', '\_\_file\_\_', '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=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)) +print(vhod) + +\[0.0, 0.6038955602659801, 1.1830675653399556, 1.713804645284377, 2.17437836168736, 2.5459327724842526, 2.813256396441241, 2.9654049729843344, 2.9961495215131584, 2.904231356598613]``` + +!\[График2](Figure\_2.png) + + + +Создание функций реализующие компоненты системы + + + +```py +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 + +``` + +Реализуем соединение компонент в соответствии с заданием + + + +```py +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.0575138628824743, 0.19757451809698162, 0.37271445071909315, 0.44764431066344834, 0.24935818305562138, -0.3024162461562951, -1.0323481238173855, -1.4374313649904746, -0.8573979371237693] + +``` + + # 7. Завершение сеанса работы с IDLE + diff --git a/TEMA7/Рис1.png b/TEMA7/Рис1.png new file mode 100644 index 0000000..78e179f Binary files /dev/null and b/TEMA7/Рис1.png differ