Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Python object-oriented programming: export from Russian Wikipedia (with edits history) for import to Russian Wikibooks
This file has been truncated, but you can view the full file.
<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.10/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.10/ http://www.mediawiki.org/xml/export-0.10.xsd" version="0.10" xml:lang="ru">
<siteinfo>
<sitename>Википедия</sitename>
<dbname>ruwiki</dbname>
<base>https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D0%B0</base>
<generator>MediaWiki 1.33.0-wmf.6</generator>
<case>first-letter</case>
<namespaces>
<namespace key="-2" case="first-letter">Медиа</namespace>
<namespace key="-1" case="first-letter">Служебная</namespace>
<namespace key="0" case="first-letter" />
<namespace key="1" case="first-letter">Обсуждение</namespace>
<namespace key="2" case="first-letter">Участник</namespace>
<namespace key="3" case="first-letter">Обсуждение участника</namespace>
<namespace key="4" case="first-letter">Википедия</namespace>
<namespace key="5" case="first-letter">Обсуждение Википедии</namespace>
<namespace key="6" case="first-letter">Файл</namespace>
<namespace key="7" case="first-letter">Обсуждение файла</namespace>
<namespace key="8" case="first-letter">MediaWiki</namespace>
<namespace key="9" case="first-letter">Обсуждение MediaWiki</namespace>
<namespace key="10" case="first-letter">Шаблон</namespace>
<namespace key="11" case="first-letter">Обсуждение шаблона</namespace>
<namespace key="12" case="first-letter">Справка</namespace>
<namespace key="13" case="first-letter">Обсуждение справки</namespace>
<namespace key="14" case="first-letter">Категория</namespace>
<namespace key="15" case="first-letter">Обсуждение категории</namespace>
<namespace key="100" case="first-letter">Портал</namespace>
<namespace key="101" case="first-letter">Обсуждение портала</namespace>
<namespace key="102" case="first-letter">Инкубатор</namespace>
<namespace key="103" case="first-letter">Обсуждение Инкубатора</namespace>
<namespace key="104" case="first-letter">Проект</namespace>
<namespace key="105" case="first-letter">Обсуждение проекта</namespace>
<namespace key="106" case="first-letter">Арбитраж</namespace>
<namespace key="107" case="first-letter">Обсуждение арбитража</namespace>
<namespace key="828" case="first-letter">Модуль</namespace>
<namespace key="829" case="first-letter">Обсуждение модуля</namespace>
<namespace key="2300" case="first-letter">Гаджет</namespace>
<namespace key="2301" case="first-letter">Обсуждение гаджета</namespace>
<namespace key="2302" case="case-sensitive">Определение гаджета</namespace>
<namespace key="2303" case="case-sensitive">Обсуждение определения гаджета</namespace>
<namespace key="2600" case="first-letter">Тема</namespace>
</namespaces>
</siteinfo>
<page>
<title>Объектно-ориентированное программирование на Python</title>
<ns>0</ns>
<id>478924</id>
<revision>
<id>3045135</id>
<timestamp>2007-01-29T18:20:09Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>Создание страницы</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="264">С самого начала [[Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]].</text>
<sha1>6qcuzpq7v1ntkywir7mmj7ygxjq10xz</sha1>
</revision>
<revision>
<id>3045169</id>
<parentid>3045135</parentid>
<timestamp>2007-01-29T18:22:28Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="417">С самого начала [[Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]]. На языке Питон писать программы в объектно-ориентированном стиле просто и приятно.</text>
<sha1>8419btwv02jgs5ep1s4m8dj1hxnzn8q</sha1>
</revision>
<revision>
<id>3045208</id>
<parentid>3045169</parentid>
<timestamp>2007-01-29T18:26:00Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="488">С самого начала [[Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]]. На языке Питон писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова.'''</text>
<sha1>bt8qmrvzt7lpk1okhoz35qc3dp5hmzi</sha1>
</revision>
<revision>
<id>3045424</id>
<parentid>3045208</parentid>
<timestamp>2007-01-29T18:39:53Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="517">С самого начала [[Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]]. На языке Питон писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''</text>
<sha1>45l2yjpfztsxxag2uulx1flwu924l99</sha1>
</revision>
<revision>
<id>3045447</id>
<parentid>3045424</parentid>
<timestamp>2007-01-29T18:41:03Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="524">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]]. На языке Питон писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''</text>
<sha1>ochm21zolniszs4o4xamr71s52bx0kg</sha1>
</revision>
<revision>
<id>3045458</id>
<parentid>3045447</parentid>
<timestamp>2007-01-29T18:41:28Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="515">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]]. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''</text>
<sha1>n9txalyl9cvz7lzrr4hq8gqjxcjcfvy</sha1>
</revision>
<revision>
<id>3071142</id>
<parentid>3045458</parentid>
<timestamp>2007-01-31T15:41:20Z</timestamp>
<contributor>
<username>Valodzka</username>
<id>7840</id>
</contributor>
<minor/>
<comment>+{{источник?}}</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="536">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]]{{источник?}}. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''</text>
<sha1>5xyh6qs6098xz45ghyuhfu0mxyl3miy</sha1>
</revision>
<revision>
<id>3073259</id>
<parentid>3071142</parentid>
<timestamp>2007-01-31T18:20:57Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="1446">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]]{{источник?}}. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''
== Введение ==
=== Принципы ООП ===
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==</text>
<sha1>g04zvgp43x7nzyfxwiav6uk9jqatfaf</sha1>
</revision>
<revision>
<id>3073632</id>
<parentid>3073259</parentid>
<timestamp>2007-01-31T18:46:15Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="1527">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]]{{источник?}}. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''
== Введение ==
=== Принципы ООП ===
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Цитаты и ссылки ==
* http://www.ercb.com/ddj/1997/ddj.9711.html</text>
<sha1>19ojsdj75l4wq49dawmo1c947jchakm</sha1>
</revision>
<revision>
<id>3073743</id>
<parentid>3073632</parentid>
<timestamp>2007-01-31T18:53:34Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="1653">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]]
&lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;
{{источник?}}. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''
== Введение ==
=== Принципы ООП ===
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Цитаты и ссылки ==
* http://www.ercb.com/ddj/1997/ddj.9711.html</text>
<sha1>dguoxwiunw0u1aukqlmzudr2exbqkf9</sha1>
</revision>
<revision>
<id>3073776</id>
<parentid>3073743</parentid>
<timestamp>2007-01-31T18:55:40Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="1590">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''
== Введение ==
=== Принципы ООП ===
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Примечания ==
{{reflist|2}}</text>
<sha1>jvsapguth3sgdnbbelducrs5nihh7y9</sha1>
</revision>
<revision>
<id>3074082</id>
<parentid>3073776</parentid>
<timestamp>2007-01-31T19:16:33Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Введение */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="2010">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''
== Введение ==
=== Принципы ООП ===
Согласно Алану Кэю &lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt; - автору объектно-ориентированного языка Смолтолк - объектно-ориентированным может называться язык, построенный с учетом следующих принципов:
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Примечания ==
{{reflist|2}}</text>
<sha1>mdd86ig4nzw4jsdfu0214101ofr6dxo</sha1>
</revision>
<revision>
<id>3074151</id>
<parentid>3074082</parentid>
<timestamp>2007-01-31T19:21:26Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Принципы ООП */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="2030">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] &lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt; - автору объектно-ориентированного языка Смолтолк - объектно-ориентированным может называться язык, построенный с учетом следующих принципов:
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Примечания ==
{{reflist|2}}</text>
<sha1>71dby8sv6xl533s9r8g172go6xx07p8</sha1>
</revision>
<revision>
<id>3074159</id>
<parentid>3074151</parentid>
<timestamp>2007-01-31T19:21:54Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Принципы ООП */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="1980">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
'''Извините, эта статья еще не готова. (см. Обсуждение)'''
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] &lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt; - автору языка Смолтолк - объектно-ориентированным может называться язык, построенный с учетом следующих принципов:
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Примечания ==
{{reflist|2}}</text>
<sha1>8ln5cja1hxv8goxrirf900h31ss6qeb</sha1>
</revision>
<revision>
<id>3074185</id>
<parentid>3074159</parentid>
<timestamp>2007-01-31T19:23:55Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="1880">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] &lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt; - автору языка Смолтолк - объектно-ориентированным может называться язык, построенный с учетом следующих принципов:
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Примечания ==
{{reflist|2}}</text>
<sha1>7b6w4aodbow2q6lnu02jfe5x51umvid</sha1>
</revision>
<revision>
<id>3074280</id>
<parentid>3074185</parentid>
<timestamp>2007-01-31T19:30:55Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Принципы ООП */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="2633">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] &lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt; - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Примечания ==
{{reflist|2}}</text>
<sha1>da6exsse9jocwluy0bcj2al16udoa4z</sha1>
</revision>
<revision>
<id>3074286</id>
<parentid>3074280</parentid>
<timestamp>2007-01-31T19:31:34Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Принципы ООП */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="2632">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Примечания ==
{{reflist|2}}</text>
<sha1>gr8qnip11tn82eeuehlhxralak493gv</sha1>
</revision>
<revision>
<id>3074323</id>
<parentid>3074286</parentid>
<timestamp>2007-01-31T19:33:24Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Принципы ООП */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="2697">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Примечания ==
{{reflist|2}}</text>
<sha1>9piiv146ziufaetyz2q1ejajud9wepp</sha1>
</revision>
<revision>
<id>3074420</id>
<parentid>3074323</parentid>
<timestamp>2007-01-31T19:37:25Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Определение класса */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="2990">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения методов класса
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Примечания ==
{{reflist|2}}</text>
<sha1>kwu6dhla4c71cno1qnch7j3n9p4eif4</sha1>
</revision>
<revision>
<id>3074447</id>
<parentid>3074420</parentid>
<timestamp>2007-01-31T19:38:48Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="3009">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения методов класса
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}</text>
<sha1>bpsqcg82aqbf6p6y1ey4ydfcmqwv9ao</sha1>
</revision>
<revision>
<id>3074711</id>
<parentid>3074447</parentid>
<timestamp>2007-01-31T19:57:20Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Определение класса */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="4695">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
def myMethod(self, x):
return x * x
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}</text>
<sha1>gia8summh0n8kabkugabg2tgnn9uxw3</sha1>
</revision>
<revision>
<id>3074834</id>
<parentid>3074711</parentid>
<timestamp>2007-01-31T20:05:06Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Определение класса */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5048">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}</text>
<sha1>63g57csp3xftv7brw3jrx8zg41yztjl</sha1>
</revision>
<revision>
<id>3074863</id>
<parentid>3074834</parentid>
<timestamp>2007-01-31T20:06:25Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Наследование и множественное наследование */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5115">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}</text>
<sha1>n2qelndw3svt727oiq9mrv170m237hi</sha1>
</revision>
<revision>
<id>3074927</id>
<parentid>3074863</parentid>
<timestamp>2007-01-31T20:10:29Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Объекты, типы и классы */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="5116">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}</text>
<sha1>p6cydms1fbdmj8elu5nq8jxc6pfzh9z</sha1>
</revision>
<revision>
<id>3083000</id>
<parentid>3074927</parentid>
<timestamp>2007-02-01T15:36:10Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Инкапсуляция и доступ к свойствам */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="8012">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени (используются достаточно редко в реальном коде) дают несколько большую защиту: атрибут перестает быть доступен по этому имени. Последнее используется достаточно редко.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответсвующих методах.
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}</text>
<sha1>1tuebuzt52l49c21ars9l3b2jjz656q</sha1>
</revision>
<revision>
<id>3083027</id>
<parentid>3083000</parentid>
<timestamp>2007-02-01T15:40:30Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Инкапсуляция и доступ к свойствам */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="8340">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени (используются достаточно редко в реальном коде) дают несколько большую защиту: атрибут перестает быть доступен по этому имени. Последнее используется достаточно редко.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
В некоторых случаях атрибуты класса являются полностью динамическими и доступы к таким атрибутам можно контролировать методами &lt;code&gt;.__getattr__()&lt;/code&gt;, &lt;code&gt;.__setattr__()&lt;/code&gt;, &lt;code&gt;.__delattr__()&lt;/code&gt;.
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}</text>
<sha1>5aje02mkop3taw02d3enc66ur8h6ktz</sha1>
</revision>
<revision>
<id>3083033</id>
<parentid>3083027</parentid>
<timestamp>2007-02-01T15:41:06Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Инкапсуляция и доступ к свойствам */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="8338">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени (используются достаточно редко в реальном коде) дают несколько большую защиту: атрибут перестает быть доступен по этому имени. Последнее используется достаточно редко.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
В некоторых случаях атрибуты класса являются полностью динамическими и доступ к таким атрибутам можно контролировать методами &lt;code&gt;.__getattr__()&lt;/code&gt;, &lt;code&gt;.__setattr__()&lt;/code&gt;, &lt;code&gt;.__delattr__()&lt;/code&gt;.
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}</text>
<sha1>px1837ksi11zi4r52g75tebtv3ytibq</sha1>
</revision>
<revision>
<id>3090093</id>
<parentid>3083033</parentid>
<timestamp>2007-02-02T05:26:47Z</timestamp>
<contributor>
<username>Ale012</username>
<id>40484</id>
</contributor>
<comment>категория</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="8395">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени (используются достаточно редко в реальном коде) дают несколько большую защиту: атрибут перестает быть доступен по этому имени. Последнее используется достаточно редко.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
В некоторых случаях атрибуты класса являются полностью динамическими и доступ к таким атрибутам можно контролировать методами &lt;code&gt;.__getattr__()&lt;/code&gt;, &lt;code&gt;.__setattr__()&lt;/code&gt;, &lt;code&gt;.__delattr__()&lt;/code&gt;.
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>64zljrvfi3s1kzn9bp3qar1i2vswfdw</sha1>
</revision>
<revision>
<id>3096398</id>
<parentid>3090093</parentid>
<timestamp>2007-02-02T17:13:39Z</timestamp>
<contributor>
<username>Koder</username>
<id>27335</id>
</contributor>
<comment>/* Инкапсуляция и доступ к свойствам */ дополнение, обновление данных</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="11017">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени дают несколько большую защиту: атрибут перестает быть доступен по этому имени.Последнее используется достаточно редко.
Есть существенное отличие между такими атрибутами и личными (private) членами класса в таких
языках как [[C++]] или [[Java]]: атрибут остается доступным, но под именем вида
&lt;code&gt;_ИмяКласса__ИмяАтрибута&lt;/code&gt;, а при каждом обращении &lt;code&gt;Python&lt;/code&gt; будет модифицировать имя в зависимости
от того экземпляр какого класса обращается к атрибуту . Таким образом родительский и дочерний
классы могут иметь атрибут с именем, например, "__f" но не будут мешать друг другу.
&gt;&gt;&gt; class parent(object):
def __init__(self):
self.__f = 2
def get(self):return self.__f
....
&gt;&gt;&gt; class child(parent):
def __init__(self):
self.__f = 1
parent.__init__(self)
def cget(self):return self.__f
....
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.get()
2
&gt;&gt;&gt; c.cget()
1
&gt;&gt;&gt; c.__dict__
{'_child__f': 1, '_parent__f': 2} #на самом деле у объекта "с" два разных атрибута
Особым случаем является наличие двух подчеркиваний в начале и в конце имени - такие атрибуты
используются для специальных свойств и функций класса(например для перегрузки операции).
Такие атрибуты доступны по своему имени, но их использование зарезервировано для специальных
атрибутов, изменяющих поведение объекта.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
Есть два способа централизованно контролировать доступ к атрибутам - первый основан на перегрузке
методов &lt;code&gt;__getattr__()&lt;/code&gt;, &lt;code&gt;__setattr__()&lt;/code&gt;, &lt;code&gt;__delattr__()&lt;/code&gt;.
А второй на перегрузке методов &lt;code&gt;__getattribute__()&lt;/code&gt;, &lt;code&gt;__setattribute__()&lt;/code&gt;, &lt;code&gt;__delattribute__()&lt;/code&gt; . Второй метод позволяет более жесткий контроль, например контролируя чтение уже существующих атрибутов.
Эти способы позволяют организовать полностью динамический доступ к атрибутам объекта или, что используется очень часто, имитации несуществующих атрибутов. По такому принципу функционируют, например, все системы [[RPC]] Python - имитируя функции и поля реально существующие на удаленном сервере.
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>22vj1e282row025q2mp3a0pqi9ftib6</sha1>
</revision>
<revision>
<id>3101331</id>
<parentid>3096398</parentid>
<timestamp>2007-02-03T08:59:30Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Инкапсуляция и доступ к свойствам */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="10984">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени дают несколько большую защиту: атрибут перестает быть доступен по этому имени.Последнее используется достаточно редко.
Есть существенное отличие между такими атрибутами и личными (private) членами класса в таких
языках как [[C++]] или [[Java]]: атрибут остается доступным, но под именем вида
&lt;code&gt;_ИмяКласса__ИмяАтрибута&lt;/code&gt;, а при каждом обращении &lt;code&gt;Python&lt;/code&gt; будет модифицировать имя в зависимости
от того экземпляр какого класса обращается к атрибуту . Таким образом родительский и дочерний
классы могут иметь атрибут с именем, например, "__f" но не будут мешать друг другу.
&gt;&gt;&gt; class parent(object):
def __init__(self):
self.__f = 2
def get(self):return self.__f
....
&gt;&gt;&gt; class child(parent):
def __init__(self):
self.__f = 1
parent.__init__(self)
def cget(self):return self.__f
....
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.get()
2
&gt;&gt;&gt; c.cget()
1
&gt;&gt;&gt; c.__dict__
{'_child__f': 1, '_parent__f': 2} #на самом деле у объекта "с" два разных атрибута
Особым случаем является наличие двух подчеркиваний в начале и в конце имени - такие атрибуты
используются для специальных свойств и функций класса(например для перегрузки операции).
Такие атрибуты доступны по своему имени, но их использование зарезервировано для специальных
атрибутов, изменяющих поведение объекта.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
Есть два способа централизованно контролировать доступ к атрибутам. Первый основан на перегрузке
методов &lt;code&gt;__getattr__()&lt;/code&gt;, &lt;code&gt;__setattr__()&lt;/code&gt;, &lt;code&gt;__delattr__()&lt;/code&gt;,
а второй - методов &lt;code&gt;__getattribute__()&lt;/code&gt;, &lt;code&gt;__setattribute__()&lt;/code&gt;, &lt;code&gt;__delattribute__()&lt;/code&gt; . Второй метод позволяет более жесткий контроль, например, чтение уже существующих атрибутов.
Эти способы позволяют организовать полностью динамический доступ к атрибутам объекта или, что используется очень часто, имитации несуществующих атрибутов. По такому принципу функционируют, например, все системы [[RPC]] для Python, имитируя методы и свойства, реально существующие на удаленном сервере.
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>tiboawz0s4okkheqe5a3sez9cupsv18</sha1>
</revision>
<revision>
<id>3101670</id>
<parentid>3101331</parentid>
<timestamp>2007-02-03T09:54:35Z</timestamp>
<contributor>
<username>Koder</username>
<id>27335</id>
</contributor>
<minor/>
<comment>/* Инкапсуляция и доступ к свойствам */ стилевые правки</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="11007">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени дают несколько большую защиту: атрибут перестает быть доступен по этому имени.Последнее используется достаточно редко.
Есть существенное отличие между такими атрибутами и личными (private) членами класса в таких
языках как [[C++]] или [[Java]]: атрибут остается доступным, но под именем вида
&lt;code&gt;_ИмяКласса__ИмяАтрибута&lt;/code&gt;, а при каждом обращении &lt;code&gt;Python&lt;/code&gt; будет модифицировать имя в зависимости
от того экземпляр какого класса обращается к атрибуту . Таким образом родительский и дочерний
классы могут иметь атрибут с именем, например, "__f" но не будут мешать друг другу.
&gt;&gt;&gt; class parent(object):
def __init__(self):
self.__f = 2
def get(self):return self.__f
....
&gt;&gt;&gt; class child(parent):
def __init__(self):
self.__f = 1
parent.__init__(self)
def cget(self):return self.__f
....
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.get()
2
&gt;&gt;&gt; c.cget()
1
&gt;&gt;&gt; c.__dict__
{'_child__f': 1, '_parent__f': 2} #на самом деле у объекта "с" два разных атрибута
Особым случаем является наличие двух подчеркиваний в начале и в конце имени - такие атрибуты
используются для специальных свойств и функций класса(например для перегрузки операции).
Такие атрибуты доступны по своему имени, но их использование зарезервировано для специальных
атрибутов, изменяющих поведение объекта.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
Есть два способа централизованно контролировать доступ к атрибутам. Первый основан на перегрузке
методов &lt;code&gt;__getattr__()&lt;/code&gt;, &lt;code&gt;__setattr__()&lt;/code&gt;, &lt;code&gt;__delattr__()&lt;/code&gt;,
а второй - методов &lt;code&gt;__getattribute__()&lt;/code&gt;, &lt;code&gt;__setattribute__()&lt;/code&gt;, &lt;code&gt;__delattribute__()&lt;/code&gt; . Второй метод позволяет более жесткий контроль, например, управление чтением уже существующих атрибутов.
Эти способы позволяют организовать полностью динамический доступ к атрибутам объекта или, что используется очень часто, имитации несуществующих атрибутов. По такому принципу функционируют, например, все системы [[RPC]] для Python, имитируя методы и свойства, реально существующие на удаленном сервере.
=== Полиморфизм ===
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>pvsrb5zxljy6bfibwrw7ulekpj8r5r4</sha1>
</revision>
<revision>
<id>3102285</id>
<parentid>3101670</parentid>
<timestamp>2007-02-03T11:14:25Z</timestamp>
<contributor>
<username>Koder</username>
<id>27335</id>
</contributor>
<comment>/* Полиморфизм */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="13563">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени дают несколько большую защиту: атрибут перестает быть доступен по этому имени.Последнее используется достаточно редко.
Есть существенное отличие между такими атрибутами и личными (private) членами класса в таких
языках как [[C++]] или [[Java]]: атрибут остается доступным, но под именем вида
&lt;code&gt;_ИмяКласса__ИмяАтрибута&lt;/code&gt;, а при каждом обращении &lt;code&gt;Python&lt;/code&gt; будет модифицировать имя в зависимости
от того экземпляр какого класса обращается к атрибуту . Таким образом родительский и дочерний
классы могут иметь атрибут с именем, например, "__f" но не будут мешать друг другу.
&gt;&gt;&gt; class parent(object):
def __init__(self):
self.__f = 2
def get(self):return self.__f
....
&gt;&gt;&gt; class child(parent):
def __init__(self):
self.__f = 1
parent.__init__(self)
def cget(self):return self.__f
....
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.get()
2
&gt;&gt;&gt; c.cget()
1
&gt;&gt;&gt; c.__dict__
{'_child__f': 1, '_parent__f': 2} #на самом деле у объекта "с" два разных атрибута
Особым случаем является наличие двух подчеркиваний в начале и в конце имени - такие атрибуты
используются для специальных свойств и функций класса(например для перегрузки операции).
Такие атрибуты доступны по своему имени, но их использование зарезервировано для специальных
атрибутов, изменяющих поведение объекта.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
Есть два способа централизованно контролировать доступ к атрибутам. Первый основан на перегрузке
методов &lt;code&gt;__getattr__()&lt;/code&gt;, &lt;code&gt;__setattr__()&lt;/code&gt;, &lt;code&gt;__delattr__()&lt;/code&gt;,
а второй - методов &lt;code&gt;__getattribute__()&lt;/code&gt;, &lt;code&gt;__setattribute__()&lt;/code&gt;, &lt;code&gt;__delattribute__()&lt;/code&gt; . Второй метод позволяет более жесткий контроль, например, управление чтением уже существующих атрибутов.
Эти способы позволяют организовать полностью динамический доступ к атрибутам объекта или, что используется очень часто, имитации несуществующих атрибутов. По такому принципу функционируют, например, все системы [[RPC]] для Python, имитируя методы и свойства, реально существующие на удаленном сервере.
=== Полиморфизм ===
В компилируемых языках программирования [[Полиморфизм (программирование)| полиморфизм]] достигается
за счет деления ф-ций на виртульные(те, которые можно перегрузить в потомке) и невиртульные,
которые перегрузить невозможно. В Python все методы являются виртуальными. Это является естественным
следствием разрешения доступа на этапе исполнения.
&gt;&gt;&gt; class parent(object):
def isParOrPChild(self) : return True
def who(self) : return 'parent'
&gt;&gt;&gt; class child(parent):
def who(self,val):return 'child'
&gt;&gt;&gt; x = parent()
&gt;&gt;&gt; x.meth(),x.isParOrPChild()
('parent',True)
&gt;&gt;&gt; x = child()
&gt;&gt;&gt; x.meth(),x.isParOrPChild()
('child',True)
Явно указав имя класса можно обратится к методу родителя(как впрочем и любого другого объекта)
&gt;&gt;&gt; class child(parent):
def __init__(self):
parent.__init__(self)
Используя исключения можно имитировать чисто виртуальные методы:
&gt;&gt;&gt; class Abstract(Exception):pass
&gt;&gt;&gt; class abstobj(object):
def abstmeth(self):
raise Abstract('Method abstobj.abstmeth is pure virtual')
&gt;&gt;&gt; abstobj().abstmeth()
Traceback (most recent call last):
File "&lt;stdin&gt;", line 1, in &lt;module&gt;
File "&lt;stdin&gt;", line 2, in method
__main__.Abstract: Method abstobj.abstmeth is pure virtual
Или лучше так:
&gt;&gt;&gt; def abstract(func):
def closure(*dt,**mp):
raise Abstract("Method %s is pure virtual" % func.__name__)
return closure
&gt;&gt;&gt; class abstobj(object):
@abstract
def abstmeth(self):pass
Изменяя атрибут &lt;code&gt;__class__&lt;/code&gt; можно перемещать объект вверх или вниз
по иерархии наследования ( впрочем как и к любому другому типу )
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.val = 10
&gt;&gt;&gt; c.who()
'child'
&gt;&gt;&gt; c.__class__ = parent
&gt;&gt;&gt; c.who()
'parent'
&gt;&gt;&gt; c.val
10
Однако в этом случае никакие преобразования типов не делаются, поэтому согласованность данных
всецело лежит на программисте.
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>nq26s7do3tm57mbux5yxi6qbbvb9cgs</sha1>
</revision>
<revision>
<id>3102295</id>
<parentid>3102285</parentid>
<timestamp>2007-02-03T11:16:13Z</timestamp>
<contributor>
<username>Koder</username>
<id>27335</id>
</contributor>
<comment>/* Полиморфизм */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="13570">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени дают несколько большую защиту: атрибут перестает быть доступен по этому имени.Последнее используется достаточно редко.
Есть существенное отличие между такими атрибутами и личными (private) членами класса в таких
языках как [[C++]] или [[Java]]: атрибут остается доступным, но под именем вида
&lt;code&gt;_ИмяКласса__ИмяАтрибута&lt;/code&gt;, а при каждом обращении &lt;code&gt;Python&lt;/code&gt; будет модифицировать имя в зависимости
от того экземпляр какого класса обращается к атрибуту . Таким образом родительский и дочерний
классы могут иметь атрибут с именем, например, "__f" но не будут мешать друг другу.
&gt;&gt;&gt; class parent(object):
def __init__(self):
self.__f = 2
def get(self):return self.__f
....
&gt;&gt;&gt; class child(parent):
def __init__(self):
self.__f = 1
parent.__init__(self)
def cget(self):return self.__f
....
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.get()
2
&gt;&gt;&gt; c.cget()
1
&gt;&gt;&gt; c.__dict__
{'_child__f': 1, '_parent__f': 2} #на самом деле у объекта "с" два разных атрибута
Особым случаем является наличие двух подчеркиваний в начале и в конце имени - такие атрибуты
используются для специальных свойств и функций класса(например для перегрузки операции).
Такие атрибуты доступны по своему имени, но их использование зарезервировано для специальных
атрибутов, изменяющих поведение объекта.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
Есть два способа централизованно контролировать доступ к атрибутам. Первый основан на перегрузке
методов &lt;code&gt;__getattr__()&lt;/code&gt;, &lt;code&gt;__setattr__()&lt;/code&gt;, &lt;code&gt;__delattr__()&lt;/code&gt;,
а второй - методов &lt;code&gt;__getattribute__()&lt;/code&gt;, &lt;code&gt;__setattribute__()&lt;/code&gt;, &lt;code&gt;__delattribute__()&lt;/code&gt; . Второй метод позволяет более жесткий контроль, например, управление чтением уже существующих атрибутов.
Эти способы позволяют организовать полностью динамический доступ к атрибутам объекта или, что используется очень часто, имитации несуществующих атрибутов. По такому принципу функционируют, например, все системы [[RPC]] для Python, имитируя методы и свойства, реально существующие на удаленном сервере.
=== Полиморфизм ===
В компилируемых языках программирования [[Полиморфизм (программирование)| полиморфизм]] достигается
за счет деления ф-ций на виртуальные (те, которые можно перегрузить в потомке) и не виртуальные
(которые перегрузить невозможно). В Python все методы являются виртуальными. Это является естественным
следствием разрешения доступа на этапе исполнения.
&gt;&gt;&gt; class parent(object):
def isParOrPChild(self) : return True
def who(self) : return 'parent'
&gt;&gt;&gt; class child(parent):
def who(self,val):return 'child'
&gt;&gt;&gt; x = parent()
&gt;&gt;&gt; x.meth(),x.isParOrPChild()
('parent',True)
&gt;&gt;&gt; x = child()
&gt;&gt;&gt; x.meth(),x.isParOrPChild()
('child',True)
Явно указав имя класса можно обратится к методу родителя(как впрочем и любого другого объекта)
&gt;&gt;&gt; class child(parent):
def __init__(self):
parent.__init__(self)
Используя исключения можно имитировать чисто виртуальные методы:
&gt;&gt;&gt; class Abstract(Exception):pass
&gt;&gt;&gt; class abstobj(object):
def abstmeth(self):
raise Abstract('Method abstobj.abstmeth is pure virtual')
&gt;&gt;&gt; abstobj().abstmeth()
Traceback (most recent call last):
File "&lt;stdin&gt;", line 1, in &lt;module&gt;
File "&lt;stdin&gt;", line 2, in method
__main__.Abstract: Method abstobj.abstmeth is pure virtual
Или лучше так:
&gt;&gt;&gt; def abstract(func):
def closure(*dt,**mp):
raise Abstract("Method %s is pure virtual" % func.__name__)
return closure
&gt;&gt;&gt; class abstobj(object):
@abstract
def abstmeth(self):pass
Изменяя атрибут &lt;code&gt;__class__&lt;/code&gt; можно перемещать объект вверх или вниз
по иерархии наследования ( впрочем как и к любому другому типу )
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.val = 10
&gt;&gt;&gt; c.who()
'child'
&gt;&gt;&gt; c.__class__ = parent
&gt;&gt;&gt; c.who()
'parent'
&gt;&gt;&gt; c.val
10
Однако в этом случае никакие преобразования типов не делаются, поэтому согласованность данных
всецело лежит на программисте.
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>2kqk2krqaiy4sk0rczy6exaiss9i6p9</sha1>
</revision>
<revision>
<id>3102613</id>
<parentid>3102295</parentid>
<timestamp>2007-02-03T12:01:36Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Полиморфизм */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="13882">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени дают несколько большую защиту: атрибут перестает быть доступен по этому имени.Последнее используется достаточно редко.
Есть существенное отличие между такими атрибутами и личными (private) членами класса в таких
языках как [[C++]] или [[Java]]: атрибут остается доступным, но под именем вида
&lt;code&gt;_ИмяКласса__ИмяАтрибута&lt;/code&gt;, а при каждом обращении &lt;code&gt;Python&lt;/code&gt; будет модифицировать имя в зависимости
от того экземпляр какого класса обращается к атрибуту . Таким образом родительский и дочерний
классы могут иметь атрибут с именем, например, "__f" но не будут мешать друг другу.
&gt;&gt;&gt; class parent(object):
def __init__(self):
self.__f = 2
def get(self):return self.__f
....
&gt;&gt;&gt; class child(parent):
def __init__(self):
self.__f = 1
parent.__init__(self)
def cget(self):return self.__f
....
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.get()
2
&gt;&gt;&gt; c.cget()
1
&gt;&gt;&gt; c.__dict__
{'_child__f': 1, '_parent__f': 2} #на самом деле у объекта "с" два разных атрибута
Особым случаем является наличие двух подчеркиваний в начале и в конце имени - такие атрибуты
используются для специальных свойств и функций класса(например для перегрузки операции).
Такие атрибуты доступны по своему имени, но их использование зарезервировано для специальных
атрибутов, изменяющих поведение объекта.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
Есть два способа централизованно контролировать доступ к атрибутам. Первый основан на перегрузке
методов &lt;code&gt;__getattr__()&lt;/code&gt;, &lt;code&gt;__setattr__()&lt;/code&gt;, &lt;code&gt;__delattr__()&lt;/code&gt;,
а второй - методов &lt;code&gt;__getattribute__()&lt;/code&gt;, &lt;code&gt;__setattribute__()&lt;/code&gt;, &lt;code&gt;__delattribute__()&lt;/code&gt; . Второй метод позволяет более жесткий контроль, например, управление чтением уже существующих атрибутов.
Эти способы позволяют организовать полностью динамический доступ к атрибутам объекта или, что используется очень часто, имитации несуществующих атрибутов. По такому принципу функционируют, например, все системы [[RPC]] для Python, имитируя методы и свойства, реально существующие на удаленном сервере.
=== Полиморфизм ===
В компилируемых языках программирования [[Полиморфизм (программирование)| полиморфизм]] достигается
за счет деления функций на виртуальные (те, которые можно перегрузить в потомке) и не виртуальные
(которые перегрузить невозможно). В Питоне все методы являются виртуальными. Это является естественным
следствием разрешения доступа на этапе исполнения. Более того, полиморфизм в Питоне вообще не завязан всецело на
наследовании, поэтому его можно считать сигнатурно-ориентированным полиморфизмом (signature-oriented polymorfism).
&gt;&gt;&gt; class parent(object):
def isParOrPChild(self) : return True
def who(self) : return 'parent'
&gt;&gt;&gt; class child(parent):
def who(self,val):return 'child'
&gt;&gt;&gt; x = parent()
&gt;&gt;&gt; x.meth(),x.isParOrPChild()
('parent',True)
&gt;&gt;&gt; x = child()
&gt;&gt;&gt; x.meth(),x.isParOrPChild()
('child',True)
Явно указав имя класса можно обратится к методу родителя(как впрочем и любого другого объекта)
&gt;&gt;&gt; class child(parent):
def __init__(self):
parent.__init__(self)
Используя исключения можно имитировать чисто виртуальные методы:
&gt;&gt;&gt; class Abstract(Exception):pass
&gt;&gt;&gt; class abstobj(object):
def abstmeth(self):
raise Abstract('Method abstobj.abstmeth is pure virtual')
&gt;&gt;&gt; abstobj().abstmeth()
Traceback (most recent call last):
File "&lt;stdin&gt;", line 1, in &lt;module&gt;
File "&lt;stdin&gt;", line 2, in method
__main__.Abstract: Method abstobj.abstmeth is pure virtual
Или лучше так:
&gt;&gt;&gt; def abstract(func):
def closure(*dt,**mp):
raise Abstract("Method %s is pure virtual" % func.__name__)
return closure
&gt;&gt;&gt; class abstobj(object):
@abstract
def abstmeth(self):pass
Изменяя атрибут &lt;code&gt;__class__&lt;/code&gt; можно перемещать объект вверх или вниз
по иерархии наследования ( впрочем как и к любому другому типу )
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.val = 10
&gt;&gt;&gt; c.who()
'child'
&gt;&gt;&gt; c.__class__ = parent
&gt;&gt;&gt; c.who()
'parent'
&gt;&gt;&gt; c.val
10
Однако в этом случае никакие преобразования типов не делаются, поэтому согласованность данных
всецело лежит на программисте.
=== Имитация встроенных типов ===
== Отношения между классами ==
=== Наследование и множественное наследование ===
==== Порядок разрешения методов ====
==== "Новые" и "классические" классы ====
=== Агрегация. Контейнеры. Итераторы ===
=== Ассоциация ===
==== Слабые ссылки ====
=== Метаклассы ===
== Методы ==
=== Статический метод ===
=== Метод класса ===
=== Мультиметоды ===
== Устойчивость объектов ==
== Ссылки ==
== Примечания ==
{{reflist|2}}
[[Категория:Программирование]]</text>
<sha1>ajsqczzj45ursptoza1tvapbdt2nmvx</sha1>
</revision>
<revision>
<id>3119364</id>
<parentid>3102613</parentid>
<timestamp>2007-02-04T20:44:42Z</timestamp>
<contributor>
<username>РоманСузи</username>
<id>41369</id>
</contributor>
<comment>/* Имитация встроенных типов */</comment>
<model>wikitext</model>
<format>text/x-wiki</format>
<text xml:space="preserve" bytes="16652">С самого начала [[Python|Питон]] проектировался как [[Объектно-ориентированный язык программирования|объектно-ориентированный язык программирования]] &lt;ref name="python oop from beginning"&gt;[http://www.ercb.com/ddj/1997/ddj.9711.html Dr. Dobb's Journal, November, 1997]&lt;/ref&gt;. На Питоне писать программы в объектно-ориентированном стиле просто и приятно.
== Введение ==
=== Принципы ООП ===
Согласно [[Кей, Алан|Алану Кэю]] - автору языка программирования [[Smalltalk]] - объектно-ориентированным может называться язык, построенный с учетом следующих принципов&lt;ref name="alan kay oop principles"&gt;[http://www.cs.aau.dk/~torp/Teaching/E02/OOP/handouts/introduction.pdf ]&lt;/ref&gt;:
* Все данные представляются объектами
* Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
* Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
* Каждый объект имеет тип
* Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)
Как будет показано в данной статье, язык программирования Питон соответствует этим принципам.
=== Основные концепции ООП в Питон ===
== Объекты, типы и классы ==
=== Определение класса ===
Для ясности последующиего изложения рассмотрим определение класса с точки зрения синтаксиса. Для определения [[Класс (программирование)|класса]] используется оператор &lt;code&gt;class&lt;/code&gt;:
class имя_класса(надкласс1, надкласс2, ...):
# определения атрибутов и методов класса
У класса могут быть базовые (родительские) классы (надклассы), которые (если они есть) указываются в скобках после имени определяемого класса.
Минимально возможное определение класса выглядит так:
class A:
pass
В терминологии Питона члены класса называются атрибутами, функции класса - методами, а [[Поле класса|поля класса]] - [[Свойство (программирование) | свойствами]] (или просто атрибутами).
Определения [[Метод (программирование)|методов]] аналогичны определениям функций, но (за некоторыми исключениями, о которых ниже) методы всегда имеют первый аргумент, называемый по широко принятому соглашению &lt;code&gt;self&lt;/code&gt;:
class A:
def m1(self, x):
# блок кода метода
Определения [[Атрибут (программирование)|атрибутов]] - обычные операторы присваивания, которые ссвязывают некоторые значения с именами атрибутов.
class A:
attr1 = 2 * 2
В Питон класс не является чем-то статическим после определения, поэтому добавить атрибуты можно и после:
class A:
pass
&amp;nbsp;
def myMethod(self, x):
return x * x
&amp;nbsp;
A.m1 = myMethod
A.attr1 = 2 * 2
=== Инкапсуляция и доступ к свойствам ===
[[Инкапсуляция (программирование) | Инкапсуляция]] является одним из ключевых понятий ООП. В языке Питон сокрытие информации о внутреннем устройстве объекта выполняется на уровне соглашения между программистами о том, какие атрибуты относятся к общедоступному интерфейсу класса, а какие относятся к внутренней реализации. Одиночное подчеркивание в начале имени атрибута говорит о том, что метод не предназначен для использования вне методов класса (или вне функций и классов модуля), однако, атрибут все-таки доступен по этому имени. Два подчеркивания в начале имени дают несколько большую защиту: атрибут перестает быть доступен по этому имени.Последнее используется достаточно редко.
Есть существенное отличие между такими атрибутами и личными (private) членами класса в таких
языках как [[C++]] или [[Java]]: атрибут остается доступным, но под именем вида
&lt;code&gt;_ИмяКласса__ИмяАтрибута&lt;/code&gt;, а при каждом обращении &lt;code&gt;Python&lt;/code&gt; будет модифицировать имя в зависимости
от того экземпляр какого класса обращается к атрибуту . Таким образом родительский и дочерний
классы могут иметь атрибут с именем, например, "__f" но не будут мешать друг другу.
&gt;&gt;&gt; class parent(object):
def __init__(self):
self.__f = 2
def get(self):return self.__f
....
&gt;&gt;&gt; class child(parent):
def __init__(self):
self.__f = 1
parent.__init__(self)
def cget(self):return self.__f
....
&gt;&gt;&gt; c = child()
&gt;&gt;&gt; c.get()
2
&gt;&gt;&gt; c.cget()
1
&gt;&gt;&gt; c.__dict__
{'_child__f': 1, '_parent__f': 2} #на самом деле у объекта "с" два разных атрибута
Особым случаем является наличие двух подчеркиваний в начале и в конце имени - такие атрибуты
используются для специальных свойств и функций класса(например для перегрузки операции).
Такие атрибуты доступны по своему имени, но их использование зарезервировано для специальных
атрибутов, изменяющих поведение объекта.
Доступ к атрибуту может быть как прямой:
class A(object):
def __init__(self, x): # атрибут получает значение в конструкторе
self.x = x
&amp;nbsp;
a = A(5)
print a.x
a.x = 6
Так и с использованием свойств с заданными методами для получения, установки и удаления атрибута:
class A(object):
def __init__(self, x):
self._x = x
def getx(self): # метод для получения значения
return self._x
def setx(self, value): # присваивания нового значения
self._x = value
def delx(self): # удаления атрибута
del self._x
x = property(getx, setx, delx, "Свойство x") # определяем x как свойство
&amp;nbsp;
a = A(5)
print a.x # Синтаксис доступа к атрибуту при это прежний
a.x = 6
Разумеется, первый способ хорошо только если значение атрибута является атомарной операцией по изменению состояния объекта. Если же это не так, то второй способ позволит выполнить все необходимые действия в соответствующих методах.
Есть два способа централизованно контролировать доступ к атрибутам. Первый основан на перегрузке
методов &lt;code&gt;__getattr__()&lt;/code&gt;, &lt;code&gt;__setattr__()&lt;/code&gt;, &lt;code&gt;__delattr__()&lt;/code&gt;,
а второй - методов &lt;code&gt;__getattribute__()&lt;/code&gt;, &lt;code&gt;__setattribute__()&lt;/code&gt;, &lt;code&gt;__delattribute__()&lt;/code&gt; . Второй метод позволяет более жесткий контроль, например, управление чтением уже существующих атрибутов.
Эти способы позволяют организовать полностью динамический доступ к атрибутам объекта или, что используется очень часто, имитации несуществующих атрибутов. По такому принципу функционируют, например, все системы [[RPC]] для Python, имитируя методы и свойства, реально существующие на удаленном сервере.
=== Полиморфизм ===
В компилируемых языках программирования [[Полиморфизм (программирование)| полиморфизм]] достигается
за счет деления функций на виртуальные (те, которые можно перегрузить в потомке) и не виртуальные
(которые перегрузить невозможно). В Питоне все методы являются виртуальными. Это является естественным
следствием разрешения доступа на этапе исполнения. Более того, полиморфизм в Питоне вообще не завязан всецело на
наследовании, поэтому его можно считать сигнатурно-ориентированным полиморфизмом (signature-oriented polymorfism).
&gt;&gt;&gt; class parent(object):
def isParOrPChild(self) : return True
def who(self) : return 'parent'
&gt;&gt;&gt; class child(parent):
def who(self,val):return 'child'
&gt;&gt;&gt; x = parent()
&gt;&gt;&gt; x.meth(),x.isParOrPChild()
('parent',True)
&gt;&gt;&gt; x = child()
&gt;&gt;&gt; x.meth(),x.isParOrPChild()
('child',True)
Явно указав имя класса можно обратится к методу родителя(как впрочем и любого другого объекта)