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

Бу­ра­ти­но (о по­ли­мор­физ­ме):
— Те­бя как зо­вут?
— Маль­ви­на!
— Мы не в сау­не! В жиз­ни те­бя как зо­вут?!
— Ма­ри­на...

Ду­маю, все мы так или ина­че слы­ша­ли об объ­ект­но-ори­ен­ти­ро­ван­ном про­грам­ми­ро­ва­нии. Эта за­мет­ка для тех, кто за 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 'Я не умею это делать'

Ли­стинг 1. Реа­ли­за­ция клас­са girl на язы­ке про­грам­ми­ро­ва­ния Python

Эта про­грам­ма — опи­са­ние клас­са 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 и j):

>>> 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
Вася

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

32 отзыва на запись «Пи­тон, де­вуш­ки, и объ­ект­но-ори­ен­ти­ро­ван­ное про­грам­ми­ро­ва­ние»

По­сле g.со­си слож­но со­сре­до­то­чит­ся на ин­кап­су­ля­ции и осо­бен­но­стях сбор­ки му­со­ра
Впро­чем, ка­кая раз­ни­ца, ес­ли объ­ект де­ла­ет всё то, что вам от не­го нуж­но
Слу­чаи, ко­гда Ва­си де­ла­ют всё то, что вам нуж­но, в ди­на­ми­че­ском про­грам­ми­ро­ва­нии на­зы­ва­ют­ся ути­ным ти­пи­ро­ва­ни­ем:
If it looks like a duck and quacks like a duck, it must be a duck
Очень по­нра­ви­лось, ил­лю­стра­тив­но до пре­де­ла. Жаль, что из-за бли­зо­сти к это­му са­мо­му пре­де­лу, эти ил­лю­стра­ции нель­зя бу­дет ис­поль­зо­вать в учеб­ном про­цес­се
Есть не­точ­ность: ин­кап­су­ля­ция — это объ­еди­не­ние дан­ных и ко­да, ра­бо­таю­ще­го с эти­ми дан­ны­ми, в еди­ную сущ­ность.
Ну, во-пер­вых, у ме­ня при­мер­но так и на­пи­са­но:
Этот тер­мин озна­ча­ет, что вы об­ща­е­тесь с де­вуш­кой как с це­лост­ной сущ­но­стью, и вам не важ­но, как она устрое­на внут­ри.
Под «об­ще­ни­ем» я по­ни­мал вы­зов ме­то­дов и ра­бо­ту со свой­ства­ми. А во-вто­рых, со­глас­но Ви­ки­пе­дии,
Инкапсуля́ция — свой­ство язы­ка про­грам­ми­ро­ва­ния, поз­во­ляю­щее объ­еди­нить дан­ные и код в объ­ект и скрыть реа­ли­за­цию объ­ек­та от поль­зо­ва­те­ля.
По­это­му у ме­ня есть при­пис­ка:
Её дан­ные скры­ты от вас.
Хо­тя сле­ду­ет при­знать, что в Пи­то­не не­воз­мож­но пол­но­стью скрыть свой­ства объ­ек­та.
Вот уж по­нят­но так по­нят­но объ­яс­нил!! )
Я прям си­дел и ржал как конь, осо­зна­вая, что я всё по­ни­маю )
И пред­став­лял, что ав­тор, на­вер­ня­ка, сам ржал, ко­гда пи­сал.. Осо­бен­но, вот эти строч­ки:
Ко­гда вы хра­ни­те де­ву­шек или пе­ре­да­ё­те их для об­ра­бот­ки в ка­кую-ни­будь функ­цию
Жаль, толь­ко про по­ли­мор­физм нифи­га­шеч­ки не по­нят­но Кста­ти, а чем на­ве­ян пост? Кто-то по­про­сил?
Из­ви­ни­те за на­зой­ли­вость, а бу­дет ли ещё ка­кой-ли­бо не­про­стой ма­те­ри­ал, осо­бен­но в Ва­шем ис­пол­не­нии, по­доб­но это­му? )
Ес­ли вдруг пой­дё­те на урл мо­е­го сай­та и там уви­ди­те лин­ко­по­мой­ку на­вер­ху, и пор­но в ссыл­ках — не пу­гай­тесь — это лишь жал­кие по­пыт­ки мо­не­ти­зи­ро­вать блог на пи­во
Пост на­ве­ян слу­чай­но­стью. Я де­лал тек­сто­вый об­ра­бот­чик на ос­но­ве пат­тер­нов для ге­не­ра­ции тек­сто­вых пред­став­ле­ний чи­сел и скло­не­ния за­ви­си­мо­го сло­ва (на­при­мер 1234+сту­дент = «Ты­ся­ча две­сти трид­цать че­ты­ре сту­ден­та»), и вдруг по­лу­чи­лась впол­не не­пло­хая сме­на окон­ча­ния (иди-иду, бе­ги-бе­гу, и т.п.). Вот мысль и ста­ла раз­ви­вать­ся. Так как это слу­чай­ность, то ни­че­го но­во­го по­доб­но­го ти­па не пред­ви­дит­ся
Класс­ная шту­ка! С окон­ча­ни­я­ми по­нра­ви­лось. Вот ес­ли бы еще бы­ли на С и на Дел­фи дуб­ли­ка­ты, бы­ло бы про­сто за­ме­ча­тель­но! (С пи­то­ном ни­ко­гда не ра­бо­тал )
аффф­тар жжет
Спа­си­бо за псто! УГ по­вер­же­но ри­аль­не!
Вот так и рас­ска­зы­вай же­не что за­дер­жал­ся на ра­бо­те до 10, по­то­му что про­грам­ми­ро­вал….
Так по­сле та­ких по­стов ведь и не по­ве­рит!
Мо­жет хоть кто-ни­будь в ру­не­те на­пи­сать не смеш­ной, не пош­лый, не про де­ву­шек пост ко­то­рый бы до­ход­чи­во ил­лю­стри­ро­вал тя­го­ты и слож­но­сти ра­бо­ты с ком­пью­те­ром?
су­пер)))))
над ко­ман­да­ми дол­го сме­ял­ся))
ав­тор мо­ло­дец))
Ав­то­ру ми­нус за по­ли­мор­физм и на­сле­до­ва­ние!
Ста­тья пол­но­стью по Фрей­ду) — но за­чем так пре­не­бре­жи­тель­но от­но­сит­ся к жен­ско­му по­лу.
На­вер­ное имен­но по это­му у мно­гих де­ву­ше­ек сте­рео­тип­ное не­га­тив­ное мне­ние о про­грам­ми­стах!
Мо­гу сде­лать вы­вод, что у ав­то­ра не­ла­ды с лич­ной жиз­нью, да и пред­ме­том соб­ствен­но то­же не шиб­ко вла­де­ет!

Ну по­че­му же?

Ав­тор уже 4 го­да, как же­нат, и впол­не счаст­лив:

Моя же­на
ду­маю, ес­ли на­пи­сать то же, но про му­жи­ков — под­хо­жи- на­гнись — жо­пу раз­дви­гай, то уже счаст­ли­вы бу­де­те не так силь­но. Ну вот не мо­гут лю­ди по­нять, как это жен­щи­нам не­при­ят­но чи­тать, эм­па­тия на ну­ле. За­то на пи­то­не про­грам­ми­ру­ет, да…
Ан­тон, мо­ло­дец!
Ста­тья — блеск! Ува­жаю мно­го­уров­не­вость в со­чи­не­ни­ях, ко­гда и для ума, и для ду­ши, и для чи­ста­поржать то­же оста­ет­ся))))) Успе­хов!
Не пло­хо
За­бав­но, очень ил­лю­стра­тив­но.
Од­на­ко вер­но ска­за­но ввер­ху — при­мер про по­ли­мор­физм в це­лом не­пра­виль­ный, это де­мон­стра­ция ducktyping. При­мер по­ли­мор­физ­ма это пе­ре­опре­де­ле­ние ме­то­да «го­товь» в клас­се cook, или что то око­ло то­го.

Скрипт для Python 3, мо­жет ко­му по­на­до­бит­ся :)

# -*- coding: cp1251 -*-
class girl:
     methods = {'и':'у','й':'ю','ти':'щу','ей':'ью','ри':'рю',
                'ери':'еру','ети':'ечу','ись':'усь','йся':'юсь',
                'оди':'ожу','рай':'раю','вись':'вюсь','тись':'чусь'}
     def start(name = "Маша"):
         print ("Привет, меня зовут", name)
     def __del__(self):
         print ("Прощай")
     def __getattr__(self, m):
         for l in range( len(m) ):
             try:
                 print (m[:l] + girl.methods[ m[l:] ])
                 return
             except KeyError: pass
         if m[0] !='_': print ("Я не умею это делать")
     start()
g=girl()
Спа­си­бо.
Я бы не­мно­го пе­ре­пи­сал… class Girl:
methods = {‘и’: ‘у’, ‘й’: ‘ю’, ‘ти’: ‘щу’, ‘ей’: ‘ью’, ‘ри’: ‘рю’,
‘ери’: ‘еру’, ‘ети’: ‘ечу’, ‘ись’: ‘усь’, ‘йся’: ‘юсь’,
‘оди’: ‘ожу’, ‘рай’: ‘раю’, ‘вись’: ‘вюсь’, ‘тись’: ‘чусь’} def __init__(self, name=»Ма­ша»):
print(«При­вет, ме­ня зо­вут», name) def __del__(self):
print(«Про­щай») def __getattr__(self, m):
for l in range(len(m)):
try:
print(m[:l] + Girl.methods[m[l:]])
return
except KeyError:
pass
if m[0] != ‘_’:
print(«Я не умею это де­лать»)

class Girl:
methods = {\'и\': \'у\', \'й\': \'ю\', \'ти\': \'щу\', \'ей\': \'ью\', \'ри\': \'рю\',
\'ери\': \'еру\', \'ети\': \'ечу\', \'ись\': \'усь\', \'йся\': \'юсь\',
\'оди\': \'ожу\', \'рай\': \'раю\', \'вись\': \'вюсь\', \'тись\': \'чусь\'} def __init__(self, name=\"Ма­ша\"):
print(\"При­вет, ме­ня зо­вут\", name) def __del__(self):
print(\"Про­щай\") def __getattr__(self, m):
for l in range(len(m)):
try:
print(m[:l] + Girl.methods[m[l:]])
return
except KeyError:
pass
if m[0] != \'_\':
print(\"Я не умею это де­лать\")
class Girl:
    methods = {‘и’: ‘у’, ‘й’: ‘ю’, ‘ти’: ‘щу’, ‘ей’: ‘ью’, ‘ри’: ‘рю’,
               ‘ери’: ‘еру’, ‘ети’: ‘ечу’, ‘ись’: ‘усь’, ‘йся’: ‘юсь’,
               ‘оди’: ‘ожу’, ‘рай’: ‘раю’, ‘вись’: ‘вюсь’, ‘тись’: ‘чусь’}     def __init__(self, name="Маша"):
        print("Привет, меня зовут", name)     def __del__(self):
        print("Прощай")     def __getattr__(self, m):
        for l in range(len(m)):
            try:
                print(m[:l] + Girl.methods[m[l:]])
                return
            except KeyError:
                pass
        if m[0] != ‘_’:
            print("Я не умею это делать")
 
Ста­тья ши­кар­ная! Сра­зу всё по­нял. По­че­му в шко­ле так не объ­яс­ня­ют?
>>> p = girl ()
При­вет, ме­ня зо­вут На­та­ша
>>> p. под­хо­ди
SyntaxError: invalid syntax Это при ко­ди­ров­ке cp1251
При ко­ди­ров­ке utf-8 то же са­мое.
В чем пе­рец?
Функ­цио­ни­ро­ва­ние это­го при­ме­ра ос­но­ва­но на глю­ке в ста­рых вер­си­ях Idle (ре­дак­тор для Пи­то­на), поз­во­ляв­шем ис­поль­зо­вать рус­ские бук­вы в име­нах ме­то­дов (при­чём толь­ко в ко­ди­ров­ке cp1251). Я сей­час по­ты­кал­ся в раз­ные вер­сии Пи­то­на; по­след­няя вер­сия, в ко­то­рой ра­бо­та­ет при­мер, — 2.6.6. Вот ссыл­ка: http://www.python.org/download/releases/2.6.6/ (я про­ве­рял на 32-х бит­ной сбор­ке).
До­бро­го вре­ме­ни су­ток) Спа­си­бо за ста­тью. Очень по­нят­но на­пи­са­но. Я как раз пи­шу адап­тер. Так как пи­тон ви­жу во­об­ще пер­вый раз, то до­ста­точ­но слож­но, а зна­ний ооп во­об­ще не хва­та­ет.

Юни­код вер­сия

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

class girl:
    dic = {'и':'у','й':'ю','ти':'щу','ей':'ью','ри':'рю',
           'ери':'еру','ети':'ечу','ись':'усь','йся':'юсь',
           'оди':'ожу','рай':'раю','вись':'вюсь','тись':'чусь'}
    udic = dict([(k.decode('utf-8'), v.decode('utf-8')) for k, v in dic.items()])
   
    def __init__(self, name = 'Наташа'):
        print u'Привет, меня зовут', name.decode('utf-8')
        self.name = name.decode('utf-8')
    def __del__(self):
        print u'Прощай'
    def do(self, m):
        m = m.decode('utf-8')
        for key in self.udic.keys():
            if m[-len(key):] == key:
                print ''.join([m[:-len(key)],self.udic[key]]).encode(sys.stdout.encoding)
                return
        print u'Я не умею это делать'

g = girl('Алинка')
g.do('раздевайся')
g.do('соси')
g.do('раздвигай')
g.do('агрегат')
print g.name, u'уходит..'
del g

А вот ра­бо­таю­щая вер­сия для Python3.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

class Girl(object):
    dic = {'и':'у','й':'ю','ти':'щу','ей':'ью','ри':'рю',
           'ери':'еру','ети':'ечу','ись':'усь','йся':'юсь',
           'оди':'ожу','рай':'раю','вись':'вюсь','тись':'чусь'}
    udic = dict([(k, v) for k, v in dic.items()])
   
    def __init__(self, name = 'Наташа'):
        print(" ".join(['Привет, меня зовут', name]))
        self.name = name
    def __del__(self):
        print('Прощай')
    def __getattr__(self, m):
        for key in self.udic.keys():
            if m[-len(key):] == key:
                print(''.join([m[:-len(key)],self.udic[key]]))
                return
        print('Я не умею это делать')

g = Girl('Алинка')
g.паркуйся
g.программируй
g.улыбайся
g.упражняйся
del g
Вы уве­ре­ны, что ваш код со­от­вет­ству­ет ори­ги­на­лу? Де­ло в том, что нуж­но за­ме­нять окон­ча­ние на са­мое длин­ное из тех, что есть в таб­ли­це, а не на пер­вое по­пав­шее­ся. Рас­смот­рим на­бор из трёх пра­вил, имею­щих­ся в таб­ли­це:
1) и → у
2) ри → рю
3) ери → еру Для че­го нуж­но тре­тье пра­ви­ло, ес­ли есть пер­вое? Для то­го, что­бы в не­ко­то­рых слу­ча­ях пе­ре­кры­вать вто­рое, ко­то­рое ино­гда пе­ре­кры­ва­ет пер­вое. Пра­ви­ла бы­ли по­лу­че­ны ма­шин­ным обу­че­ни­ем на ос­но­ве спис­ка из двух­сот гла­го­лов по­ве­ли­тель­но­го на­кло­не­ния. В тек­сте про­грам­мы пра­ви­ла упо­ря­до­че­ны по убы­ва­нию ча­сто­ты ис­поль­зо­ва­ния. При этом бо­лее длин­ное пра­ви­ло яв­ля­ет­ся ис­клю­че­ни­ем (пе­ре­кры­ва­ет) бо­лее ко­рот­кое.
Во­об­ще класс­ная ста­тья! Сра­зу ста­но­вит­ся все по­нят­но как на­чать про­грам­ми­ро­вать на Python-е, спа­си­бо!
на­ко­нец-то всё по­нял !!!
вы­бе­ри­те пункт ме­ню «Edit with IDLE» — а ес­ли нет та­ко­го пунк­та в нис­па­даю­щем ме­ню мыш­ки?

Оставить отзыв

Жёлтые поля обязательны к заполнению

   

Можете использовать теги <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> <pre lang=""> <div class=""> <span class=""> <br>