|
|
# Отчёт по Теме 8
|
|
|
|
|
|
Кузьменко Елена, А-02-23
|
|
|
|
|
|
## 1. Запустили интерактивную оболочку IDLE.
|
|
|
|
|
|
```py
|
|
|
import os, sys, importlib
|
|
|
os.chdir(r"C:\Users\vaffl\Desktop\Учеба\ПОАС\TEMA8")
|
|
|
os.getcwd()
|
|
|
'C:\\Users\\vaffl\\Desktop\\Учеба\\ПОАС\\TEMA8'
|
|
|
```
|
|
|
|
|
|
## 2. Создание и использование модулей в среде Python.
|
|
|
|
|
|
Модуль в Python — это отдельный файл с расширением .py, содержащий код на языке Python, который может быть повторно использован в других программах через import.
|
|
|
|
|
|
### 2.1. Запуск модуля через import
|
|
|
|
|
|
Mod1.py
|
|
|
```py
|
|
|
perm1 = input('Mod1:Введите значение = ')
|
|
|
print('Mod1:Значение perm1=', perm1)
|
|
|
|
|
|
```
|
|
|
|
|
|
main.py
|
|
|
```py
|
|
|
>>> import sys, os
|
|
|
>>> import Mod1
|
|
|
Mod1:Введите значение = 10
|
|
|
Mod1:Значение perm1= 10
|
|
|
>>> type(Mod1)
|
|
|
<class 'module'>
|
|
|
>>> dir(Mod1)
|
|
|
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
|
|
|
```
|
|
|
|
|
|
Повторное обращение к Mod1 в main:
|
|
|
```py
|
|
|
>>> import Mod1 # требуется перезагрузить
|
|
|
>>> importlib.reload(Mod1)
|
|
|
Mod1:Введите значение = 6
|
|
|
Mod1:Значение perm1= 6
|
|
|
<module 'Mod1' from 'C:\\Users\\vaffl\\Desktop\\Учеба\\ПОАС\\TEMA8\\Mod1.py'>
|
|
|
>>> Mod1.perm1
|
|
|
'6'
|
|
|
```
|
|
|
|
|
|
### 2.2. Импортируемые модули в словаре.
|
|
|
|
|
|
Импортированные модули заносятся в словарь – значение атрибута sys.modules.
|
|
|
|
|
|
```py
|
|
|
>>> print(sorted(sys.modules.keys()))
|
|
|
['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', . . ., 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
|
|
|
|
|
```
|
|
|
print(sorted(sys.modules.keys())) выводит отсортированный по алфавиту список всех модулей, загруженных в память Python на данный момент.
|
|
|
|
|
|
Удаление Mod1 из словаря:
|
|
|
|
|
|
```py
|
|
|
>>> sys.modules.pop('Mod1')
|
|
|
<module 'Mod1' from 'C:\\Users\\vaffl\\Desktop\\Учеба\\ПОАС\\TEMA8\\Mod1.py'>
|
|
|
>>> print(sorted(sys.modules.keys()))
|
|
|
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', …, 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
|
|
```
|
|
|
|
|
|
### 2.3. Запуск модуля на выполнение с помощью exec().
|
|
|
|
|
|
Функция exec действует так, как будто на месте обращения к ней в программу вставлен код из объекта-аргумента функции. Объект-модуль при этом не создается. Созданные при выполнении модуля объекты становятся объектами главной программы.
|
|
|
|
|
|
```py
|
|
|
>>> exec(open('Mod1.py').read()) # читает как бинарный файл
|
|
|
Mod1:Введите значение = 3
|
|
|
Mod1:Значение perm1= 3
|
|
|
>>> exec(open('Mod1.py', encoding='utf-8').read())
|
|
|
Mod1:Введите значение = 3
|
|
|
Mod1:Значение perm1= 3
|
|
|
>>> print(sorted(sys.modules.keys())) # Объект-модуль не появится
|
|
|
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', ...,'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
|
|
>>> perm1
|
|
|
'3'
|
|
|
```
|
|
|
|
|
|
### 2.4. Инструкция from … import …
|
|
|
|
|
|
Можно осуществлять импорт модуля не целиком, а только часть содержащихся в нем объектов.
|
|
|
|
|
|
#### Пример 1
|
|
|
|
|
|
```py
|
|
|
>>> from Mod1 import perm1
|
|
|
Mod1:Введите значение = 1
|
|
|
Mod1:Значение perm1= 1
|
|
|
>>> "perm1" in dir()
|
|
|
True
|
|
|
>>> "Mod1" in dir()
|
|
|
False
|
|
|
>>> perm1 # Теперь переменная главной программы
|
|
|
'1'
|
|
|
```
|
|
|
|
|
|
#### Пример 2
|
|
|
|
|
|
Содержимое нового модуля Mod2:
|
|
|
|
|
|
```py
|
|
|
def alpha():
|
|
|
print('****ALPHA****')
|
|
|
t=input('Значение t=')
|
|
|
return t
|
|
|
|
|
|
def beta(q):
|
|
|
import math
|
|
|
expi=q*math.pi
|
|
|
return math.exp(expi)
|
|
|
```
|
|
|
main.py
|
|
|
```py
|
|
|
>>> from Mod2 import beta # импортирует beta из модуля
|
|
|
>>> g = beta(2); g
|
|
|
535.4916555247646
|
|
|
```
|
|
|
|
|
|
Случай обращения к переменной без её импорта:
|
|
|
```py
|
|
|
>>> alpha()
|
|
|
Traceback (most recent call last):
|
|
|
File "<pyshell#41>", line 1, in <module>
|
|
|
alpha()
|
|
|
NameError: name 'alpha' is not defined
|
|
|
```
|
|
|
|
|
|
Импорт функции из модуля с псевдонимом:
|
|
|
```py
|
|
|
>>> from Mod2 import alpha as al
|
|
|
>>> al()
|
|
|
****ALPHA****
|
|
|
Значение t=54
|
|
|
'54'
|
|
|
```
|
|
|
|
|
|
```py
|
|
|
>>> del al,beta
|
|
|
>>> dir()
|
|
|
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'g', 'importlib', 'os', 'perm1', 'sys']
|
|
|
>>> from Mod2 import * # импорт всего содержимого
|
|
|
>>> tt=alpha()
|
|
|
****ALPHA****
|
|
|
Значение t=0.12
|
|
|
>>> uu = beta(float(tt))
|
|
|
>>> uu
|
|
|
1.4578913609506803
|
|
|
```
|
|
|
|
|
|
## 3. Многомодульные программы.
|
|
|
|
|
|
### 3.1. Пример простой многомодульной программы.
|
|
|
|
|
|
Содержимое модуля Mod0:
|
|
|
```py
|
|
|
#Модуль Mod0
|
|
|
import Mod1
|
|
|
print('perm1=',Mod1.perm1)
|
|
|
from Mod2 import alpha as al
|
|
|
tt=al()
|
|
|
print('tt=',tt)
|
|
|
from Mod2 import beta
|
|
|
qq=beta(float(tt))
|
|
|
print('qq=',qq)
|
|
|
```
|
|
|
|
|
|
main.py
|
|
|
```py
|
|
|
>>> import Mod0
|
|
|
Mod1:Введите значение = 10
|
|
|
Mod1:Значение perm1= 10
|
|
|
perm1= 10
|
|
|
****ALPHA****
|
|
|
Значение t=0.1
|
|
|
tt= 0.1
|
|
|
qq= 1.369107770624847
|
|
|
>>> Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
|
|
|
'0.1'
|
|
|
1.369107770624847
|
|
|
'10'
|
|
|
```
|
|
|
|
|
|
### 3.2. Многомодульная программа(Тема7)
|
|
|
|
|
|
MM1.py
|
|
|
```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 and xtt>(-gran):
|
|
|
ytt=0
|
|
|
elif xtt>=gran:
|
|
|
ytt=xtt-gran
|
|
|
elif xtt<=(-gran):
|
|
|
ytt=xtt+gran
|
|
|
return ytt
|
|
|
```
|
|
|
|
|
|
MM2.py
|
|
|
```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))
|
|
|
|
|
|
import MM1 as mod
|
|
|
yi1=0;yin1=0;yi2=0
|
|
|
vyhod=[]
|
|
|
for xt in vhod:
|
|
|
xt1=xt-yi2 #отрицательная обратная связь
|
|
|
[yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
|
|
|
yi2=mod.tahogen(yin1,k2,yi2)
|
|
|
yt=mod.nechus(yin1,Xm)
|
|
|
vyhod.append(yt)
|
|
|
```
|
|
|
|
|
|
MM0.py
|
|
|
```py
|
|
|
import MM2
|
|
|
print("y =", MM2.vyhod)
|
|
|
```
|
|
|
|
|
|
main.py
|
|
|
```py
|
|
|
>>> import MM0
|
|
|
k1,T,k2,Xm,A,F,N=5,4,3,10,13,40,20
|
|
|
y = [0, 0, 0, 0, 0, 2.477949838924891, 0, -20.53441412153191, 17.715970981372855, 60.985241346827166, -100.52605254589719, -130.44369177973613, 361.76845433684196, 191.5984158258393, -1110.3384817523201, 0, 3063.4072561608186, -1492.2961077606046, -7685.482903314702, 7891.808692887814]
|
|
|
```
|
|
|
|
|
|
|
|
|
### 3.3. Области действия объектов в модулях.
|
|
|
|
|
|
#### Пример 1
|
|
|
|
|
|
Попробуйте вставить в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
|
|
|
|
|
|
Mod2.py
|
|
|
```py
|
|
|
def alpha():
|
|
|
print('****ALPHA****')
|
|
|
t=input('Значение t=')
|
|
|
print('Результат beta(2) из alpha:', beta(2))
|
|
|
return t
|
|
|
|
|
|
def beta(q):
|
|
|
import math
|
|
|
print('Результат alpha() из beta:', alpha())
|
|
|
expi=q*math.pi
|
|
|
return math.exp(expi)
|
|
|
```
|
|
|
Одновременно нельзя функциям обращаться друг к другу, так как возникает рекурсия(обращение функции к самой себе) - происходит зацикливание вывода(пока не прервать)
|
|
|
|
|
|
В отдельных случаях:
|
|
|
main.py
|
|
|
```py
|
|
|
>>> Mod2.alpha()
|
|
|
****ALPHA****
|
|
|
Значение t=10
|
|
|
Результат beta(2) из alpha: 535.4916555247646
|
|
|
'10'
|
|
|
```
|
|
|
|
|
|
```py
|
|
|
>>> Mod2.beta(3)
|
|
|
****ALPHA****
|
|
|
Значение t=10
|
|
|
Результат alpha() из beta: 10
|
|
|
12391.647807916694
|
|
|
```
|
|
|
|
|
|
#### Пример 2
|
|
|
|
|
|
Попробуйте отобразить на экране в модуле Mod0 значения объектов t и expi.
|
|
|
|
|
|
Mod2.py
|
|
|
```py
|
|
|
#Модуль Mod0
|
|
|
import Mod1
|
|
|
print('perm1=',Mod1.perm1)
|
|
|
from Mod2 import alpha as al
|
|
|
tt=al()
|
|
|
print('tt=',tt)
|
|
|
from Mod2 import beta
|
|
|
qq=beta(float(tt))
|
|
|
print('qq =',qq)
|
|
|
print('t =',t)
|
|
|
print('expi =',expi)
|
|
|
```
|
|
|
|
|
|
main.py
|
|
|
```py
|
|
|
>>> import Mod0
|
|
|
Mod1:Введите значение = 2
|
|
|
Mod1:Значение perm1= 2
|
|
|
perm1= 2
|
|
|
****ALPHA****
|
|
|
Значение t=1
|
|
|
tt= 1
|
|
|
qq = 23.140692632779267
|
|
|
Traceback (most recent call last):
|
|
|
File "<pyshell#96>", line 1, in <module>
|
|
|
import Mod0
|
|
|
File "C:\Users\vaffl\Desktop\Учеба\ПОАС\TEMA8\Mod0.py", line 10, in <module>
|
|
|
print('t =',t)
|
|
|
NameError: name 't' is not defined. Did you mean: 'tt'
|
|
|
```
|
|
|
Переменные t и expi -локальные, они не существуют в Mod0(только во время выполнения функций alpha() и beta())
|
|
|
|
|
|
#### Пример 3
|
|
|
|
|
|
Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
|
|
|
|
|
|
Mod0.py
|
|
|
```py
|
|
|
#Модуль Mod0
|
|
|
import Mod1
|
|
|
print('perm1=',Mod1.perm1)
|
|
|
from Mod2 import alpha as al
|
|
|
tt=al()
|
|
|
print('tt=',tt)
|
|
|
from Mod2 import beta
|
|
|
qq=beta(float(tt))
|
|
|
print('qq =',qq)
|
|
|
Mod1.perm1 *= 3 # с указанием модуля
|
|
|
print("perm1 = ", Mod1.perm1)
|
|
|
```
|
|
|
|
|
|
main.py
|
|
|
```py
|
|
|
>>> import Mod0
|
|
|
perm1= 2
|
|
|
****ALPHA****
|
|
|
Значение t=10
|
|
|
tt= 10
|
|
|
qq = 44031505860631.98
|
|
|
perm1 = 222
|
|
|
```
|
|
|
|
|
|
#### Пример 4
|
|
|
|
|
|
Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq.
|
|
|
|
|
|
```py
|
|
|
>>> import Mod0
|
|
|
perm1= 222
|
|
|
****ALPHA****
|
|
|
Значение t=1
|
|
|
tt= 1
|
|
|
qq = 23.140692632779267
|
|
|
perm1 = 222222222
|
|
|
>>> perm1*2
|
|
|
Traceback (most recent call last):
|
|
|
File "<pyshell#112>", line 1, in <module>
|
|
|
perm1
|
|
|
NameError: name 'perm1' is not defined
|
|
|
>>> tt*2
|
|
|
Traceback (most recent call last):
|
|
|
File "<pyshell#113>", line 1, in <module>
|
|
|
tt
|
|
|
NameError: name 'tt' is not defined
|
|
|
>>> qq*2
|
|
|
Traceback (most recent call last):
|
|
|
File "<pyshell#114>", line 1, in <module>
|
|
|
qq*2
|
|
|
NameError: name 'qq' is not defined
|
|
|
```
|
|
|
perm1,tt,qq - локальные объекты, к ним можно обращаться только в модулях, где они были заданы изначально.
|
|
|
|
|
|
## 4. Завершение сеанса работы с IDLE. |
