Питон, девушки и объектно-ориентированное программирование

Ду­маю, все мы так или ина­че слы­ша­ли об объ­ект­но-ори­ен­ти­ро­ван­ном про­грам­ми­ро­ва­нии. Эта за­мет­ка для тех, кто за 15 ми­нут хо­чет по­нять, что это та­кое. На про­стом при­ме­ре я про­де­мон­стри­рую по­ня­тия класс, объ­ект, кон­ст­рук­тор, де­ст­рук­тор, ин­кап­су­ля­ция, и да­же ска­жу па­ру слов про та­кие слож­ные ве­щи, как на­сле­до­ва­ние и по­ли­мор­физм. Для экс­пе­ри­мен­тов мы бу­дем ис­поль­зо­вать ин­тер­пре­ти­руе­мый язык про­грам­ми­ро­ва­ния Python, ко­то­рый мож­но ска­чать от­сю­да (я ис­поль­зо­вал вер­сию 2.5.4).

По­сле уста­нов­ки Пи­то­на со­здай­те пу­стой файл test.py, на­жми­те на не­го пра­вой кноп­кой мы­ши (бу­дем пред­по­ла­гать, что вы ис­поль­зу­е­те Windows), и вы­бе­ри­те пункт ме­ню «Edit with IDLE». От­кро­ют­ся два ок­на. Ок­но «Python Shell» мо­же­те за­крыть, а в остав­шее­ся ок­но вставь­те сле­дую­щий текст, и со­хра­ни­те файл:

# -*- coding: cp1251 -*-
class girl:
    methods = {'и':'у','й':'ю','ти':'щу','ей':'ью','ри':'рю',
               'ери':'еру','ети':'ечу','ись':'усь','йся':'юсь',
               'оди':'ожу','рай':'раю','вись':'вюсь','тись':'чусь'}
    def __init__(self, name = 'Наташа'):
        print 'Привет, меня зовут', name
        self.name = name
    def __del__(self):
        print 'Прощай'
    def __getattr__(self, m):
        for l in xrange( len(m) ):
            try:
                print m[:l] + girl.methods[ m[l:] ]
                return
            except KeyError: pass
        if m[0] != '_': print 'Я не умею это делать'

Эта про­грам­ма — опи­са­ние клас­са girl (де­вуш­ка). Класс — это не­ко­то­рая аб­стракт­ная сущ­ность, ко­то­рая опи­сы­ва­ет всё то об­щее, что бу­дут иметь объ­ек­ты это­го клас­са. На­при­мер, су­ще­ству­ют де­вуш­ки Ма­ша, На­та­ша, Све­та, и дру­гие, но при опре­де­лён­ных об­сто­я­тель­ствах вам со­вер­шен­но не важ­но знать имя де­вуш­ки и дру­гие её свой­ства: до­ста­точ­но то­го, что этот объ­ект — де­вуш­ка, и она мо­жет де­лать всё то, что мо­гут де­лать де­вуш­ки. Это и есть ос­нов­ная идея объ­ект­но-ори­ен­ти­ро­ван­но­го про­грам­ми­ро­ва­ния.

Кон­ст­рук­тор и ме­то­ды

Пре­жде чем мы по­дроб­но раз­бе­рём опи­са­ние клас­са, да­вай­те посмот­рим, как он ра­бо­та­ет. На­жми­те F5 и в по­явив­шем­ся ок­не ин­тер­пре­та­то­ра вве­ди­те сле­ду­ю­щую ко­ман­ду по­сле сим­во­лов >>>:

>>> g = girl()
Привет, меня зовут Наташа

Мы толь­ко что со­зда­ли объ­ект клас­са girl, ко­то­рый те­перь хра­нит­ся в пе­ре­мен­ной g (точ­нее, пе­ре­мен­ная g с ним свя­за­на). Этот объ­ект ещё на­зы­ва­ют эк­зем­пля­ром клас­са. Объ­ект име­ет свой­ства и ме­то­ды. Свой­ства — эта та ин­фор­ма­ция, ко­то­рая хра­нит­ся в объ­ек­те. Ме­то­ды — это те дей­ствия, ко­то­рые мо­жет вы­пол­нять объ­ект (при вы­пол­не­нии ме­то­дов обыч­но ис­поль­зу­ют­ся и мо­дифи­ци­ру­ют­ся свой­ства объ­ек­та). Обыч­но все объ­ек­ты од­но­го клас­са об­ла­да­ют од­ни­ми и те­ми же на­бо­ра­ми ме­то­дов и свойств, но раз­лич­ны­ми зна­че­ни­я­ми этих свойств.

Кон­ст­рук­тор — тот ме­тод, ко­то­рый ав­то­ма­ти­че­ски вы­пол­ня­ет­ся в мо­мент со­зда­ния объ­ек­та. В дан­ном слу­чае де­вуш­ка в мо­мент со­зда­ния по­при­вет­ство­ва­ла нас и на­зва­ла своё имя. В Python кон­ст­рук­тор име­ет имя __init__.

В объ­ект­но-ори­ен­ти­ро­ван­ных язы­ках про­грам­ми­ро­ва­ния на­зва­ния свойств и ме­то­дов обыч­но за­пи­сы­ва­ют­ся че­рез точ­ку по­сле то­го объ­ек­та, к ко­то­ро­му они от­но­сят­ся. Посмот­рим, ка­кие ме­то­ды име­ет на­ша де­вуш­ка:

>>> g.подходи
подхожу
>>> g.раздевайся
раздеваюсь
>>> g.соси
сосу
>>> g.ложись
ложусь
>>> g.раздвигай
раздвигаю
>>> g.переворачивайся
переворачиваюсь
>>> g.одевайся
одеваюсь

Не­пло­хой на­бор ме­то­дов для клас­са girl! Ка­жет­ся, что на­ша де­вуш­ка мо­жет де­лать всё, что угод­но, но на са­мом де­ле это не так:

>>> g.упячка
Я не умею это делать

Де­ст­рук­тор и сбор­щик му­со­ра

По­сле то­го, как де­вуш­ка нам боль­ше не нуж­на, мы мо­жем уда­лить её:

>>> del g
Прощай

То, что мы ви­дим, на­зы­ва­ет­ся де­ст­рук­то­ром — это тот ме­тод, ко­то­рый ав­то­ма­ти­че­ски вы­пол­ня­ет­ся при уда­ле­нии объ­ек­та. В Python де­ст­рук­тор име­ет имя __del__.
Здесь есть не­боль­шая тон­кость: объ­ект на са­мом де­ле уда­ля­ет­ся не по ко­ман­де del, а чуть поз­же: во вре­мя сбор­ки му­со­ра. Ко­ман­дой del мы каг­бэ го­во­рим, что объ­ект g нам боль­ше не ну­жен. А сбор­щик му­со­ра уда­лит объ­ект то­гда, ко­гда он боль­ше не бу­дет ну­жен ни­где.

Про­ве­рим это. До­пу­стим, у вас с дру­гом од­на де­вуш­ка на дво­их, од­на­ко вы об­ща­е­тесь с ней че­рез раз­ные пе­ре­мен­ные (p и :

>>> p = girl()
Привет, меня зовут Наташа
>>> j = p
>>> j.тяни
тяну
>>> p.толкай
толкаю
>>> del j
>>> del p
Прощай

Об­ра­ти­те вни­ма­ние, что сбор­щик му­со­ра уда­лил де­вуш­ку толь­ко то­гда, ко­гда она не ста­ла боль­ше нуж­на ни как p, ни как j.

Утеч­ка па­мя­ти

Ино­гда бы­ва­ет так, что сбор­щик му­со­ра не мо­жет уда­лить не­нуж­ных де­ву­шек. Рас­смот­рим си­ту­а­цию, ко­гда у вас есть две де­вуш­ки, и они вдруг по­лю­би­ли друг дру­га:

>>> g1 = girl('Маша')
Привет, меня зовут Маша
>>> g2 = girl('Марина')
Привет, меня зовут Марина
>>> g1.танцуй
танцую
>>> g2.раздевайся
раздеваюсь
>>> g1.love = g2
>>> g2.love = g1
>>> del g1
>>> del g2
>>>

Де­вуш­ки не уда­ли­лись, хо­тя ни од­на из них вам боль­ше не нуж­на (вы вы­пол­ни­ли для обе­их ко­ман­ду del). Про­бле­ма здесь в том, что де­вуш­ки нуж­ны друг дру­гу, по­это­му сбор­щик му­со­ра не уда­лил ни од­ну из них (это на­зы­ва­ет­ся коль­це­вой за­ви­си­мо­стью). По­сле вы­пол­не­ния ко­манд del у вас боль­ше нет пе­ре­мен­ных g1 и g2, по­это­му вы бо­лее не име­е­те ни­ка­кой воз­мож­но­сти свя­зать­ся с де­вуш­ка­ми. Од­на­ко, они всё ещё за­ни­ма­ют опе­ра­тив­ную па­мять. Ес­ли де­вуш­ки вам нуж­ны ча­сто, то из-за по­доб­ных си­ту­а­ций па́ры (или да­же трой­ки) де­ву­шек ра­но или позд­но зай­мут всё сво­бод­ное про­стран­ство, и про­грам­ма ава­рий­но за­вер­шит­ся. По этой же при­чи­не со­вре­мен­ные слож­ные про­грам­мы (на­при­мер, опе­ра­ци­он­ные си­сте­мы) при­хо­дит­ся ино­гда пе­ре­за­гру­жать, что­бы вос­ста­но­вить их ра­бо­то­спо­соб­ность.

Ин­кап­су­ля­ция и свой­ства

Те­перь по­го­во­рим об ин­кап­су­ля­ции. Этот тер­мин озна­ча­ет, что вы об­ща­е­тесь с де­вуш­кой как с це­лост­ной сущ­но­стью, и вам не важ­но, как она устрое­на внут­ри. Её дан­ные скры­ты от вас. Со­зда­дим двух де­ву­шек:

>>> g1 = girl('Маша')
Привет, меня зовут Маша
>>> g2 = girl('Наташа')
Привет, меня зовут Наташа
>>> g1.пей
пью
>>> g2.пей
пью

Вро­де бы обе де­вуш­ки со­вер­шен­но оди­на­ко­вы: мож­но вы­зы­вать для обе­их од­ни и те же ме­то­ды. И всё же это раз­лич­ные де­вуш­ки. У них есть свой­ства (в на­шем слу­чае — име­на). К со­жа­ле­нию, мы не мо­жем узнать эти име­на без на­ру­ше­ния ин­кап­су­ля­ции, ибо де­вуш­ки не со­дер­жат ме­то­дов для то­го, что­бы со­об­щить своё имя. По­это­му об­ра­тим­ся к име­нам на­пря­мую, без ве­до­ма де­ву­шек:

>>> print g1.name
Маша
>>> print g2.name
Наташа
>>>

Ко­гда вы хра­ни­те де­ву­шек или пе­ре­да­ё­те их для об­ра­бот­ки в ка­кую-ни­будь функ­цию, вам не на­до бес­по­ко­ить­ся, и хра­нить вме­сте с де­вуш­ка­ми их име­на или пе­ре­да­вать име­на вме­сте с ни­ми: име­на хра­нят­ся внут­ри де­ву­шек, в це­ло­сти и со­хран­но­сти.

На­сле­до­ва­ние

На­сле­до­ва­ние при­ме­ня­ет­ся для то­го, что­бы со­здать бо­лее кон­крет­ный класс из бо­лее об­ще­го. Рас­смот­рим при­мер. До­пу­стим, нам нуж­на ку­хар­ка. Ку­хар­ка — это то­же де­вуш­ка, толь­ко по­ми­мо все­го осталь­но­го она уме­ет го­то­вить. Так и на­пи­шем (до­бавь­те эти стро­ки в ваш файл test.py и со­хра­ни­те):

class cook(girl):
    methods = girl.methods
    methods['готовь'] = 'Кушайте, пожалуйста!'

Те­перь на­жми­те F5 и ис­пы­тай­те ку­хар­ку:

>>> c = cook()
Привет, меня зовут Наташа
>>> c.готовь
Кушайте, пожалуйста!

Об­ра­ти­те вни­ма­ние, что, как и лю­бая де­вуш­ка, ку­хар­ка по­при­вет­ство­ва­ла нас при со­зда­нии. На­сле­до­ва­ние хо­ро­шо тем, что вы все­гда мо­же­те ис­поль­зо­вать ку­хар­ку, как де­вуш­ку:

>>> c.готовь
Кушайте, пожалуйста!
>>> c.раздевайся
раздеваюсь

По­ли­мор­физм

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

>>> g = gril()
Привет, меня зовут Эльвира
>>> g.подходи
подхожу
>>> g.соси
сосу

Но, ес­ли вы на­ру­ша­е­те ин­кап­су­ля­цию, про­ис­хо­дит нечто стран­ное:

>>> print g.name
Вася

Впро­чем, ка­кая раз­ни­ца, ес­ли объ­ект де­ла­ет всё то, что вам от не­го нуж­но...

Автор: Су­хи­нов Ан­тон
WWW: ]]>http://iproc.ru]]>
Адрес статьи на блоге автора: ]]>http://iproc.ru/2009/08/python-girls-oop/#post-3035]]>