В соответствии с основной задачей, решаемой при проектировании программы, входящие в нее классы могут находиться в разных отношениях. Наиболее простое — отношение независимости классов, то есть независимости порождаемых ими объектов. Более сложное — отношение включения, для которого используют названия «имеет» (has-a) и «включает» (is-part-of).
В теории объектно-ориентированного анализа различают две формы отношения включения – композицию и агрегацию.
При отношении композиции объекты одного класса или нескольких разных классов входят как поля в объект другого (включающего) класса. Таким образом, включенные объекты не существуют без включающего их объекта.
При отношении агрегации объект одного класса объединяет уже существующие объекты других классов. То есть и включающий объект и включаемые в него объекты существуют в некотором смысле самостоятельно. При уничтожении включающего объекта входившие в него объекты сохраняются.
Рассмотрим на примерах особенности реализации на языке С# отношений композиции и агрегации.
Трюк Excel 21. Операции с листом Excel
Определим (программа 13_01.cs) класс «точка на плоскости»: class Point
В классе закрытые поля double x, у определяют координаты точки. Свойства X и Y обеспечивают удобный доступ к координатам точки, представленной объектом класса Point. В классе Point нет явно определенного конструктора и компилятор добавляет открытый конструктор без параметров, при использовании которого координаты создаваемой точки по умолчанию получают нулевые значения.
Объекты класса Point можно по-разному включать в более сложные классы. Возьмем в качестве такого включающего класса класс Circle, объект которого представляет «окружность на плоскости». Объект класса Point (точку) будем использовать в качестве центра окружности.
Начнем с композиции классов и, отложив объяснения, дадим такое определение класса:
double rad; // радиус окружности
Point centre = new Point(); // центр окружности
// свойство для радиуса окружности:
// свойство для получения значения длины окружности:
// свойство для центра окружности:
public void display()
Console.WriteLine(«Centre: X=, Y=; Radius=, Length=», centre.X, centre.Y, this.rad, Len);
В классе Circle два закрытых поля: double rad — радиус окружности и Point centre — ссылка на объект класса Point. Для инициализации этой ссылки используется выражение с операцией new, в котором выполняется явное обращение к конструктору класса Point. Тем самым при создании каждого объекта «окружность» всегда создается в виде его поля объект «точка», определяющий центр окружности.
Три открытых свойства обеспечивают доступ к характеристикам объекта-окружности: Rad — радиус окружности, Len — длина окружности, Centre -центр окружности.
В классе определен открытый метод display(), выводящий координаты центра и значения других характеристик объекта, представляющего окружность.
Получаем текст из input JavaScript. First steps
Так как в классе Circle нет явно определенных конструкторов, то неявно создается конструктор без параметров и поля определяемого с его помощью объекта получают значения по умолчанию.
В следующей программе создан объект класса Circle. Затем с помощью свойств классов Circle и Point изменены значения его полей. Метод display() выводит сведения о характеристиках объекта,
public static void Main()
Circle rim = new Circle();
Результат выполнения программы:
Centre: X=10, Y=20; Radius=3, Length= 18,85
Основное, на что следует обратить внимание, — в программе нет отдельно существующего объекта класса Point. Именно это является основным признаком композиции классов. Объект класса Point явно создаётся только при создании объекта класса Circle.
Не изменяя класс Point, можно следующим образом построить класс «окружность на плоскости», используя агрегацию классов (программа 13_2.cs):
double rad; // радиус окружности
Point centre; // ссылка без инициализации
public Circle(Point p, double rd) // конструктор
public void display()
Console.WriteLine(«Centre: X=, Y=; Radius=, Length=», centre.X, centre.Y, this.rad, Len);
В тексте нового класса Circle показаны полностью только объявления полей и конструктор, первый параметр которого — ссылка на объект класса Point. Свойства и метод display() остались без изменений.
При таком измененном определении класса Circle для создания его объекта необходимо, чтобы уже существовал объект класса Point, с помощью которого в объекте будет определено значение поля centre.
Диаграмма классов, находящихся в отношении агрегации, (см. рис. 13.2), практически та же, что и диаграмма композиции. Только в классе Circle явно присутствует конструктор общего вида.
В следующей программе (в методе Main) создан объект класса Point. Затем с помощью свойств X и Y изменены значения его полей. На основе этого объекта конструктор класса Circle формирует объект «окружность на плоскости». Метод display() выводит сведения о характеристиках построенного объекта,
public static void Main()
Point pt = new Point();
Circle rim = new Circle(pt, 10);
Результат выполнения программы:
Centre: X=10, Y=20; Radius=10, Length=62,83
В отличие от композиции при агрегации в классе Circle нет явной инициализации поля centre. Для обеспечения включения объекта класса Point в объект класса Circle в классе Circle явно определен конструктор, одним из параметров которого служит ссылка на объект класса Point. В теле конструктора значение этой ссылки присваивается полю centre класса Circle.
Источник: studfile.net
Пространство имен и область видимости в Python
Последняя строка «Дзен Питона» гласит: «Пространства имен — отличная штука! Давайте будем использовать ее чаще!» . Что же это за загадочные пространства имен? Давайте сначала узнаем, что такое имя.
Примечание. Если не читали «Дзен Питона», введите import this в интерпретаторе.
Например, когда мы присваиваем a = 2 , 2 — это объект, хранящийся в памяти, а a — это имя, с которым мы его связываем. Мы можем получить адрес объекта в ОЗУ с помощью встроенной функции id () . Давайте посмотрим, как ей пользоваться. Имя (оно же идентификатор) — это просто название, данное объекту. В Python всё — объекты, а имя — это способ доступа к объекту.
# Примечание: вы можете получить другие значения id. a = 2 print(‘id(2) =’, id(2)) print(‘id(a) =’, id(a))
Вывод:
id(2) = 9302208
id(a) = 9302208
Здесь оба аргумента ссылаются на 2 , поэтому у них одинаковый id. Давайте сделаем задачу немного интереснее.
# Примечание: вы можете получить другие значения id. a = 2 print(‘id(a) =’, id(a)) a = a+1 print(‘id(a) =’, id(a)) print(‘id(3) =’, id(3)) b = 2 print(‘id(b) =’, id(b)) print(‘id(2) =’, id(2))
Вывод:
id(a) = 9302208
id(a) = 9302240
id(3) = 9302240
id(b) = 9302208
id(2) = 9302208
Что происходит в программе выше? Давайте рассмотрим это на диаграмме:
Сначала создается объект 2 и с ним связывается имя a . Когда мы обновляем значение a = a + 1 , создается новый объект 3 , и теперь уже a ссылается на этот объект.
Обратите внимание, что id (a) и id (3) выдают одинаковые значения.
Кроме того, когда выполняется строка b = 2 , новое имя b связывается с предыдущим объектом 2 .
Это эффективное решение, поскольку Python не нужно создавать дубликаты объектов. Такая динамическая привязка имен и делает Python мощным. Также имя может относиться к любому типу объекта.
>>> a = 5 >>> a = ‘Привет, мир!’ >>> a = [1,2,3]
Все эти привязки действительны, и a будет ссылаться на три различных типа объектов на разных стадиях. Функции тоже являются объектами, поэтому имя может ссылаться и на них.
def printHello(): print(«Привет!») a = printHello a()
Вывод:
Привет!
Как видите, имя a может ссылаться на функцию и мы можем вызывать ее, используя это имя.
Что такое пространство имен
Теперь, когда мы понимаем, что такое имена, мы можем перейти к понятию пространства имен.
Проще говоря, пространство имен — это набор имен.
В Python вы можете представить себе пространство имен в виде отображения каждого имени, которое вы определили, на соответствующие объекты.
В определенный момент времени могут сосуществовать несколько пространств имен, и все они будут полностью изолированы.
Пространство имен, содержащее все встроенные имена, создается при запуске интерпретатора Python и существует, пока интерпретатор не завершит работу.
По этой причине встроенные функции, такие как id () , print () и т. д., всегда доступны из любой части программы.
Каждый модуль создает свое собственное глобальное пространство имен.
Все разные пространства имен изолированы. Следовательно, одно и то же имя, которое используется в разных модулях, не вызывает противоречий.
В модулях могут быть различные функции и классы. При вызове функции создается локальное пространство имен данной функции. Так же — с классом. Следующая диаграмма поможет лучше понять эту концепцию.
Область видимости переменных
Несмотря на то, что различные пространства имен могут быть определены одновременно, мы не сможем получить доступ ко всем из них в каждой части программы. Тут в игру вступает область видимости.
Область видимости — это часть программы, из которой можно получить доступ к пространству имен напрямую, без какого-либо префикса.
В любой момент работы программы существует как минимум три области видимости:
- область видимости текущей функции, имеющей локальные имена;
- область видимости модуля, имеющего глобальные имена;
- самая внешняя область видимости, хранящая встроенные имена.
Когда объект вызывается внутри функции, Python сначала ищет имя в локальном пространстве имен, затем в глобальном пространстве имен и, наконец, во встроенном пространстве имен.
Если внутри одной функции определена другая, то пространство имен последней будет вложено в локальное пространство первой.
Пример работы области видимости и пространства имен
def outer_function(): b = 20 def inner_function(): c = 30 a = 10
Здесь переменная a находится в глобальном пространстве имен. Переменная b находится в локальном пространстве имен outer_function () , а c находится во вложенном локальном пространстве имен inner_function () .
Когда мы находимся в inner_function () , c является для нас локальной переменной, b нелокальной, а a — глобальной. Мы можем получить доступ к значениям всех трех переменных a , b и c , однако изменять значение мы можем только у c .
Если мы попытаемся изменить значение b , в локальном пространстве имен будет создана новая переменная b , которая отличается от нелокальной версии b . То же самое происходит, когда мы изменяем значение a .
Однако, если мы объявим a как глобальную, все обращения будут направлены к глобальной a . Точно так же, если мы хотим поменять значение переменной b , она должна быть объявлена нелокальной. Следующий пример демонстрирует это.
def outer_function(): a = 20 def inner_function(): a = 30 print(‘a = ‘, a) inner_function() print(‘a = ‘, a) a = 10 outer_function() print(‘a = ‘, a)
Вывод:
a = 30
a = 20
a = 10
В этой программе три разные переменные a определены в отдельных пространствах имен. А в следующей программе не так.
def outer_function(): global a a = 20 def inner_function(): global a a = 30 print(‘a = ‘, a) inner_function() print(‘a = ‘, a) a = 10 outer_function() print(‘a = ‘, a)
Вывод:
a = 30
a = 30
a = 30
Здесь все обращения и объявления относятся к глобальной переменной a благодаря ключевому слову global.
СodeСhick.io — простой и эффективный способ изучения программирования.
Источник: codechick.io
[Кейс] Успешное продвижение молодого сайта
Кейс. Успешное продвижение молодого сайта., Сайт 11 месяцев, посещаемость ~7000 чел/сутки, доход 25000 руб/мес.
Тематика: женская/развлекательная
Возраст: 11 месяцев
Посещаемость: ~7000 чел/сутки
Материал: 400 новостей (рерайт/копипаст)
Доход: ~25000 руб/месяц
Расходы: 5000 руб/месяц
Пузомерки: тИЦ 90/Пр 0
Примерно месяц назад сайт был продан за 320000 рублей и при продаже много людей интересовались методикой продвижения, поэтому было решено создать своеобразный кейс.
Про что я рассказываю:
— где лучше регистрировать домен
— какой использовал движок
— какой материал нужно добавлять
Дополнительно:
— открытая статистика liveinternet.ru
— доступ к статистике metrika.yandex.ru
— скрины популярных запросов
Источник: openssource.bz