Модульное программирование: атрибуты и методы

Многоуровневая вложенность

До сих пор мы рассматривали двухуровневую структуру модуля. На уровне модуля задавалась глобальная информация, на уровне метода - локальная. Имена методов являлись глобальными, имена формальных параметров - локальными.

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

На число уровней вложенности не накладывается ограничений, хотя содержательно трудно представить более чем трехуровневую структуру. По отношению к вложенному методу, имена, введенные в охватывающем методе, являются глобальными, - они доступны во вложенном методе. Более того, вложенный метод может изменять значения таких объектов. Но, как и в случае с глобальными именами, прежде чем присвоить новое значение имени, введенному в охватывающем методе, такое имя нужно объявить, как нелокальное имя. Для такого объявления используется ключевое слово nonlocal:

nonlocal <кортеж имен охватывающего метода>

Заметьте, имена в теле метода могут иметь три различных статуса: локальные, нелокальные и глобальные.

Придумать простые содержательные примеры многоуровневой структуры непросто. Я начну с достаточно сложного для понимания примера, носящего скорее формальный характер. Тем не менее он хорошо демонстрирует возможности функционального программирования языка Python .

Ранее мы рассматривали функции высших порядков, которые имеют функции в качестве аргументов. В данном примере я построю функцию f_cover(x), которая в качестве результата возвращает функцию. Естественно, определить возвращаемую функцию в теле функции f_cover(x). Так появляется трехуровневая структура. Вложенная функция f_inside(x) будет иметь параметр и использовать локальную переменную охватывающей функции как глобальную информацию. Более того, вложенная функция будет изменять эту глобальную переменную в качестве побочного эффекта, используя механизм nonlocal переменных. Приводимый код имеет небольшой размер, но стоит его изучить внимательно:

def f_cover(x):
    """
    Вложенные функции. Nonlocal переменные
    """
    y = x + 7
    def f_inside(x):
        nonlocal y
        y = y + 10
        return x + y    
    return f_inside

Давайте построим тест, в котором будет вызвана функция f_cover:

def test5():
    f = f_cover(1)
    res = f(2)
    print("res = ", res)
    res = f(2)
    print("res = ", res)
    res = f(2)
    print("res = ", res)
test5()

Заметьте, имя функции f_inside - это локальное имя и непосредственно вызвать эту функцию по имени не представляется возможным, но имя f можно связать с функцией, возвращаемой в результате вызова f_cover (по сути с функцией f_inside) и функцию f можно вызывать многократно.

Вот результат вычислений:

Обратите внимание, результаты вызова функции с одним и тем же аргументом разные, поскольку возвращаемое значение зависит от глобального для этой функции аргумента у, которое изменяется при каждом вызове.

Мы построили пример трехуровневой структуры с использованием nonlocal переменных. Построим теперь содержательный пример трехуровневой структуры, чаще встречающийся на практике. Я уже говорил, что одно из основных назначений модуля - предоставлять сервисы, многократно используемые другими модулями. Классическим примером является пакет math. Сервис реализуется как метод модуля. Если метод сложный, то применяется декомпозиция и в результате появляются более простые методы. Возникает дилемма, на каком уровне определять эти вспомогательные методы, - на уровне модуля или встраивать их в тело метода, для которого строится декомпозиция. Зачастую, второй способ предпочтительнее, поскольку на глобальном уровне видны только методы, представляющие сервис, а вспомогательные методы скрыты (инкапсулированы) и недоступны для вызова.

В качестве примера работы такого подхода рассмотрим задачу вычисления площади выпуклого многоугольника, заданного списком координат вершин многоугольника. Список начинается с некоторой вершины А с перечислением всех вершин при обходе вершин по часовой стрелке. Декомпозиция метода достаточно очевидна. Соединим вершину А с остальными вершинами, разбив многоугольник на треугольники. Сумма площадей треугольников даст искомую площадь. Тройка вершин каждого треугольника, позволяет определить размеры сторон треугольника, а затем по формуле Герона вычислить его площадь.

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

def PolygonSquare(vertices: list)->float:
    """
    Площадь выпуклого многоугольника,
    заданного списком его вершин - vertices
    """
    import math
    def Side (A:tuple, B:tuple)->float:
    
        x1 = A[0]; y1 =A[1]
        x2 = B[0]; y2 =B[1]
        s = math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
        return s

    def Geron(s1:float, s2: float, s3:float)-> float:
        p = (s1 + s2 + s3) / 2;
        return math.sqrt(p * (p - s1) * (p - s2) * (p - s3))
    
    def TriangleSquare()->float:
        sideAB = Side(A, B)
        sideAC = Side(A, C)
        sideBC = Side(B, C)
        s = Geron(sideAB, sideBC, sideAC)
        return s

    sp = 0
    n = len(vertices)
    A = vertices[0]
    for i in range(n-2):
        B = vertices[i+1]
        C= vertices[i+2] 
        st = TriangleSquare()
        sp += st
    return sp

Заметьте, тройка вершин А, В, С является глобальной информацией для встроенного метода TriangleSquare. Этот метод не имеет параметров и всю информацию получает через глобальные переменные. Другим методам нужны параметры.

Построим простой тест, вычисляющий площадь квадрата:

def test6():
    vertices= [(0, 0),(0, 1), (1, 1), (1, 0)]
    square = PolygonSquare(vertices)
    print('площадь мноугольника = ', square)
test6()

Вот результаты: