Вопрос 3 куда записываются атрибуты объекта

Ответ. С помощью атрибутов можно менять свойства объекта, которому соответствует элемент.

Ответ. Атрибуты всегда записываются внутри открывающего тега.

Ответ. Список атрибутов отделяется от имени тега одним или несколькими пробелами.

Ответ. Атрибуты отделяется друг от друга одним или несколькими пробелами.

Ответ. Атрибут noshade в теге HR задаёт плоскую линию. По умолчанию браузер рисует линию объёмной.

Ещё примеры: атрибут nowrap запрещает перенос слов на новую строку в табличных клетках (элементы TD и TH ), атрибут readonly запрещает редактирование полей ввода в элементах TEXTAREA и INPUT , атрибут selected устанавливает вариант выбора по умолчанию в элементе OPTION .

Ответ. Атрибуты с параметрами записываются в следующем формате:

Перед знаком равенства и после него могут стоять пробелы.

Тег с атрибутом	Что означает	В режиме умолчания
	Абзац будет выровнен по правому краю.	Выравнивание по левому краю.
	В элементе FONT цвет шрифта будет красным.	Цвет шрифта определяется атрибутом text в теге BODY , а если этот атрибут не задан, то настройками браузера.
	Элемент “изображение” (тег IMG ) связывается с файлом pic.gif .	Нет значения по умолчанию.

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

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

Ответ. Порядок следования атрибутов в теге не важен.

Ответ. Если атрибуты не заданы, будет работать режим “умолчания”, принятый в браузере. Например, текст абзаца будет выравниваться по левому краю (для языков с записью текста слева направо), горизонтальная линия будет выводиться объёмной, текст печататься шрифтом, стандартным для той операционной системы, в которой работает браузер (Times New Roman для Windows).

стилевые свойства, заданные при помощи CSS;
атрибуты тегов;
режим умолчания браузера.

Пользователь может изменить режим умолчания браузера, выбрав в настройках свои значения для цвета фона и текста, задав собственный шрифт (и его размер).

Ответ. В этом атрибуте можно задавать стилевые свойства на языке CSS. В отличие от атрибутов тегов, CSS предлагает более широкий спектр свойств элементов, доступных для изменения. Например, в примере “Сборник газетных вырезок” для элемента BLOCKQUOTE была задана рамка — её нельзя задать с помощью обычных атрибутов:

Тег	Описание	HR	Горизонтальная линия. Конечный тег отсутствует.

Атрибут	Значение	Описание
align	left, right, center, justify	Горизонтальное выравнивание: слева, справа, по центру, по ширине.
noshade	Нет.	Рисование линии одним цветом.
size	Число пикселов.	Толщина линии. Значение по умолчанию зависит от браузера.
width	Число пикселов или процентов.	Длина линии в пикселах или в процентах. По умолчанию width=100% .

Ответ. Цвет фона страницы задаётся атрибутом bgcolor , а цвет текста атрибутом text в теге BODY . Пример:

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

Ответ. Выравнивание текста по горизонтали можно задавать атрибутом align . Значения этого атрибута: left, right, center, justify (выравнивание слева, справа, по центру, по ширине).

Имена и области видимости

Так как поиск атрибутов идет снизу вверх, то в подклассе можно:

заместить атрибут суперкласса;
предоставить атрибут суперкласса;
расширить методы суперкласса за счет их вызова из метода подкласса.

>>> class Super: . def method(self): . print('in Super.method') . >>> class Sub(Super): . def method(self): # Переопределить метод . print('starting Sub.method') # Дополнительное действие . Super.method(self) # Выполнить действие по умолчанию . print(ending Sub.method')

Взаимодействие классов при наследовании

Файл примера specialize.py

Super — имеет методы method и delegate (он хочет метод action в наследнике).
Inheritor — ничего своего, все только наследует от Super.
Replacer — переопределяет Super.method своей собственной версией.
Extender — переопределяет Super.method так, что вызывает и его, для выполнения действий по умолчанию.
Provider — реализует метод action, который ожидается метдом Super.delegate

class Super: def method(self): print('in Super.method') # Поведение по умолчанию def delegate(self): self.action() # Ожидаемый метод class Inheritor(Super): # Наследует методы, как они есть pass class Replacer(Super): # Полностью замещает method def method(self): print('in Replacer.method') class Extender(Super): # Расширяет поведение метода method def method(self): print('starting Extender.method') Super.method(self) print('ending Extender.method') class Provider(Super): # Определяет необходимый метод def action(self): print('in Provider.action') if __name__ == '__main__': for myclass in (Inheritor, Replacer, Extender): print('\n' + myclass.__name__ + '. ') myclass().method() print('\nProvider. ') x = Provider() x.delegate()

Inheritor. in Super.method Replacer. in Replacer.method Extender. starting Extender.method in Super.method ending Extender.method Provider. in Provider.action

Абстрактные суперклассы

Когда класс Provider вызывается метод delegate , начинаются две независимых процедуры поиска.

первый вариант:
- при вызове x.delegate() интерпретатор ищет метод, начиная от класса Provider вверх по дереву наследования.
- Экземпляр x передается в виде аргумента self.
Абстрактный суперкласс — класс, который ожидает, что часть его функционала будет реализована его детьми.

Хороший тон: сделать «абстрактность» неработоспособной, возбуждая NotImplementedError или написав assert (проверяет логическое выражение, если истина, идет дальше, если ложь, то останавливает выполнение с сообщением об ошибке):
```
class Super: def delegate(self): self.action() def action(self): assert False, 'action must be defined!' # При вызове этой версии >>> X = Super() >>> X.delegate() AssertionError: action must be defined! 
```
или через возбуждение исключения
```
class Super: def delegate(self): self.action() def action(self): raise NotImplementedError('action must be defined!') >>> X = Super() >>> X.delegate() NotImplementedError: action must be defined! 
```
Если наследник не реализует метод, то мы получим исключение и у него:
```
>>> class Sub(Super): pass . >>> X = Sub() >>> X.delegate() NotImplementedError: action must be defined! 
```
до тех пор, пока не реализуем:
```
>>> class Sub(Super): . def action(self): print('Реализация тут') . >>> X = Sub() >>> X.delegate() Реализация тут 
```
Абстрактные суперклассы в питоне 2.6 и 3.0

Абстрактный суперкласс можно определить с помощью специальных синтаксических конструкций. Они разные в питоне 2.6 и 3.0

Эти конструкции запретят создавать экземпляры, если методы не будут определены в дереве ниже.

Python 3.0 (подробнее разберем позже):
```
from abc import ABCMeta, abstractmethod class Super(metaclass=ABCMeta): @abstractmethod def method(self, . ): pass 
```
```
class Super: __metaclass__ = ABCMeta @abstractmethod def method(self, . ): pass 
```
Чтобы запретить это для методов delegate и action, напишем эту конструкцию для питона 3.0:
```
>>> from abc import ABCMeta, abstractmethod >>> >>> class Super(metaclass=ABCMeta): . def delegate(self): . self.action() . @abstractmethod . def action(self): . pass >>> X = Super() TypeError: Can’t instantiate abstract class Super with abstract methods action >>> class Sub(Super): pass . >>> X = Sub() TypeError: Can’t instantiate abstract class Sub with abstract methods action >>> class Sub(Super): . def action(self): print('Реализация тут') . >>> X = Sub() >>> X.delegate() Реализация тут 
```
Плюс: получаем ошибку раньше — при создании экземпляра класса, а не при попытке вызвать у экземпляра метод, которого нет.

Минус: увеличение кода.

О декораторах функций (@abstractmethod) и объявлении метаклассов расскажем потом.

Пространство имен
- Неквалифицированные имена (например, Х) располагаются в областях видимости (namespace).
- Квалифицированные имена атрибутов (например, object.X) принадлежат простанствам имен объектов.
- Некоторые области видимости инициализируют пространства имен объектов (в модулях и классах)
Простые имена — глобальные, пока нет =

Правило нахождения имени LEGB.
- Присваивание (X = value) — делает имена локальными, создает или изменяет имя X в текущей локальной области видимости, если имя не объявлено глобальным
- Ссылка (X) — пытается отыскать имя Х по правилу LEGB.
Имена атрибутов: пространства имен объектов

Квалифицированные имена атрибутов ссылаются на атрибуты конкретных объектов и к ним применяются правила, предназначенные для модулей и классов. Для объектов классов и экземпляров эти правила дополняются включением процедуры поиска в дереве наследования:
- Присваивание (object.X = value) Создает или изменяет атрибут с именем X в пространстве имен объекта object, и ничего больше.
Восхождение по дереву наследования происходит только при попытке получить ссылку на атрибут, но не при выполнении операции присваивания.
- Ссылка (object.X) Для объектов, созданных на основе классов, поиск атрибута X производится сначала в объекте object, затем во всех классах, расположенных выше в дереве наследования. В случае объектов, которые создаются не из классов, таких как модули, атрибут X извлекается непосредственно из объекта object.
Классификация имен происходит при =.
```
X = 11 # Глобальное (в модуле) имя/атрибут (X, или manynames.X) def f(): print(X) # Обращение к глобальному имени X (11) def g(): X = 22 # Локальная (в функции) переменная (X, скрывает имя X в модуле) print(X) class C: X = 33 # Атрибут класса (C.X) def m(self): X = 44 # Локальная переменная в методе (X) self.X = 55 # Атрибут экземпляра (instance.X) if __name__ == '__main__': print(X) # 11: модуль (за пределами файла manynames.X) f() # 11: глобальная g() # 22: локальная print(X) # 11: переменная модуля не изменилась obj = C() # Создать экземпляр print(obj.X) # 33: переменная класса, унаследованная экземпляром obj.m() # Присоединить атрибут X к экземпляру print(obj.X) # 55: экземпляр print(C.X) # 33: класс (она же obj.X, если в экземпляре нет X) #print(C.m.X) # ОШИБКА: видима только в методе #print(g.X) # ОШИБКА: видима только в функции 
```
Теперь в другом файле:
```
# otherfile.py import manynames X = 66 print(X) # 66: здешняя глобальная переменная print(manynames.X) # 11: глобальная, ставшая атрибутом в результате импорта manynames.f() # 11: X в manynames, не здешняя глобальная! manynames.g() # 22: локальная в функции, в другом файле print(manynames.C.X) # 33: атрибут класса в другом модуле I = manynames.C() print(I.X) # 33: все еще атрибут класса I.m() print(I.X) # 55: а теперь атрибут экземпляра! 
```
Добавим global и nonlocal:
```
X = 11 # Глобальная в модуле def g1(): print(X) # Ссылка на глобальную переменную в модуле def g2(): global X X = 22 # Изменит глобальную переменную в модуле def h1(): X = 33 # Локальная в функции def nested(): print(X) # Ссылка на локальную переменную в объемлющей функции def h2(): X = 33 # Локальная в функции def nested(): nonlocal X # Инструкция из Python 3.0 X = 44 # Изменит локальную переменную в объемлющей функции 
```
Старайтесь не писать одинаковые имена в разных областях (контекстах)

Словари пространств имен (исследуем какие есть имена)

Пространства имен реализованы как словари и доступны по встроенному атрибуту __dict__

Аналогично объекты классов и экземпляров: обращение к квалифицированному имени — это операция доступа к элементу словаря.
```
>>> class super: . def hello(self): . self.data1 = 'spam' . >>> class sub(super): . def hola(self): . self.data2 = 'eggs' . 
```
- экземпляры по атрибуту __class__ получают ссылку на класс;
- класс по атрибуту __bases__ получает кортеж со ссылками на суперклассы.
```
>>> X = sub() >>> X.__dict__ # Словарь пространства имен экземпляра <> >>> X.__class__ # Класс экземпляра >>> sub.__bases__ # Суперклассы данного класса (,) >>> super.__bases__ # В Python 2.6 возвращает пустой кортеж () (,) 
```
Исследуем экземпляр подкласса:
```
>>> Y = sub() >>> X.hello() >>> X.__dict__ 'data1': 'spam'> >>> X.hola() >>> X.__dict__ 'data1': 'spam', 'data2': 'eggs'> >>> sub.__dict__.keys() ['__module__', '__doc__', 'hola'] >>> super.__dict__.keys() ['__dict__', '__module__', '__weakref__', 'hello', '__doc__'>] >>> Y.__dict__ # до сих пор пустой. <> 
```
Имена с __ определяются автоматически.

Можно доступиться к атрибуту по квалифицированному имени или индексироваться по ключу:
```
>>> X.data1, X.__dict__['data1'] ('spam', 'spam') >>> X.data3 = 'toast' >>> X.__dict__ 'data1': 'spam', 'data3': 'toast', 'data2': 'eggs'> >>> X.__dict__['data3'] = 'ham' >>> X.data3 'ham' 
```
Заметим, что унаследованный атрибут X.hello недоступен через X.__dict__[‘hello’]

Функция dir(object) напоминает вызов object.dict.keys(), но:
- dir — сортирует свой список и включает в него системные атрибуты.
- собирает унаследованные атрибуты (с версии 2.2)
- вместе с атрибутами класса object
```
>>> X.__dict__, Y.__dict__ < ('data1': 'spam', 'data3': 'ham', 'data2': 'eggs'>, <>) >>> list(X.__dict__.keys()) # Необходимо в Python 3.0 ['data1', 'data3', 'data2'] # В Python 2.6 >>> dir(X) ['__doc__', '__module__', 'data1', 'data2', 'data3', 'hello', 'hola'] >>> dir(sub) ['__doc__', '__module__', 'hello', 'hola'] >>> dir(super) ['__doc__', '__module__', 'hello'] # В Python 3.0: >>> dir(X) ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', . часть строк опущена. 'data1', 'data2', 'data3', 'hello', 'hola'] >>> dir(sub) ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', . часть строк опущена. 'hello', 'hola'] >>> dir(super) ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', . часть строк опущена. 'hello' ] 
```
Строки документации (docstring)

Написаны в тройных кавычках.

Автоматически сохраняются интерпретатором в их объектах.

Сделаем блоки документации:
```
"""I am: docstr.__doc__""" def func(args): """I am: docstr.func.__doc__""" pass class spam: """I am: spam.__doc__ or docstr.spam.__doc__""" def method(self, arg): """I am: spam.method.__doc__ or self.method.__doc__""" pass 
```
Доступ к объектам docstr:
```
>>> import docstr >>> docstr.__doc__ 'I am: docstr.__doc__' >>> docstr.func.__doc__ 'I am: docstr.func.__doc__' >>> docstr.spam.__doc__ 'I am: spam.__doc__ or docstr.spam.__doc__' >>> docstr.spam.method.__doc__ 'I am: spam.method.__doc__ or self.method.__doc__' 
```
Сделаем из строк документации help:
```
>>> help(docstr) Help on module docstr: NAME docstr - I am: docstr.__doc__ FILE c:\misc\docstr.py CLASSES spam class spam | I am: spam.__doc__ or docstr.spam.__doc__ | | Methods defined here: | | method(self, arg) | I am: spam.method.__doc__ or self.method.__doc__ FUNCTIONS func(args) I am: docstr.func.__doc__ 
```
Классы и модули
- Модули
  - Это пакеты данных и исполняемого кода.
  - Создаются как файлы с программным кодом на языке Python или как расширения на языке C.
  - Задействуются операцией import.
  - Реализуют новые объекты.
  - Создаются с помощью инструкции class.
  - Задействуются операцией вызова.
  - Всегда располагаются внутри модуля. Кроме того, классы поддерживают дополнительные возможности, недоступные в модулях, такие как перегрузка операторов, создание множества экземпляров и наследование. Несмотря на то что и классы, и модули являются пространствами имен, между ними есть различия.
  Встроенные атрибуты класса
  - __dict__ — Dictionary containing the class’s namespace.
  - __doc__ — Class documentation string or none, if undefined.
  - __name__ — Class name.
  - __module__ — Module name in which the class is defined. This attribute is «__main__» in interactive mode.
  - __bases__ — A possibly empty tuple containing the base classes, in the order of their occurrence in the base class list.
```
#!/usr/bin/python class Employee: 'Common base class for all employees' empCount = 0 def __init__(self, name, salary): self.name = name self.salary = salary Employee.empCount += 1 def displayCount(self): print "Total Employee %d" % Employee.empCount def displayEmployee(self): print "Name : ", self.name, ", Salary: ", self.salary print "Employee.__doc__:", Employee.__doc__ print "Employee.__name__:", Employee.__name__ print "Employee.__module__:", Employee.__module__ print "Employee.__bases__:", Employee.__bases__ print "Employee.__dict__:", Employee.__dict__ 
```
```
Employee.__doc__: Common base class for all employees Employee.__name__: Employee Employee.__module__: __main__ Employee.__bases__: () Employee.__dict__: , 'empCount': 2, 'displayEmployee': , '__doc__': 'Common base class for all employees', '__init__': > 
```
  results matching » «
  
  No results matching » «
  
  Работа с атрибутами объекта в Python
  
  В работе с объектно-ориентированным программированием в Python возникают ситуации, когда необходимо получить список всех атрибутов, которые присутствуют у определенного объекта. Для примера, рассмотрим ситуацию, когда создается класс с некоторыми атрибутами:
```
class MyClass(): def __init__(self, number): self.multi = int(number) * 2 self.str = str(number) object = MyClass(2)
```
  В данном случае, у объекта object класса MyClass есть два атрибута: multi и str . Теперь необходимо получить имена этих атрибутов.
  
  Python предоставляет встроенную функцию dir() , которая возвращает список имён, определённых в текущей области видимости. Если ей передать в качестве аргумента объект, она вернёт список его атрибутов. Пример использования:
```
print(dir(object))
```
  Но стоит отметить, что вместе с атрибутами объекта, dir() возвращает также и все методы этого объекта, включая служебные методы, которые начинаются и заканчиваются двойным подчеркиванием.
  
  Если необходимо получить только пользовательские атрибуты, то можно воспользоваться функцией vars() . Она возвращает словарь, где ключами являются имена атрибутов, а значениями — их значения. Пример использования:
```
print(vars(object))
```
  В результате будет получен словарь вида: . Чтобы получить только имена атрибутов, достаточно обратиться к ключам словаря:
```
print(vars(object).keys())
```
  В результате будет получен список имен атрибутов: [‘multi’, ‘str’] .
  
  Таким образом, Python предоставляет удобные инструменты для работы с атрибутами объектов, позволяющие упростить и ускорить написание кода.
  
  Использование замены атрибутов
  
  Замена атрибутов позволяет инженерной сети изменять способ распространения значений, позволяя объекту динамически транспонировать значения, когда происходит трассировка сети. На практике это позволяет изменять фазы части сети, используя замену атрибутов на отдельном устройстве или соединении, передающем на какой-либо раздел сети, вместо того чтобы изменять атрибут передаваемого значения на всех объектах в этом разделе сети.
  
  Значения замены атрибутов используются для пересчета атрибутов сети в случаях, когда подсеть экспортируется, трассируется или обновляется. Они настраиваются для подсетей на уровне с помощью инструмента Установить определение подсети , чтобы представить определение по умолчанию или стандартное определение для всех подсетей на уровне. Чтобы изменить это определение во время операции (обновления или трассировки), получите доступ к соответствующему инструменту с помощью ModelBuilder или программно через Python.
  
  Замена атрибутов осуществляется путем настройки сетевого атрибута для поля базы данных. Замена — это тип сетевого атрибута, значение которого используется для расчета распространяемого значения для объектов с категорией замещения атрибута, назначенной его типу оборудования. Полученное значение замены затем используется для расчета значения для следующего связанного объекта. Чтобы использовать замену атрибутов, необходимо настроить распространение атрибутов.
  - A, B и C равны 2^2, 2^1 и 2^0, или A = 4, B = 2 и C = 1 соответственно.
  Затем вы настраиваете комбинации, такие как AB = 6, AC = 5, BC = 3 и ABC = 7, путем сложения исходных значений. Это те же значения, которые вы найдете в домене кодированных значений, настроенном для поля Phase . В следующей таблице показаны домены и значения битов для каждой фазы:
  
  Эта информация позволяет настроить информацию, связанную с вашей сетью, которая будет указывать операции трассировки заменить одно значение фазы на другое. Например, замените фазу B, когда присутствует фаза A, или замените обесточенные фазы B и C. В результате такого изменения объект с фазой A рассматриваются как фаза B, а объекты с фазой B или C считаются обесточенными. Эти вычисленные значения сохраняются в другом поле объектов, которые настроены для замены.
  
  Вычисление значений замены
  
  Чтобы правильно рассчитать значения замены и настроить замену атрибутов, вам нужно думать о всех 3 битах, поскольку каждый из них имеет 3 бита под ними, чтобы описать замену того, какими битами должны стать A, B и C. В 3-битной системе приходится иметь дело с 9 битами. В 4-разрядной системе при добавлении нейтрали к A, B и C результат будет 16.
  
  Сосредоточив внимание на примере 3-разрядной системы из решения Electric Utility Network Foundation, в котором A становится B, B становится обесточенным, а C становится обесточенным (ABC->B00), мы можем лучше понять, как производится эта замена. Бит A переключился бы на бит B в этом первом положении, а бит замены был бы равен 7. Для замены обесточенной фазы B или C не требуется указывать никакого значения. Чтобы сделать эту замену используется значение 128, то есть 2 ^ 7.
  
  128 (2^7)
  
  Если же вы хотите заменить фазу B на фазу A, C на B и A на C (ABC-> BCA), результат будет выглядеть как на следующем изображении, где A становится B, B становится C, а C становится A. Чтобы сделать эту замену, будет использоваться значение 140, то есть 2^7 + 2^3 + 2^2 (128 + 8 + 4 = 140).
  
  128 (2^7)
  
  Для получения дополнительной информации об этих примерах замены электрических фаз изучите поле phasessubstituted для уровня Electric Device в словаре данных упомянутого выше решения.
  
  Как значения замены работают с распространением
  - А становится В.
  - B обесточивается.
  - C обесточивается.
  Распространяемым значением следующего связанного объекта будет результат рассчитанного значения замены на тройнике. В приведенном ниже примере тройник имеет значение сетевого атрибута AC, которое пересчитывается в B. Каждый последующий объект с A в своем наборе фаз заменяется на B, пока выполняется аналитическая операция.
  
  На изображении выше значения черной надписи представляют атрибуты сети (фаза), значения фиолетовой надписи представляют сетевой атрибут замены, а синяя надпись представляет значение распространенного сетевого атрибута. Обратите внимание, что объекты, подключенные справа от первого тройника, не отображают распространяемое значение B. Это связано с тем, что объекту тройника назначена категория сети тройник подсети, что позволяет значению замены тройника влиять только на те объекты, которые подключены вне основной линии, линии, на которой тройник находится в середине пролета.
  
  Примечание:
  
  Сетевые объекты, помеченные категорией тройника подсети, должны находиться в середине линии, иначе они станут ошибками при проверке топологии сети.
  
  Объекты, подключенные справа от второго тройника, имеют одно и то же значение, распространяющееся вниз по первому ответвлению (обозначено синим B). Объекты, соединенные ниже второго тройника, имеют подчеркнутую букву B для обозначения новых распространяемых значений, рассчитанных по второму ответвлению.
  
  Замены позволяют продолжать уточнять результаты распространяемых значений. Рассмотрим пример выше с тем, что ниже. В приведенном выше примере второй тройник ниже по потоку находится под напряжением, где замена: A становится B, а B и C обесточиваются. В приведенном ниже примере, где замена: A становится обесточенным, C становится B, и B становится обесточенным; второй последующий тройник обесточен (значение замены 2 справа вместо 128 в примере слева), эффективно обесточивая тройник и любые объекты, отводящиеся от него.
  
  Использование распространения замен
  
  Распространенные значения, в том числе замены атрибутов, не используются для переопределения значений ваших объектов или значений связанных сетевых атрибутов. При экспортировании подсети распространяемые значения сохраняются в извлеченной информации. Когда подсеть обновляется, распространяемые значения могут быть сохранены в поле Propagated Attribute , если оно определено. Это поле задается с помощью инструмента Задать определение подсети при настройке уровня. В этом примере показан уровень с настроенными Распространителями, которые включают атрибут замены, а также атрибут распространения, оба из которых являются необязательными.
  
  С помощью Распространителя, настроенного на изображении выше, при обновлении подсети на этом уровне сетевой атрибут Phases Current , определенный как поле Attribute на изображении, будет распространяться. Если он пересекает объект с категорией подсети Замена атрибутов, он проверит значение замены, используя сетевой атрибут PhasesSubstituted , определенный в поле Substitution Attribute . Результирующее распространяемое значение, включая замену, если применимо, будет записано в поле phaseenergized , определенном в поле Propagated Attribute .
  
  Определение объектов, которые будут использовать атрибуты замены
  
  Сетевая категория замена атрибутов является системной категорией сети, которая позволяет определять, какие типы оборудования будут использоваться для замены атрибутов. Для замены атрибутов будут рассматриваться любые объекты с данной категорией.
  
  Эта категория устанавливается для типов оборудования администратором инженерной сети в момент настройки с помощью инструмента Задать категорию сети . Замену атрибутов можно настроить, запустив инструмент Установить определение подсети для существующего уровня с использованием ModelBuilder или через Python.
  
  Обзор процесса настройки замены атрибутов
  
  Замена атрибутов настраивается администратором инженерной сети. Это необходимые шаги для установления замены атрибутов, основанные на примере, описанном в разделе Распространение атрибутов:
  1. Назначьте категорию сети Замена атрибутов классам для определенных групп оборудования и типов оборудования, например, электрический Тройник из класса объектов Соединение .
  2. Создайте поле для хранения значения, которое будет использоваться для определения способа замены распространяемых значений. Это необходимо только для классов, в которых тип оборудования был установлен с сетевой категорией Замена атрибутов .
  3. Создайте и назначьте домен кодированного значения полю, созданному на шаге 2. Например, значение 128 при декодировании означает, что A становится B, B обесточивается, а C обесточивается в 3-битной системе. Добавьте закодированные значения для представления каждой замены, которую может захотеть сделать пользователь. Примеры, обсуждавшиеся до сих пор для 3 бит, следующие:
  Код Описание
  
  2 C на B, и AB обесточены
  
  128 A на B и BC обесточены
  
  140 A на B, B на C и С на A
  1. Щелкните правой кнопкой мыши инструмент Задать определение подсети в модели и выберите Создать переменную , затем щелкните Из параметра и щелкните Распространители .
  2. Дважды щелкните параметр Распространители , добавленный в модель, и соответствующим образом заполните атрибуты.
  Похожие публикации: