# Отчет по теме 8

Коломейцев Дмитрий, А-02-23

## Модули и структурирование программы

### 1. Установка рабочего каталога. Создание рабочего протокола.

В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.

![alt text](pictures/{5BE09682-A24A-40A1-8124-20E491C67708}.png)

### 2. Создание и использование модулей в среде Python.

Модулем в среде Python называется любая часть программного кода на этом языке, записанная в отдельном файле.  В языке Python модули также являются объектами класса module.

Для дальнейшей работы с многомодульными программами были подключены ещё два важных модуля: sys и importlib. Также была проверена корректность установки рабочего каталога.

```py
>>> import sys, importlib
>>> os.getcwd()
    '/home/s0ba4/mpei/python-labs/TEMA8'
```

#### 2.1. Запуск модуля на выполнение через __import__.

С помощью текстового редактора оболочки __IDLE__ в текущем рабочем каталоге был создан файл __Mod1.py__, содержимое которого представлено ниже.

![alt text](pictures/{117F468B-8629-4866-B9B8-FE473ECC9310}.png)

Созданный модуль был запущен с помощью инструкции __import__:

```py
>>> import Mod1
    Mod1: Введите значение = 5
    Mod1: Значение perm1 = 5
>>> type(Mod1) # Определение класса модуля
    <class 'module'>
>>> dir(Mod1) # Получение списка атрибутов модуля
    ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
>>> Mod1.perm1 # Обращение к переменной perm из модуля Mod1
    '5'
```

Повторный запуск модуля с помощью __import__ не происходит, однако при использовании функции __reload__ из импортированного ранее модуля __importlib__ всё работает как надо:

```py
>>> import Mod1 # Ничего не происходит
>>> importlib.reload(Mod1)
	Mod1:Введите значение = 5
	Mod1:Значение perm1= 5
	<module 'Mod1' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod1.py'>
>>> Mod1.perm1
    '3'
```

#### 2.2. Обнаружеие импортированных модулей.

Импортированные модули заносятся в словарь - значение атрибута __sys.modules__, поэтому их можно увидеть с помощью инструкции __keys()__.
```py
>>> print(sorted(sys.modules.keys()))
    ['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
```

Для обеспечения возможности повторного импорта модуля, его нужно удалить из словаря с помощью метода __pop()__:

```py
>>> sys.modules.pop("Mod1")
    <module 'Mod1' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod1.py'>
>>> print(sorted(sys.modules.keys()))
    ['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
>>> import Mod1
    Mod1: Введите значение = 123
    Mod1: Значение perm1 = 123
>>> sys.modules.pop("Mod1")
    <module 'Mod1' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod1.py'>
```

#### 2.3. Запуск модуля на выполнение с помощью __exec()__.

Запуск модуля на выполнение может проводиться и с помощью инструкции __exec()__, однако объект-модуль при этом не создается, а всё созданные при выполнении модуля объекты становятся объектами главной программы.

```py
exec(open("Mod1.py").read())
Mod1:Введите значение = 52
Mod1:Значение perm1= 52
perm1
'52'
exec(open("Mod1.py").read())
Mod1:Введите значение = 1337
Mod1:Значение perm1= 1337
perm1
'1337'
exec(open("Mod1.py").read())
Mod1:Введите значение = 3295297524.423452345234.523452345dffd
Mod1:Значение perm1= 3295297524.423452345234.523452345dffd
perm1
'3295297524.423452345234.523452345dffd'
```

#### 2.4. Использование инструкции __from ... import ...__.

В одном модуле может содержаться несколько программных единиц, поэтому иногда бывает целесообразней осуществлять не импорт модуля целиком, а только некоторой его части. Это можно сделать с помощью следующей конструкции: <br>
__from <Имя модуля> import <Имя объектов для импорта>__

```py
>>> from Mod1 import perm1
    Mod1: Введите значение = 123
    Mod1: Значение perm1 = 123
>>> dir()
    ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'importlib', 'os', 'perm1', 'sys']
>>> "Mod1" in dir() # Модуль Mod1 не появился в памяти
    False
>>> perm1 # Переменная модуля стала переменной главной программы с введенным значением
    '123'
```

Был создан еще один модуль __Mod2.py__:

![alt text](pictures/{B2E2E35D-322F-4C09-85FB-C0FC57394039}.png)

С помощью изученного метода импортирования частей модуля, была импортирована функция __beta__ модуля __Mod2.py__, а затем проверено её наличие и наличие самого модуля в памяти.

```py
>>> from Mod2 import beta
>>> g = beta(2)
    ****BETA****
>>> g
    535.4916555247646
>>> dir()
    ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']
>>> "Mod2" in dir()
    False
>>> alpha() # Функци alpha не была импортирована, поэтому к ней нельзя обратиться
    Traceback (most recent call last):
      File "<pyshell#48>", line 1, in <module>
        alpha()
    NameError: name 'alpha' is not defined
```

Импортировать части модуля можно с заданными им псевдонимами, по которым можно в дальнейшем к ним обращаться:

```py
>>> from Mod2 import alpha as al
>>> al()
    ****ALPHA****
    Значение t = 1000
    '1000'
>>> del al, beta
>>> from Mod2 import alpha as al, beta as bt
>>> del al, bt
>>> from Mod2 import *
>>> tt = alpha()
    ****ALPHA****
    Значение t = 0.12
>>> uu = beta(float(tt))
    ****BETA****
>>> uu
    1.4578913609506803
```

### 3. Создание многомодульных программ.

#### 3.1. Пример простой многомодульной программы.

Создан еще один модуль __Mod0.py__, содержащий программу, вызывающую ранее созданные модули __Mod1.py__ и __Mod2.py__.

![alt text](pictures/{A25C5EAC-92E8-4F23-B8E9-5BE87E9283AC}.png)

Теперь программа состоит из нескольких модулей, которые работают вместе:

```py
>>> sys.modules.pop("Mod1")
    <module 'Mod1' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod1.py'>
>>> sys.modules.pop("Mod2")
    <module 'Mod2' from '/home/s0ba4/mpei/python-labs/TEMA8/Mod2.py'>
>>> import Mod0
    perm1 = 5
    ****ALPHA****
    Значение t = 52
    tt = 52
    ****BETA****
    qq = 8.862788791286627e+70
>>> Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
	'52'
	8.862788791286627e+70
	'5'
```

#### 3.2. Создание многомодульной программы на примере функций из Темы 7.

Еще одним примером многомодульной программы может послужить реализованная в Теме 7 модель системы, состоящей из реального двигателя, тахогенератора и звена типа "Зона нечувствительности".

Все функции, описывающие работу устройств определены в модуль __MM1.py__:

![alt text](pictures/image.png)

Функции, обеспечивающие ввод параметров, формирование входного сигнала и реализацию модели расчета выходного сигнала, записаны в модуль __MM2.py__:

![alt text](pictures/image-1.png)

Наконец, главная программа, запускающая на выполнение остальные модули и выводящая полученный результат, записана в модуль __MM0.py__:

![alt text](pictures/image-2.png)

Пример работы такой многомодульной программы:

```py
>>> import MM0
    k1, T, k2, Xm, A, F, N = 6, 5, 3, 6, 4, 52, 25
	y = [0, 0, 0, 0, 0, 0, 0, -1.9291370981109637, 0.13848804176909013, 13.773276599801669, -20.0742209249815, -37.123925111537424, 87.28337537839631, 71.75055146715692, -291.6798616834719, -74.07241570986423, 865.8067910312374, -174.03948221659053, -2355.7884307777927, 1593.9444577623474, 5875.070618240176, -7209.234247700489, -13141.442258853853, 26326.31674573709, 24651.970202679335]
```

#### 3.3. Области действия объектов в модулях.

Объекты в модулях обладают определенными зонами действия, что будет рассматриваться в последующих примерах.

__Пример 1:__

Обращение изнутри одной функции к другой в рамках одного модуля: 

```py
def alpha():
    print("****ALPHA****")
    print("Вызов функции beta из функции alpha:", beta(0))
    t = input("Значение t = ")
    return t
```

```py
>>> import Mod2
>>> Mod2.alpha()
    ****ALPHA****
    ****BETA****
    Вызов функции beta из функции alpha: 1.0
    Значение t = 123
    '123'
```

Аналогичный пример для второй функции:

```py
def beta(q):
    print("****BETA****")
    print("Вызов функции alpha из функции beta:", alpha())
    import math
    expi = q * math.pi
    return math.exp(expi)
```

```py
>>> import Mod2
>>> Mod2.beta(4)
    ****BETA****
    ****ALPHA****
    Значение t = 5
    Вызов функции alpha из функции beta: 5
    286751.31313665316
```

__Пример 2:__

Отображение во внешнем модуле объектов внутреннего модуля:

```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)
```

```py
>>> import Mod0
    Mod1: Введите значение = 1
    Mod1: Значение perm1 = 1
    perm1 = 1
    ****ALPHA****
    Значение t = 2
    tt = 2
    ****BETA****
    qq = 535.4916555247646
    Traceback (most recent call last):
      File "<pyshell#106>", line 1, in <module>
         import Mod0
      File "/home/s0ba4/mpei/python-labs/TEMA8/Mod0.py", line 10, in <module>
         print("t =", t, " expi =", expi)
    NameError: name 't' is not defined. Did you mean: 'tt'?
```

При закомментировании обращения к переменной __t__, всё равно будет ошибка, так как переменная __expi__ также определена в другом модуле и напрямую доступа к ней нет.

```py
>>> import Mod0
    Mod1: Введите значение = 1
    Mod1: Значение perm1 = 1
    perm1 = 1
    ****ALPHA****
    Значение t = 2
    tt = 2
    ****BETA****
    qq = 535.4916555247646
    Traceback (most recent call last):
      File "<pyshell#111>", line 1, in <module>
        import Mod0
      File "/home/s0ba4/mpei/python-labs/TEMA8/Mod0.py", line 11, in <module>
        print("expi =", expi)
    NameError: name 'expi' is not defined
```

__Пример 3:__

Изменение значений объектов внутреннего модуля во внешнем модуле:

```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 * 3 =", Mod1.perm1)
```

Данный код будет работать, так как обращение к перменной __perm1__ происходит не напрямую, а с указанием родительского модуля - __Mod1__.

```py
>>> import Mod0
    Mod1: Введите значение = 1
    Mod1: Значение perm1 = 1
    perm1 = 1
    ****ALPHA****
    Значение t = 2
    tt = 2
    ****BETA****
    qq = 535.4916555247646
    perm1 * 3 = 111 #
```

__Пример 4:__

Изменение значений объектов модуля из командной строки:

```py
>>> import Mod0
    Mod1: Введите значение = 3
    Mod1: Значение perm1 = 3
    perm1 = 3
    ****ALPHA****
    Значение t = 2
    tt = 2
    ****BETA****
    qq = 535.4916555247646
>>> perm1 *= 2
    Traceback (most recent call last):
      File "<pyshell#121>", line 1, in <module>
        perm1 *= 2
    NameError: name 'perm1' is not defined
>>> tt *= 2
    Traceback (most recent call last):
      File "<pyshell#122>", line 1, in <module>
        tt *= 2
    NameError: name 'tt' is not defined
>>> qq *= 2
    Traceback (most recent call last):
      File "<pyshell#123>", line 1, in <module>
        qq *= 2
    NameError: name 'qq' is not defined
```

__Вывод:__

Объекты, определённые внутри модуля, принадлежат его внутренней области видимости, поэтому к ним можно обращаться напрямую только внутри самого модуля. Во внешних программах доступ к таким переменным возможен только через указание имени модуля, то есть родителя.

### 4. Завершение работы со средой.

Сохранил файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.