Вы находитесь на странице: 1из 82

Основы и методология программирования, 1 модуль

ПМИ ФКН ВШЭ

Михаил Густокашин, 2016

mgustokashin@hse.ru
2
Оглавление

1 Ввод-вывод, простые типы данных 7


1.1 Êàê èçó÷àòü ïðîãðàììèðîâàíèå . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 ßçûê Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3 Îðãàíèçàöèÿ êóðñà, âûñòàâëåíèå îöåíîê è òðåáîâàíèÿ . . . . . . . . . . . 8
1.4 Ïðîãðàììíîå îáåñïå÷åíèå . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5 Òèïû äàííûõ è ôóíêöèÿ âûâîäà . . . . . . . . . . . . . . . . . . . . . . . 9
1.6 Ïåðåìåííûå . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.7 Àðèôìåòè÷åñêèå âûðàæåíèÿ . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.8 Îïåðàöèè íàä ñòðîêàìè . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.9 ×òåíèå äàííûõ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.10 Ïðèìåðû ðåøåíèÿ çàäà÷ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.11 Êàê ïåðåìåííûå óñòðîåíû âíóòðè . . . . . . . . . . . . . . . . . . . . . . . 14
1.12 Êàê ðåøàòü çàäà÷è . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2 Логический тип данных, условный оператор, цикл while, вещественные


числа 17
2.1 Ëîãè÷åñêèé òèï äàííûõ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2 Ëîãè÷åñêèå îïåðàöèè . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3 Âûâîä è ïðåîáðàçîâàíèå ëîãè÷åñêèõ âûðàæåíèé . . . . . . . . . . . . . . 19
2.4 Óñëîâíûé îïåðàòîð . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5 Âëîæåííûé óñëîâíûé îïåðàòîð . . . . . . . . . . . . . . . . . . . . . . . . 20
2.6 Êîíñòðóêöèÿ èíà÷å-åñëè . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.7 Öèêë while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.8 Èíñòðóêöèè óïðàâëåíèÿ öèêëîì . . . . . . . . . . . . . . . . . . . . . . . . 22
2.9 Îñíîâû ðàáîòû ñ âåùåñòâåííûìè ÷èñëàìè . . . . . . . . . . . . . . . . . . 23

3 Вещественные числа и строки 25


3.1 Âåùåñòâåííûå ÷èñëà â ïàìÿòè êîìïüþòåðà . . . . . . . . . . . . . . . . . . 25
3.2 Çàïèñü, ââîä è âûâîä âåùåñòâåííûõ ÷èñåë . . . . . . . . . . . . . . . . . . 25
3.3 Ïðîáëåìû âåùåñòâåííûõ ÷èñåë . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4 Îêðóãëåíèå âåùåñòâåííûõ ÷èñåë . . . . . . . . . . . . . . . . . . . . . . . . 27
3.5 Ïîëåçíûå ôóíêöèè áèáëèîòåêè math . . . . . . . . . . . . . . . . . . . . . 28
3.6 Ñðåçû ñòðîê . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.7 Ìåòîäû nd è rnd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.8 Ìåòîäû replace è count . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3
4 ОГЛАВЛЕНИЕ

4 Функции и рекурсия 33
4.1 Ñîçäàíèå ïðîñòîé ôóíêöèè . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.2 Âûçîâû ôóíêöèé èç ôóíêöèè . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.3 Íåñêîëüêî return â ôóíêöèè . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.4 Ëîêàëüíûå è ãëîáàëüíûå ïåðåìåííûå . . . . . . . . . . . . . . . . . . . . . 35
4.5 Âîçâðàò íåñêîëüêèõ çíà÷åíèé ôóíêöèåé . . . . . . . . . . . . . . . . . . . 37
4.6 Âîçâðàò ëîãè÷åñêèõ çíà÷åíèé . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.7 Ìåõàíèçì çàïóñêà ôóíêöèé . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.8 Ðåêóðñèÿ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

5 Кортежи, цикл for, списки 41


5.1 Êîðòåæè . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.2 Ðàáîòà ñ êîðòåæàìè . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.3 Ôóíêöèÿ range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.4 Öèêë for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.5 Ñïèñêè . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.6 Èçìåíåíèå ñïèñêîâ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.7 Ìåòîäû split è join, ôóíêöèÿ map . . . . . . . . . . . . . . . . . . . . . . . 46
5.8 Äðóãèå ïîëåçíûå ìåòîäû äëÿ ðàáîòû ñî ñïèñêàìè . . . . . . . . . . . . . 46
5.9 Ïî÷åìó ñîçäàíèå íîâîãî ëó÷øå óäàëåíèÿ . . . . . . . . . . . . . . . . . . . 47

6 Сортировка, лямбда-функции, именованные параметры 49


6.1 Ñîðòèðîâêà ñïèñêîâ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.2 Ñðàâíåíèå êîðòåæåé è ñïèñêîâ . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.3 Ïàðàìåòð key â ôóíêöèè sort . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.4 ¾Ñòðóêòóðû¿ â Ïèòîíå . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.5 Ëÿìáäà-ôóíêöèè . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.6 Èìåíîâàííûå ïàðàìåòðû è íåîïðåäåëåííîå ÷èñëî ïàðàìåòðîâ . . . . . . . 54
6.7 ×òåíèå äî êîíöà ââîäà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.8 Ñîðòèðîâêà ïîäñ÷åòîì . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.9 Ñâÿçü çàäà÷ ïîèñêà è ñîðòèðîâêè . . . . . . . . . . . . . . . . . . . . . . . 57

7 Множества, словари, полезные методы для строк 59


7.1 Ìíîæåñòâà è õåø-ôóíêöèè . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.2 Ñîçäàíèå ìíîæåñòâ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.3 Ðàáîòà ñ ýëåìåíòàìè ìíîæåñòâ . . . . . . . . . . . . . . . . . . . . . . . . . 61
7.4 Ãðóïïîâûå îïåðàöèè íàä ìíîæåñòâàìè . . . . . . . . . . . . . . . . . . . . 62
7.5 Ñëîâàðè . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
7.6 Êîãäà íóæíî èñïîëüçîâàòü ñëîâàðè . . . . . . . . . . . . . . . . . . . . . . 64
7.7 Ïîëåçíûå ìåòîäû ñòðîê . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.8 Ïðèìåð ðåøåíèÿ ñëîæíîé çàäà÷è íà ñëîâàðè . . . . . . . . . . . . . . . . 65

8 Элементы функционального программирования 67


8.1 Ïàðàäèãìû ïðîãðàììèðîâàíèÿ . . . . . . . . . . . . . . . . . . . . . . . . . 67
8.2 Ôóíêöèîíàëüíîå ïðîãðàììèðîâàíèå . . . . . . . . . . . . . . . . . . . . . . 68
8.3 Èòåðàòîðû è ãåíåðàòîðû . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
8.4 Âñòðîåííûå ôóíêöèè äëÿ ðàáîòû ñ ïîñëåäîâàòåëüíîñòÿìè . . . . . . . . . 70
8.5 Ãåíåðàöèÿ êîìáèíàòîðíûõ îáúåêòîâ itertools . . . . . . . . . . . . . . . . . 71
ОГЛАВЛЕНИЕ 5

8.6 partial, reduce, accumulate . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

9 Объектно-ориентированное программирование 73
9.1 Îáúåêòíî-îðèåíòèðîâàííîå ïðîãðàììèðîâàíèå . . . . . . . . . . . . . . . 73
9.2 Èíêàïñóëÿöèÿ è êîíñòðóêòîðû . . . . . . . . . . . . . . . . . . . . . . . . . 74
9.3 Îïðåäåëåíèå ìåòîäîâ è ñòàíäàðòíûå ôóíêöèè . . . . . . . . . . . . . . . . 75
9.4 Ïåðåîïðåäåëåíèå îïåðàòîðîâ . . . . . . . . . . . . . . . . . . . . . . . . . . 75
9.5 Ïðîâåðêà êëàññà îáúåêòà . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
9.6 Îáðàáîòêà îøèáîê . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
9.7 Íàñëåäîâàíèå è ïîëèìîðôèçì . . . . . . . . . . . . . . . . . . . . . . . . . 79
9.8 Ïåðåîïðåäåëåíèå ìåòîäîâ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9.9 Ïðîåêòèðîâàíèå ñòðóêòóðû êëàññîâ . . . . . . . . . . . . . . . . . . . . . . 82
6 ОГЛАВЛЕНИЕ
Лекция 1

Ввод-вывод, простые типы данных

1.1 Как изучать программирование

Ïî íàøåìó óáåæäåíèþ åäèíñòâåííûé ñïîñîá íàó÷èòüñÿ ïðîãðàììèðîâàòü  ýòî ìíî-


ãî ïðîãðàììèðîâàòü. Âîçìîæíî, âû ñëûøàëè ìíåíèå, ÷òî íàó÷èòü ïðîãðàììèðîâàíèþ
íåâîçìîæíî è åäèíñòâåííûé ñïîñîá ýòî ñàìîîáðàçîâàíèå. Òàê ãîâîðÿò ëþäè, êîòîðûå
íå óìåþò ó÷èòü ïðîãðàììèðîâàíèþ. Ìû óìååì ó÷èòü ïðîãðàììèðîâàíèþ.
Íàø êóðñ áóäåò ñîäåðæàòü â ñåáå áîëüøîå ÷èñëî íåñëîæíûõ ïðàêòè÷åñêèõ çàäà÷,
÷òîáû ¾íàáèòü ðóêó¿.  ëåêöèîííûõ ìàòåðèàëàõ òàêæå áóäóò ñîäåðæàòüñÿ ìàòåðèàëû
äëÿ áîëåå ãëóáîêîãî ïîíèìàíèÿ ïðîèñõîäÿùèõ ïðîöåññîâ.
Ñäà÷à çàäà÷ çàéìåò äîñòàòî÷íî áîëüøîå âðåìÿ è íåêîòîðûå èç íèõ äåéñòâèòåëüíî
ñëîæíûå, íî ÷åðåç ýòîò êóðñ ïðîøëî óæå áîëüøîå êîëè÷åñòâî ëþäåé è åäèíñòâåííàÿ
ïðè÷èíà, ïî êîòîðîé ìàòåìàòè÷åñêè îäàðåííûå ëþäè íå ñìîãëè ïðîéòè åãî  ýòî èõ
ëåíü. Ìû áóäåì ïîìîãàòü âàì áîðîòüñÿ ñ ëåíüþ.

1.2 Язык Python

ßçûê Python (ïî-ðóññêè ìîæíî ïðîèçíîñèòü êàê Ïàéòîí èëè Ïèòîí) ïîÿâèëñÿ â 1991
ãîäó è áûë ðàçðàáîòàí Ãâèäà âàí Ðîññóìîì. ßçûê íàçâàí â ÷åñòü øîó ¾Ëåòàþùèé öèðê
Ìîíòè Ïàéòîíà¿. Îäíà èç ãëàâíûõ öåëåé ðàçðàáîò÷èêîâ  ñäåëàòü ÿçûê çàáàâíûì äëÿ
èñïîëüçîâàíèÿ.
Ñåé÷àñ Ïèòîí ðåãóëÿðíî âõîäèò â äåñÿòêó íàèáîëåå ïîïóëÿðíûõ ÿçûêîâ è õîðîøî
ïîäõîäèò äëÿ ðåøåíèÿ øèðîêîãî êëàññà çàäà÷: îáó÷åíèå ïðîãðàììèðîâàíèþ, ñêðèïòû
äëÿ îáðàáîòêè äàííûõ, ìàøèííîå îáó÷åíèå, ñåðâåðíàÿ âåá-ðàçðàáîòêà è ìíîãîå äðóãîå.
Áîëüøèíñòâó èç âàñ ÿçûê Ïèòîí ïîòðåáóåòñÿ äëÿ íàïèñàíèÿ ïðîåêòîâ è â ðÿäå ïðåäìå-
òîâ òðåòüåãî êóðñà, à òàêæå â ïîâñåäíåâíîì áûòó äëÿ àâòîìàòèçàöèè çàäà÷ îáðàáîòêè
äàííûõ.
Ìû áóäåì èçó÷àòü ÿçûê Ïèòîí òðåòüåé âåðñèè.

7
8 ЛЕКЦИЯ 1. ВВОД-ВЫВОД, ПРОСТЫЕ ТИПЫ ДАННЫХ

1.3 Организация курса, выставление оценок и требо-


вания

Ïðîäîëæèòåëüíîñòü êóðñà  1 ìîäóëü. Îöåíêè âûñòàâëÿþòñÿ çà âûïîëíåíèå äî-


ìàøíèõ çàäàíèé è ýêçàìåí. Íà êàæäîì ñåìèíàðñêîì çàíÿòèè âàì áóäåò ïðåäëîæåíî
íîâîå çàäàíèå, êîòîðîå îöåíèâàåòñÿ ìàêñèìóì â 10 áàëëîâ (ìîæíî ïîëó÷èòü +2 äîïîë-
íèòåëüíûõ áàëëà ðåøàÿ çàäà÷è ¾ñî çâåçäî÷êîé¿). Ðàç â äâå íåäåëè áóäåò ïðîâîäèòñÿ
î÷íàÿ çàùèòà äîìàøíèõ çàäàíèé â âèäå êîíòðîëüíîé ðàáîòû ïî ðåøåíèþ ïðàêòè÷åñêèõ
çàäà÷, ïðè ýòîì çàäà÷è áóäóò ïîõîæè íà çàäà÷è èç ÄÇ. Ïëîõîå íàïèñàíèå êîíòðîëüíîé
ðàáîòû ñíèæàåò îöåíêó çà âåñü áëîê äîìàøíèõ çàäàíèé.
Íà ðåøåíèå çàäà÷ ÄÇ îòâîäèòñÿ îäíà íåäåëÿ (168 ÷àñîâ) ñ ìîìåíòà íà÷àëà ñåìè-
íàðà ïî ñîîòâåòñòâóþùåé òåìå.  òå÷åíèå åùå îäíîé íåäåëè ìîæíî äîñäàòü çàäàíèÿ ñ
êîýôôèöèåíòîì 0.5. Çàòåì çàäàíèÿ íå îöåíèâàþòñÿ. Óâàæèòåëüíîé ïðè÷èíîé äëÿ íåâû-
ïîëíåíèÿ ÄÇ ÿâëÿåòñÿ äëèòåëüíàÿ íåâîçìîæíîñòü ïðîãðàììèðîâàòü, íàïðèìåð, êîìà.
Òàêèå âîïðîñû ðåøàþòñÿ èíäèâèäóàëüíî ñ ïðåïîäàâàòåëåì ñåìèíàðñêèõ çàíÿòèé.
Âñå çàäà÷è ÄÇ, êîíòðîëüíûõ ðàáîò è ýêçàìåíà ïðîâåðÿþòñÿ àâòîìàòè÷åñêè è âðó÷-
íóþ. Ïðîâåðêà ñîñòîèò èç íåñêîëüêèõ ýòàïîâ. Âî-ïåðâûõ, çàäà÷à ïðîâåðÿåòñÿ íà çàðàíåå
ïîäãîòîâëåííîì íàáîðå òåñòîâ, íà êîòîðûõ âàøà ïðîãðàììà äîëæíà âûäàâàòü ïðàâèëü-
íûé îòâåò. Âî-âòîðûõ, êîä ïðîâåðÿåòñÿ íà ñîîòâåòñòâèå ñòàíäàðòàì îôîðìëåíèÿ PEP8
è äðóãèì òðåáîâàíèÿì ïðåäúÿâëåìûõ ïðåïîäàâàòåëÿìè. Â-òðåòüèõ, ïðîãðàììà ïðîõî-
äèò code review, ãäå âàø ïðåïîäàâàòåëü èëè àññèñòåíò ìîæåò äàòü âàì ðåêîìåíäàöèè ïî
èñïðàâëåíèþ ïëîõèõ, íî íå ôîðìàëèçóåìûõ ÿâíî âåùåé. Â-÷åòâåðòûõ, îñóùåñòâëÿåòñÿ
ïðîâåðêà íà ñïèñûâàíèå. Çàäà÷à ñ÷èòàåòñÿ ñäàííîé, òîëüêî åñëè îíà ïðîøëà âñå ÷åòûðå
ýòàïà ïðîâåðêè. ×àñòè÷íûõ îöåíîê çà çàäà÷ó íå ïðåäóñìòîðåíî.
 ñîîòâåòñòâèå ñî âíóòðåííèìè íîðìàòèâíûìè äîêóìåíòàìè â îòíîøåíèå ñòóäåíòîâ,
óëè÷åííûõ â ñïèñûâàíèè èëè äâîéíîé ñäà÷å (ñîâìåñòíîå âûïîëíåíèå ðàáîòû) áóäóò
ïðèìåíåíû ñëåäóþùèå ñàíêöèè:

1. ïðåäóïðåæäåíèå è îáíóëåíèå áàëëà çà âñþ ðàáîòó (äàæå åñëè ñïèñàíà îäíà çàäà-
÷à), â ñëó÷àå ñïèñûâàíèÿ íà êîíòðîëüíîé ðàáîòå  îáíóëåíèå îöåíîê çà âåñü áëîê
äîìàøíèõ ðàáîò

2. âûãîâîð

3. îò÷èñëåíèå

Íàëè÷èå âûãîâîðà íå òîëüêî ñòàâèò ñòóäåíòà â ðèñêîâàííóþ ñèòóàöèþ áûòü îò÷èñ-


ëåííûì çà ëþáîå íàðóøåíèå (íàïðèìåð, çà êóðåíèå âîçëå êîðïóñà), íî è ìåøàåò ïîëó-
÷åíèþ ïîâûøåííûõ ñòèïåíäèé, ïåðåâîäó íà äðóãóþ ñïåöèàëüíîñòü è ìíîãîå äðóãîå.
 ñëó÷àå ïîäëîãà (âûïîëíåíèÿ íåíóæíîé äëÿ ñåáÿ ðàáîòû çà äðóãîãî ÷åëîâåêà), íà-
ïðèìåð, ðåøåíèÿ êîíòðîëüíîé ðàáîòû ÷åëîâåêó, ó êîòîðîãî îíà ïðîèñõîäèò â äðóãîå
âðåìÿ, ïðèìåíÿþòñÿ ñëåäóþùèé ñàíêöèè (íîìåð  ýòî êîëè÷åñòâî âûÿâëåííûõ íàðó-
øåíèé):

1. îò÷èñëåíèå

Îáðàòèòå âíèìàíèå, ÷òî óêàçàííûå ñàíêöèè ïðèìåíÿþòñÿ ê îáîèì ëþäÿì: êàê ê


ñïèñàâøèì, òàê è ê äàâøèì ñïèñàòü.
1.4. ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ 9

Ïðè ýòîì ìû êðàéíå ïîëîæèòåëüíî îòíîñèìñÿ ê êîíñòðóêòèâíîìó îáùåíèþ è âçà-


èìîïîìîùè ìåæäó ñòóäåíòàìè, âåäü êîíñóëüòàöèþ îò ïðåïîäàâàòåëÿ èëè àññèñòåíòà
íå âñåãäà ìîæíî ïîëó÷èòü ñòîëü æå áûñòðî è èñ÷åðïûâàþùå. Ïðè îêàçàíèè ïîìîùè
îòñòàþùèì òîâàðèùàì ñîáëþäàéòå ñëåäóþùèå ïðàâèëà:

1. íå ïîêàçûâàòü/ïåðåñûëàòü êîä ñâîèõ ðåøåíèé

2. íå ïèñàòü êîä çà äðóãîãî ÷åëîâåêà

3. óáåäèòüñÿ, ÷òî îòñòàþùèé ðàçîáðàëñÿ â òåìå è ñïîñîáåí ðåøàòü ïîäîáíûå çàäà÷è


ñàìîñòîÿòåëüíî

1.4 Программное обеспечение

Ìû áóäåì èñïîëüçîâàòü íà íàøåì êóðñå èíòåðïðåòàòîð ÿçûêà Ïèòîí ïîä íàçâàíèå


CPython. Îí óñòàíîâëåí ïî óìîë÷àíèþ â ñîâðåìåííûõ îïåðàöèîííûõ ñèñòåìàõ ñåìåé-
ñòâà Linux, äëÿ îñòàëüíûõ îïåðàöèîííûõ ñèñòåì íåîáõîäèìî ñêà÷àòü åãî ñ îôèöèàëü-
íîãî ñàéòà (ñìîòðè ññûëêè íà âèêè-ñòðàíèöå êóðñà).
Ïîñëå óñòàíîâêè íàì ïîòðåáóåòñÿ IDE (Integrated Development Environment). Ðåêî-
ìåíäîâàíû ê èñïîëüçîâàíèþ Wing IDE 101 è JetBrains PyCharm. Åñëè âàì ãîâîðÿò,
÷òî ëó÷øå ïîëüçîâàòüñÿ vim è ãîëûì èíòåðïðåòàòîðîì  âû ìîæåòå ïîâåðèòü (íà ñâîé
ñòðàõ è ðèñê).
Óêàçàííîå ÏÎ äîëæíî áûòü óñòàíîâëåíî íà âàøèõ íîóòáóêàõ äëÿ âûïîëíåíèÿ ÄÇ,
à òàêæå îíî óñòàíîâëåíî âî âñåõ êîìïüþòåðíûõ êëàññàõ.

1.5 Типы данных и функция вывода

Ïðîãðàììû íà ÿçûêå Ïèòîí ïðåäñòàâëÿþò ñîáîé îáû÷íûå òåêñòîâûå ôàéëû, â êîòî-


ðûõ çàïèñàíà ïîñëåäîâàòåëüíîñòü êîìàíä. Êîä ëåãêî ÷èòàåòñÿ è èíòóèòèâíî ïîíÿòåí.
Íàïðèìåð, ïðîãðàììû âûâîäÿùàÿ Hello, world! çàïèñûâàåòñÿ âñåãî â îäíó ñòðîêó:
print ( ' H e l l o , world ! ' )

 ýòîé ïðîãðàììå âûçûâàåòñÿ ôóíêöèÿ ïå÷àòè print, êîòîðîé â êà÷åñòâå ïàðàìåòðà


ïåðåäàåòñÿ ñòðîêà, ñîäåðæàùàÿ â ñåáå ôðàçó Hello, world!. Åñëè ìû õîòèì çàäàòü êàêóþ-
òî ñòðîêó, òî äîëæíû îáðàìëÿòü å¼ îäèíàðíûìè (') èëè äâîéíûìè() êàâû÷êàìè, èíà÷å
îíà áóäåò èíòåðïðåòèðîâàòüñÿ êàê êîä íà ÿçûêå Ïèòîí.
Êðîìå ñòðîê â ñåãîäíÿøíåì çàíÿòèè ìû ðàññìîòðèì öåëî÷èñëåííûé òèï äàííûõ.
Íàïðèìåð, ìîæíî ïîñ÷èòàòü ðåçóëüòàò âû÷èñëåíèÿ àðèôìåòè÷åñêîãî âûðàæåíèÿ 2 + 3
è âûâåñòè åãî ñ ïîìîùüþ òàêîé îäíîñòðî÷íîé ïðîãðàììû íà ÿçûêå Ïèòîí:
print ( 2 + 3 )

Òàêàÿ ïðîãðàììà âûâåäåò ðåçóëüòàò âû÷èñëåíèÿ âûðàæåíèÿ, êîòîðûé áóäåò ðàâåí


5. Åñëè áû ÷èñëà 2 è 3 áûëè çàêëþ÷åíû â êàâû÷êè, òî îíè èíòåðïðåòèðîâàëèñü áû
êàê ñòðîêè, à îïåðàöèÿ + ïðîâîäèëà áû êîíêàòåíàöèþ (ñêëåèâàíèå) ñòðîê. Íàïðèìåð,
òàêîé êîä:
print ( ' 2 ' + ' 3 ' )
10 ЛЕКЦИЯ 1. ВВОД-ВЫВОД, ПРОСТЫЕ ТИПЫ ДАННЫХ

âûâåäåò 23  ñòðîêó, ñîñòîÿùóþ èç ñêëååííûõ ñèìâîëîâ '2' è '3'.


Ôóíêöèÿ print ìîæåò ïðèíèìàòü è íåñêîëüêî ïàðàìåòðîâ, òîãäà îíè áóäóò âûâî-
äèòüñÿ ÷åðåç ïðîáåë, ïðè÷åì ïàðàìåòðû ìîãóò èìåòü ðàçëè÷íûå òèïû. Åñëè ìû õîòèì
ïîëó÷èòü âûâîä âèäà 2 + 3 = 5, òî ìîæåì âîñïîëüçîâàòüñÿ ñëåäóþùåé ïðîãðàììîé:
print ( ' 2 + 3 = ' , 2 + 3 )

Îáðàòèòå âíèìàíèå, ÷òî â ñòðîêå '2 + 3 =' íåò ïðîáåëà ïîñëå çíàêà =. Ïðîáåë ïîÿâ-
ëÿåòñÿ àâòîìàòè÷åñêè ìåæäó ïàðàìåòðàìè ôóíêöèè print. ×òî æå äåëàòü, åñëè õî÷åòñÿ
âûâåñòè ñòðîêó âèäà 2+3=5 (áåç ïðîáåëîâ)? Äëÿ ýòîãî ïîíàäîáèòñÿ èìåíîâàííûé ïà-
ðàìåòð sep (separator, ðàçäåëèòåëü) äëÿ ôóíêöèè print. Òà ñòðîêà, êîòîðàÿ ïåðåäàåòñÿ
â êà÷åñòâå ïàðàìåòðà sep áóäåò ïîäñòàâëÿòüñÿ âìåñòî ïðîáåëà â êà÷åñòâå ðàçäåëèòåëÿ.
 ýòîé çàäà÷å ìû áóäåì èñïîëüçîâàòü ïóñòóþ ñòðîêó â êà÷åñòâå ðàçäåëèòåëÿ. Ïóñòàÿ
ñòðîêà çàäàåòñÿ äâóìÿ ïîäðÿä èäóùèìè êàâû÷êàìè.
print ( '2+3= ' , 2 + 3 , s e p= ' ' )

 êà÷åñòâå ïàðàìåòðà sep ìîæíî èñïîëüçîâàòü ëþáóþ ñòðîêó, â òîì ÷èñëå ñîñòîÿùóþ
èç íåñêîëüêèõ ñèìâîëîâ. Åñëè íàì íóæíî ñäåëàòü íåñêîëüêî ðàçíûõ ðàçäåëèòåëåé äëÿ
ðàçíûõ ÷àñòåé ñòðîê, òî íå îñòàåòñÿ äðóãîãî âûáîðà, êðîìå êàê èñïîëüçîâàòü íåñêîëüêî
ïîäðÿä èäóùèõ ôóíêöèé print. Íàïðèìåð, åñëè ìû õîòèì âûâåñòè ñòðîêó âèäà 1 + 2 +
3 + 4 = 10, òî ìîæåì ïîïðîáîâàòü âîñïîëüçîâàòüñÿ ñëåäóþùèì êîäîì:
print ( 1 , 2 , 3 , 4 , s e p = ' + ' )
print ( ' = ' , 1 + 2 + 3 + 4 , s e p = ' ' )

Îäíàêî, âûâîä òàêîãî êîäà íàñ îãîð÷èò. Îí áóäåò âûãëÿäåòü êàê:

1 + 2 + 3 + 4
= 10

Ýòî ñâÿçàíî ñ òåì, ÷òî ïîñëå êàæäîé ôóíêöèè print ïî óìîë÷àíèþ îñóùåñòâëÿåòñÿ
ïåðåâîä ñòðîêè. Äëÿ èçìåíåíèÿ òîãî, ÷òî áóäåò ïå÷àòàòüñÿ ïîñëå âûâîäà âñåãî, ÷òî åñòü
â ôóíêöèè print ìîæíî èñïîëüçîâàòü èìåíîâàííûé ïàðàìåòð end. Íàïðèìåð, â íàøåì
ñëó÷àå ïîñëå ïåðâîãî print ìû íå õîòåëè áû ïå÷àòàòü íè÷åãî. Ïðàâèëüíûé êîä âûãëÿäèò
ñëåäóþùèì îáðàçîì:
print ( 1 , 2 , 3 , 4 , s e p= ' + ' , end= ' ' )
print ( ' = ' , 1 + 2 + 3 + 4 , s e p= ' ' )

 êà÷åñòâå end òàêæå ìîæíî èñïîëüçîâàòü àáñîëþòíî ëþáóþ ñòðîêó.

1.6 Переменные

 íåêîòîðûõ çàäà÷àõ âû÷èñëåíèÿ óäîáíî ïðîâîäèòü èñïîëüçóÿ âñïîìîãàòåëüíûå ïå-


ðåìåííûå. Íàïðèìåð, â øêîëüíûõ ôîðìóëàõ ïî ôèçèêè áûëî óäîáíî âû÷èñëÿòü íå
ãèãàíòñêîå âûðàæåíèå öåëèêîì, à çàïîìèíàÿ ðåçóëüòàòû âû÷èñëåíèÿ âî âñïîìîãàòåëü-
íûå ïåðåìåííûå. Äëÿ ïðèìåðà ðåøèì çàäà÷ó âû÷èñëåíèÿ ïðîéäåííîãî ðàññòîÿíèÿ ïî
èçâåñòíîìó âðåìåíè è ñêîðîñòè:
1.7. АРИФМЕТИЧЕСКИЕ ВЫРАЖЕНИЯ 11

s p e e d = 108
time = 12
d i s t = s p e e d * time
print ( d i s t )
 ýòîé ïðîãðàììå ìû ñîçäàåì òðè ïåðåìåííûå: speed äëÿ ñêîðîñòè, time äëÿ âðåìåíè
è dist äëÿ âû÷èñëåííîãî ðàññòîÿíèÿ. Ïðè èñïîëüçîâàíèè ïåðåìåíûõ â àðèôìåòè÷åñêîì
âûðàæåíèè ïðîñòî èñïîëüçóåòñÿ çíà÷åíèå, êîòîðîå ëåæèò â ïåðåìåííîé.
Äëÿ ïðèñâàèâàíèÿ çíà÷åíèÿ ïåðåìåííîé èñïîëüçóåòñÿ çíàê =. Èìÿ ïåðåìåííîé äîëæ-
íî áûòü çàïèñàíî ñëåâà îò çíàêà ïðèñâàèâàíèÿ, à àðèôìåòè÷åñêîå âûðàæåíèå (â êîòî-
ðîì ìîãóò áûòü èñïîëüçîâàíû ÷èñëà è äðóãèå óæå çàäàííûå ïåðåìåííûå)  ñïðàâà. Èìÿ
ïåðåìåííîé äîëæíî íà÷èíàòüñÿ ñ ìàëåíüêîé ëàòèíñêîé áóêâû, äîëæíî áûòü îñìûñ-
ëåííûì (àíëèéñêèå ñëîâà èëè îáùåóïîòðåáèìûå ñîêðàùåíèÿ) è íå äîëæíî ïðåâûøàòü
ïî äëèíå 10-15 ñèìâîëîâ. Åñëè ëîãè÷íîå èìÿ ïåðåìåííîé ñîñòîèò èç íåñêîëüêèõ ñëîâ,
òî íóæíî çàïèñûâàòü åãî ñ ïîìîùüþ camelTyping (êàæäîå íîâîå ñëîâî êðîìå ïåðâîãî
äîëæíî áûòü çàïèñàíî ñ áîëüøîé áóêâû).
Ïîäáðîáíåå î òîì, êàê îñóùåñòâëÿåòñÿ ïðèñâàèâàíèå áóäåò îïèñàíî íèæå.

1.7 Арифметические выражения

Ìû óæå èñïîëüçîâàëè àðèôìåòè÷åñêèå âûðàæåíèÿ â íàøèõ ïðîãðàììàõ, â ÷àñòíî-


ñòè îïåðàöèè + è *. Òàêæå ñóùåñòâóåò ðÿä äðóãèõ àðèôìåòè÷åñêèõ îïåðàöèé, êîòîðûå
ïðèâåäåíû â òàáëèöå:
Îáîçíà÷åíèå Îïåðàöèÿ Îïåðàíä 1 Îïåðàíä 2 Ðåçóëüòàò
+ Ñëîæåíèå 11 6 17
- Âû÷èòàíèå 11 6 5
* Óìíîæåíèå 11 6 66
// Öåëî÷èñëåííîå äåëåíèå 11 6 1
% Îñòàòîê îò äåëåíèÿ 11 6 5
** Âîçâåäåíèå â ñòåïåíü 2 3 8
Âñå îïåðàöèè èíôèêñíûå (çàïèñûâàþòñÿ ìåæäó îïåðàíäàìè), ò.å., íàïðèìåð, äëÿ
âîçâåäåíèÿ 2 â ñòåïåíü 3 íóæíî ïèñàòü 2**3.
Îñîáî îñòàíîâèìñÿ íà îïåðàöèÿõ âû÷èñëåíèÿ öåëîé ÷àñòè è îñòàòêà îò äåëåíèÿ îò
÷èñëà.
Ïóñòü çàäàíû äâà ÷èñëà 𝐴 è 𝐵 , ïðè÷åì 𝐵 > 0. Îáîçíà÷èì çà 𝐶 öåëóþ ÷àñòü îò
äåëåíèÿ 𝐴 íà 𝐵 , 𝐶 = 𝐴//𝐵 , à çà 𝐷  îñòàòîê îò äåëåíèÿ 𝐴 íà 𝐵 , 𝐷 = 𝐴%𝐵 .
Òîãäà äîëæíû âûïîëíÿòüñÿ ñëåäóþùèå óòâåðæäåíèÿ:

𝐴=𝐵×𝐶 +𝐷

0≤𝐷<𝐵
Ýòè óòâåðæäåíèÿ íåîáõîäèìû äëÿ ïîíèìàíèÿ ïðîöåññà âçÿòèÿ îñòàòêà îò äåëåíèÿ
îòðèöàòåëüíîãî ÷èñëà íà ïîëîæèòåëüíîå. Íåòðóäíî óáåäèòüñÿ, ÷òî åñëè -5 ðàçäåëèòü
íà 2, òî öåëàÿ ÷àñòü äîëæíà áûòü ðàâíà -3, à îñòàòîê ðàâåí 1.  íåêîòîðûõ äðóãèõ
ÿçûêàõ ïðîãðàììèðîâàíèÿ îñòàòêè â òàêîé ñèòóàöèè ìîãóò áûòü îòðèöàòåëüíûìè, ÷òî
íåïðàâèëüíî ïî ìàòåìàòè÷åñêèì îïðåäåëåíèÿì.
12 ЛЕКЦИЯ 1. ВВОД-ВЫВОД, ПРОСТЫЕ ТИПЫ ДАННЫХ

 ñëó÷àå, åñëè 𝐵 < 0 âûïîëíÿþòñÿ ñëåäóþùèå óòâåðæäåíèÿ:

𝐴=𝐵×𝐶 +𝐷

𝐵<𝐷≤0
Íàïðèìåð, ïðè äåëåíèè 11 íà -5 ìû ïîëó÷èì öåëóþ ÷àñòü ðàâíóþ -3, à îñòàòîê áóäåò
ðàâåí -4.
Åñëè æå ðàçäåëèòü -11 íà -5, òî öåëàÿ ÷àñòü áóäåò ðàâíà 2, à îñòàòîê áóäåò ðàâåí -1.
Îáðàòèòå âíèìàíèå, ÷òî öåëûå ÷èñëà â Ïèòîíå íå èìåþò îãðàíè÷åíèé íà äëèíó
(êðîìå îáúåìà äîñòóïíîé ïàìÿòè).

1.8 Операции над строками

Ñòðîêè òàêæå ìîæíî ñîõðàíÿòü â ïåðåìåííûå è èñïîëüçîâàòü â íåêîòîðîì îãðàíè-


÷åííîì êîëè÷åñòâå âûðàæåíèé.  ÷àñòíîñòè, ìîæíî ñêëåèâàòü äâå ñòðîêè ñ ïîìîùüþ
îïåðàöèè +:
goodByePhrase = ' Hasta l a v i s t a '
p e r s o n = ' baby '
print ( goodByePhrase + ' , ' p e r s o n + ' ! ' )
Òàêæå ìîæíî óìíîæèòü ñòðîêó íà öåëîå íåîòðèöàòåëüíîå ÷èñëî, â ðåçóëüòàòå ïî-
ëó÷èòñÿ èñõîäíàÿ ñòðîêà ïîâòîðåííàÿ çàäàííîå ÷èñëî ðàç:
word = ' Bye '
p h r a s e = word * 3 + ' ! '
print ( p h r a s e )
Âûâîä ýòîé ïðîãðàììû áóäåò ByeByeBye!
Ñêëàäûâàòü ÷èñëî ñî ñòðîêîé (è íàîáîðîò) íåëüçÿ. Íî ìîæíî âîñïîëüçîâàòüñÿ ôóíê-
öèåé str, êîòîðàÿ ïî ÷èñëó ãåíåðèðóåò ñòðîêó. Str  ýòî ñîêðàùåíèå îò ñëîâà string,
êîòîðîå ìîæíî ïåðåâåñòè íà ðóññêèé êàê ¾ñòðîêà, êîòîðàÿ ïðåäñòàâëÿåò ñîáîé ïîñëå-
äîâàòåëüíîñòü ñèìâîëîâ¿. Íàïðèìåð, çàäà÷ó ïðî âûâîä 2 + 3 = 5 ìîæíî ðåøèòü è òàêèì
ñïîñîáîì:
answer = ' 2 + 3 = ' + s t r ( 2 + 3 )
print ( answer )

1.9 Чтение данных

Ïðîãðàììû, êîòîðûå óìåþò òîëüêî ïèñàòü, íî íå óìåþò ÷èòàòü, ðåäêî ïðåäñòàâëÿþò


èíòåðåñ äëÿ ïîëüçîâàòåëåé. Óçíàâàòü ÷òî-òî èç âíåøíåãî ìèðà íàøè ïðîãðàììû áóäóò ñ
ïîìîùüþ ôóíêöèè input(). Ýòà ôóíêöèÿ ñ÷èòûâàåò ñòðîêó èç êîíñîëè, ÷òîáû çàêîí÷èòü
ââîä ñòðîêè íóæíî íàæàòü Enter. Ïîä ñòðîêîé â äàííîì ñëó÷àå ïîíèìàåòñÿ àíãëèéñêîå
ñëîâî line, ÷òî îçíà÷àåò ¾ñòðîêà, îêàí÷èâàþùàÿñÿ ïåðåâîäîì ñòðîêè¿. Íàïðèìåð, åñëè
â òàêóþ ïðîãðàììó:
name = input ( )
print ( ' I l o v e ' , name )
1.10. ПРИМЕРЫ РЕШЕНИЯ ЗАДАЧ 13

ââåñòè ñëîâî Python, òî îíà íàïå÷àòàåò I love Python.


Âî ìíîãèõ çàäà÷àõ íàì òðåáóåòñÿ ðàáîòàòü ñî ââåäåííûìè ÷èñëàìè, à ÷èòàòü ìû
óìååì òîëüêî ñòðîêè. ×òîáû ïðåîáðàçîâàòü ñòðîêó, ñîñòîÿùóþ èç öèôð (è, âîçìîæíî,
çíàêà − ïåðåä íèìè) â öåëîå ÷èñëî ìîæíî âîñïîëüçîâàòüñÿ ôóíêöèåé int (ñîêðàùåíèå
îò àíãëèéñêîãî integer, ¾öåëîå ÷èñëî¿). Íàïðèìåð, ðåøåíèå çàäà÷è î ñëîæåíèè äâóõ
÷èñåë áóäåò âûãëÿäåòü òàê:
a = i n t ( input ( ) )
b = i n t ( input ( ) )
print ( a + b )
Ôóíêöèÿ int ìîæåò áûòü ïðèìåíåíà íå òîëüêî ê ðåçóëüòàòó, âîçâðàùàåìîìó ôóíê-
öèåé input, íî è ê ïðîèçâîëüíîé ñòðîêå.
 ñòðîêàõ ìîãóò áûòü íå òîëüêî áóêâû, öèôðû è ïðî÷èå çíàêè ïðåïèíàíèÿ, íî è,
íàïðèìåð, ñèìâîëû òàáóëÿöèè è ïåðåâîäà ñòðîêè. ×òîáû èñïîëüçîâàòü ýòè ñèìâîëû â
êîíñòàíòíîé ñòðîêå â êîäå ïðîãðàììû íåîáõîäèìî çàïèñûâàòü èõ êàê \t è \n ñîîòâåò-
ñòâåííî. Èñïîëüçîâàíèå áýêñëåøà ïåðåä ñèìâîëîì íàçûâàåòñÿ ýêðàíèðîâàíèå. Òàêæå
ñóùåñòâóþò è äðóãèå ñèìâîëû, êîòîðûå òðåáóþò áýêñëåøà ïåðåä ñîáîé. Íàïðèìåð, ýòî
êàâû÷êè \' è \ (èñïîëüçîâàíèå áýêñëåøà ïðîñòî íåîáõîäèìî, åñëè â ñòðîêå èñïîëüçóþò-
ñÿ îáà òèïà êàâû÷åê), à òàêæå, ñîáñòâåííî, ñèìâîë áýêñëåøà, êîòîðûé íàäî çàïèñûâàòü
êàê \\.
 ñëó÷àå ñ÷èòûâàíèÿ ñ ïîìîùüþ input ñèìâîëû â êîíñîëè ýêðàíèðîâàòü íå íóæíî.

1.10 Примеры решения задач

Ðàññìîòðìè íåñêîëüêî çàäà÷, ðåøàåìûõ ñ ïîìîùüþ àðèôìåòè÷åñêèõ îïåðàöèé, êî-


òîðûå ïîêàçûâàþò íåêîòîðûå èäåè.
Ïóñòü åñòü äâà òîâàðà, ïåðâûé èç íèõ ñòîèò 𝐴 ðóáëåé 𝐵 êîïååê, à âòîðîé  𝐶 ðóáëåé
𝐷 êîïååê. Ñêîëüêî ðóáëåé è êîïååê ñòîÿò ýòè òîâàðû âìåñòå.
 çàäà÷àõ ãäå åñòü íåñêîëüêî ðàçìåðíîñòåé âåëè÷èí (íàïðèìåð, ðóáëè è êîïåéêè,
êèëîìåòðû è ìåòðû, ÷àñû è ìèíóòû) ñëåäóåò ïåðåâîäèòü âñå â íàèìåíüøóþ åäèíèöó
èçìåðåíè, îñóùåñòâëÿòü íåîáõîäèìûå äåéñòâèÿ, à çàòåì ïåðåâîäèòü îáðàòíî ê íóæíûì
åäèíèöàì.
 íàøåé çàäà÷å íàèìåíüøåé åäèíèöåé ÿâëÿþòñÿ êîïåéêè, ïîýòîìó âñå öåíû ñëåäóåò
ïåðåâåñòè â íèõ, çàòåì ñëîæèòü èõ, à çàòåì ïåðåâåñòè ðåçóëüòàò îáðàòíî â ðóáëè è
êîïåéêè. Êîä ðåøåíèÿ áóäåò âûãëÿäåòü òàê:
a = i n t ( input ( ) )
b = i n t ( input ( ) )
c = i n t ( input ( ) )
d = i n t ( input ( ) )
c o s t 1 = a * 100 + b
c o s t 2 = c * 100 + d
totalCost = cost1 + cost2
print ( t o t a l C o s t // 1 0 0 , t o t a l C o s t % 1 0 0 )
Äëÿ îïðåäåëåíèÿ êîëè÷åñòâà ðóáëåé íóæíî ðàçäåëèòü öåíó â êîïåéêàõ íà 100 íà-
öåëî, à äëÿ îïðåäåëåíèÿ îñòàâøåãîñÿ ÷èñëà êîïååê  ïîñ÷èòàòü îñòàòîê îò äåëåíèÿ íà
100.
14 ЛЕКЦИЯ 1. ВВОД-ВЫВОД, ПРОСТЫЕ ТИПЫ ДАННЫХ

Ñëåäóþùàÿ çàäà÷à: Âàñÿ èãðàåò â Super Mario Bros. î÷åíü õîðîøî è ïîëó÷èë 𝑁
äîïîëíèòåëüíûõ æèçíåé. Èçâåñòíî, ÷òî ïåðåìåííàÿ, â êîòîðîé õðàíèòñÿ êîëè÷åñòâî
æèçíåé ìîæåò ïðèíèìàòü çíà÷åíèÿ îò 0 äî 255.  ñëó÷àå, åñëè áûëî 255 æèçíåé è èãðîê
ïîëó÷èë äîïîëíèòåëüíóþ æèçíü, ñ÷åò÷èê îáíóëÿåòñÿ. Ñêîëüêî æèçíåé íà ñ÷åò÷èêå?
 ýòîé çàäà÷å äîñòàòî÷íî ïîñ÷èòàòü îñòàòîê îò äåëåíèÿ ââåäåííîãî ÷èñëà íà 256.
Òàêèå äåéñòâèÿ ÷àñòî òðåáóþòñÿ, íàïðèìåð, ïðè ðàáîòå ñî âðåìåíåì (ïðè ïåðåõîäå ÷åðåç
ñóòêè ñ÷åò÷èê âðåìåíè îáíóëÿåòñÿ). Ðåøåíèå çàäà÷è âûãëÿäèò òàê:
n = i n t ( input ( ) )
print ( n % 2 5 6 )
Ñëåäóþùàÿ çàäà÷à: ââîäèòñÿ ÷èñëî 𝑁 , íåîáõîäèìî îòðåçàòü îò íåãî 𝐾 ïîñëåäíèõ
öèôð. Íàïðèìåð, ïðè 𝑁 = 123456 è 𝐾 = 3 îòâåò äîëæåí áûòü 123.
Äëÿ ðåøåíèÿ ýòîé çàäà÷è íóæíî ïîíÿòü, ÷òî ïðîèñõîäèò ïðè öåëî÷èñëåííîì äå-
ëåíèè íà 10 (îñíîâàíèå ñèñòåìû ñ÷èñëåíèÿ). Åñëè ìû ðàçäåëèì ÷èñëî íà 10, òî áóäåò
îòáðîøåíà ïîñëåäíÿÿ öèôðà, íåçàâèñèìî îò òîãî, êàêîé îíà áûëà. Åñëè ðàçäåëèì ÷èñëî
íà 100  áóäåò îòáðîøåíî äâå ïîñëåäíèå öèôðû. Èñõîäÿ èç ýòîãî ïîëó÷àåòñÿ ðåøåíèå
çàäà÷è: íåîáõîäèìî ïðîñòî ðàçäåëèòü ÷èñëî 𝑁 íà 10𝐾 :
n = i n t ( input ( ) )
k = i n t ( input ( ) )
print ( n // 10 ** k )

1.11 Как переменные устроены внутри

 ÿçûêå Ïèòîí âñå ïåðåìåííûå ÿâëÿþòñÿ ññûëêàìè íà îáúåêòû. Êàæäûé îáúåêò


èìååò òèï (íàì èçâåñòíû int è str) è ñîäåðæèìîå, â íàøåì ñëó÷àå êîíêðåòíîå ÷èñëî èëè
ïîñëåäîâàòåëüíîñòü ñèìâîëîâ.
Ïåðåìåííûå (ññûëêè) â ÿçûêå Ïèòîí óäîáíî ïðåäñòàâëÿòü ñåáå êàê ÿðëû÷êè íà âå-
ðåâî÷êå, êîòîðûå ïðèâÿçàíû ê êàêîìó-òî îáúåêòó. Âîîáùå ãîâîðÿ, ê îäíîìó îáúåêòó
ìîæåò áûòü ïðèâÿçàíî ñêîëü óãîäíî ìíîãî ÿðëûêîâ. Ðàçëè÷íûå ïåðåìåííûå ñ îäèíàêî-
âûì çíà÷åíèåì ôàêòè÷åñêè ÿâëÿþòñÿ ÿðëû÷êàìè, ïðèâÿçàííûìè ê îäíîìó è òîìó æå
îáúåêòó.
Òèïû int è str â Ïèòîíå ÿâëÿþòñÿ íåèçìåíÿåìûìè. Ëþáîå ïðèñâàèâàíèå â Ïèòîíå
íå ìîæåò èçìåíèòü íåèçìåíÿåìûé òèï, à ìîæåò òîëüêî èçìåíèòü ìåñòî, íà êîòîðîå
óêàçûâàåò ññûëêà (è, ïðè íåîáõîäèìîñòè, ñêîíñòðóèðîâàòü íîâûé îáúåêò).
Íàïðèìåð, êîìàíäà x = 2, ïðèâåäåò ñíà÷àëà ê ñîçäàíèþ îáúåêòà òèïà ¾öåëîå ÷èñëî¿
ñî çíà÷åíèåì 2 â ïàìÿòè, à çàòåì ê ñîçäàíèþ ïåðåìåííîé x, êîòîðàÿ áóäåò ÿâëÿòüñÿ
ññûëêîé íà ýòîò îáúåêò.
Åñëè ïîñëå ýòîãî íàïèñàòü y = 2, òî íîâûé îáúåêò ñî çíà÷åíèåì 2 ñîçäàâàòüñÿ íå
áóäåò, à ñîçäàñòñÿ òîëüêî íîâàÿ ññûëêà ñ èìåíåì y ïîêàçûâàþùàÿ íà òîò æå ñàìûé
îáúåêò, ÷òî è ññûëêà x.
Åñëè òåïåðü íàïèñàòü ñòðîêó x = 3, òî ñ îáúåêòîì ñî çíà÷åíèåì 2 íè÷åãî íå ñëó÷èòñÿ,
âåäü îí íå íåèçìåíÿåìûé. Ñîçäàñòñÿ íîâûé îáúåêò ñî çíà÷åíèåì 3, ññûëêà x îòâÿæåòñÿ
îò îáúåêòà ñî çíà÷åíèåì 2 è ïðèâÿæåòñÿ ê íîâîìó îáúåêòó 3. Ïðè ýòîì ê îáúåêòó 2
îñòàíåòñÿ ïðèâÿçàíà ññûëêà y.
Åñëè èçìåíèòü è çíà÷åíèå ïåðåìåííîé y, òî ó îáúåêòà 2 íå îñòàíåòñÿ ññûëîê íà íåãî.
Ïîýòîìó îí ìîæåò áûòü áåçáîëåçíåííî óíè÷òîæåí ïðè ñáîðêå ìóñîðà, âåäü ïîëó÷èòü ê
1.12. КАК РЕШАТЬ ЗАДАЧИ 15

íåìó äîñòóï óæå íåâîçìîæíî  íà íåãî íå ññûëàåòñÿ íè îäíà ïåðåìåííàÿ.


Êîíñòàíòíûå çíà÷åíèÿ â ïðîãðàììå (íàïðèìåð, ÿâíî çàäàííûå ÷èñëà â èñõîäíîì êî-
äå ïðîãðàììû) òàêæå ÿâëÿþòñÿ ññûëêàìè íà îáúåêòû, ñîäåðæèìîå êîòîðûõ ñîâïàäàåò
ñî çíà÷åíèåì ýòèõ êîíñòàíò. Îäíàêî ýòè ññûëêè íå ìîãóò áûòü èçìåíåíû è íå ìîãóò
ó÷àñòâîâàòü â ïðèñâàèâàíèè ñ ëåâîé ñòîðîíû îò çíàêà =.

1.12 Как решать задачи

Ó êàæäîé çàäà÷è â âàøåì äîìàøíåì çàäàíèè åñòü óñëîâèå, ôîðìàò âõîäíûõ è âû-
õîäíûõ äàííûõ è ïðèìåðû.  óñëîâèè ñîäåðæèòñÿ îïèñàíèå çàäà÷è, êîòîðóþ íóæíî
ðåøèòü.  ôîðìàòå âõîäíûõ äàííûõ ñêàçàíî, êàêèå ÷èñëà ââîäÿòñÿ è â êàêîì ïîðÿä-
êå îíè äàíû, à òàêæå óêàçàíû îãðàíè÷åíèÿ íà ýòè ÷èñëà. Ãàðàíòèðóåòñÿ, ÷òî ÷èñåë
áóäåò ñòîëüêî, ñêîëüêî íóæíî, è îíè áóäóò óäîâëåòâîðÿòü îãðàíè÷åíèÿì. Âàì íóæíî
ðåøèòü çàäà÷ó òîëüêî äëÿ óêàçàííûõ îãðàíè÷åíèé. Êàê ïðîãðàììà áóäåò ðàáîòàòü äëÿ
÷èñåë, íå óäîâëåòâîðÿþùèõ îãðàíè÷åíèÿì  àáñîëþòíî íåâàæíî, òàêèõ òåñòîâ íå áóäåò.
 ôîðìàòå âûõîäíûõ äàííûõ óêàçûâàåòñÿ, ÷òî è â êàêîì ïîðÿäêå ïðîãðàììà äîëæíà
âûâîäèòü  íè÷åãî, êðîìå ýòîãî, â ðåøåíèè áûòü íå äîëæíî.
Ïðèìåðû ê çàäà÷å íóæíû äëÿ ëó÷øåãî ïîíèìàíèÿ óñëîâèÿ è ïåðâîíà÷àëüíîé ñà-
ìîïðîâåðêè. Åñòåñòâåííî, ïðîãðàììà äîëæíà ðàáîòàòü íå òîëüêî íà ïðèìåðàõ, íî è íà
ëþáûõ äðóãèõ äîïóñòèìûõ âõîäíûõ äàííûõ.
Åñëè ïðîãðàììà ðàáîòàåò ïðàâèëüíî, òî îíà ïîëó÷èò ñòàòóñ OK. Åñëè ïðîãðàììà
ïîëó÷èëà äðóãîé ñòàòóñ  âàì ñëåäóåò ïðèäóìàòü òåñòû, óäîâëåòâîðÿþùèå îãðàíè-
÷åíèÿì, è ïðîâåðèòü ðàáîòó ñâîåé ïðîãðàììû. Îáÿçàòåëüíî íàéä¼òñÿ îøèáêà. Íàøà
òåñòèðóþùàÿ ñèñòåìà ðàáîòàåò ïðàâèëüíî. Íàøè òåñòû ïðàâèëüíûå. Ïðàâèëüíûå îò-
âåòû ê íàøèì òåñòàì ïðàâèëüíûå. Ýòî òî÷íî. Ìû ïðîâåðÿëè ìíîãî ðàç. È íå òîëüêî
ìû.
16 ЛЕКЦИЯ 1. ВВОД-ВЫВОД, ПРОСТЫЕ ТИПЫ ДАННЫХ
Лекция 2

Логический тип данных, условный

оператор, цикл while, вещественные

числа

2.1 Логический тип данных

Êðîìå óæå èçâåñòíûõ íàì öåëî÷èñëåííûõ è ñòðîêîâûõ òèïîâ äàííûõ â Ïèòîíå ñó-
ùåñòâóåò òàêæå ëîãè÷åñêèé òèï äàííûõ, êîòîðûé ìîæåò ïðèíèìàòü çíà÷åíèÿ ¾èñòèíà¿
(True) èëè ¾ëîæü¿ (False).
Ïî àíàëîãèè ñ àðèôìåòè÷åñêèìè âûðàæåíèÿìè ñóùåñòâóþò ëîãè÷åñêèå âûðàæåíèÿ,
êîòîðûå ìîãóò áûòü èñòèííûìè èëè ëîæíûìè. Ïðîñòîå ëîãè÷åñêîå âûðàæåíèå èìååò
âèä <àðèôìåòè÷åñêîå âûðàæåíèå> <çíàê ñðàâíåíèÿ> <àðèôìåòè÷åñêîå âûðàæåíèå>.
Íàïðèìåð, åñëè ó íàñ åñòü ïåðåìåííûå 𝑥 è 𝑦 ñ êàêèìè-òî çíà÷åíèÿìè, òî ëîãè÷åñêîå
âûðàæåíèå 𝑥 + 𝑦 < 3 * 𝑦 â êà÷åñòâå ïåðâîãî àðèôìåòè÷åñêîãî âûðàæåíèÿ èìååò 𝑥 + 𝑦 , â
êà÷åñòâå çíàêà ñðàâíåíèÿ < (ìåíüøå), à âòîðîå àðèôìåòè÷åñêîå âûðàæåíèå â í¼ì 3 * 𝑦 .
 ëîãè÷åñêèõ âûðàæåíèÿõ äîïóñòèìû ñëåäóþùèå çíàêè ñðàâíåíèé:
Çíàê ñðàâíåíèÿ Îïèñàíèå
== ðàâíî
!= íå ðàâíî
< ìåíüøå
> áîëüøå
<= ìåíüøå èëè ðàâíî
>= áîëüøå èëè ðàâíî
 Ïèòîíå äîïóñòèìû è ëîãè÷åñêèå âûðàæåíèÿ, ñîäåðæàùèå íåñêîëüêî çíàêîâ ñðàâ-
íåíèÿ, íàïðèìåð 𝑥 < 𝑦 < 𝑧 . Ïðè ýòîì âñå ñðàâíåíèÿ îáëàäàþò îäèíàêîâûì ïðèîðèòå-
òîì, êîòîðûé ìåíüøå, ÷åì ó ëþáîé àðèôìåòè÷åñêîé îïåðàöèè.
Ðåçóëüòàò âû÷èñëåíèÿ ëîãè÷åñêîãî âûðàæåíèÿ ìîæíî ñîõðàíÿòü â ïåðåìåííóþ, êî-
òîðàÿ áóäåò èìåòü òèï bool. Ïåðåìåííûå òàêîãî òèïà, êàê è ÷èñëà è ñòðîêè, ÿâëÿþòñÿ
íåèçìåíÿåìûìè îáúåêòàìè.
Îäíèì èç ïðèìåðîâ èñïîëüçîâàíèÿ ëîãè÷åñêîãî âûðàæåíèÿ ÿâëÿåòñÿ ïðîâåðêà íà
äåëèìîñòü. Íàïðèìåð, ÷òîáû ïðîâåðèòü, ÿâëÿåòñÿ ëè ÷èñëî ÷åòíûì, íåîáõîäèìî ñðàâ-
íèòü îñòàòîê îò äåëåíèÿ ýòîãî ÷èñëà íà äâà ñ íóë¼ì:
i s E v e n = number % 2 == 0

17
18ЛЕКЦИЯ 2. ЛОГИЧЕСКИЙ ТИП ДАННЫХ, УСЛОВНЫЙ ОПЕРАТОР, ЦИКЛ WHILE, ВЕЩЕС

Ñòðîêè òàêæå ìîãóò ñðàâíèâàòüñÿ ìåæäó ñîáîé. Ïðè ýòîì ñðàâíåíèå ïðîèñõîäèò â
ëåêñèêîãðàôè÷åñêîì ïîðÿäêå (êàê óïîðÿäî÷åíû ñëîâà â ñëîâàðå).

2.2 Логические операции

×òîáû çàïèñàòü ñëîæíîå ëîãè÷åñêîå âûðàæåíèå, ÷àñòî áûâàåò íåîáõîäèìî âîñïîëü-


çîâàòüñÿ ëîãè÷åñêèìè ñâÿçêàìè ¾è¿, ¾èëè¿ è ¾íå¿.  Ïèòîíå îíè îáîçíà÷àþòñÿ êàê and,
or è not ñîîòâåòñòâåííî. Îïåðàöèè and è or ÿâëÿåþòñÿ áèíàðíûìè, ò.å. äîëæíû áûòü
çàïèñàíû ìåæäó îïåðàíäàìè, íàïðèìåð x < 3 or y > 2. Îïåðàöèÿ not  óíàðíàÿ è
äîëæíà áûòü çàïèñàíà ïåðåä åäèíñòâåííûì ñâîèì îïåðàíäîì.
Âñå ëîãè÷åñêèå îïåðàöèè èìåþò ïðèîðèòåò íèæå, ÷åì îïåðàöèè ñðàâíåíèÿ (à çíà-
÷èò, è íèæå ÷åì àðèôìåòè÷åñêèå îïåðàöèè). Ñðåäè ëîãè÷åñêèõ îïåðàöèé íàèâûñøèé
ïðèîðèòåò èìååò îïåðàöèÿ not, çàòåì èäåò and è íàèìåíüøèé ïðèîðèòåò èìååò îïåðà-
öèÿ or. Íà ïîðÿäîê âûïîëíåíèÿ îïåðàöèé ìîæíî âëèÿòü ñ ïîìîùüþ ñêîáîê, êàê è â
àðèôìåòè÷åñêèõ âûðàæåíèÿõ.
Äëÿ ïðèìåðà ïîñìîòðèì çàäà÷ó î ïåðåñå÷åíèè äâóõ äëèòåëüíûõ ñîáûòèé ïî âðåìåíè.
Îáà ñîáûòèÿ õàðàêòåðèçóþòñÿ äâóìÿ ÷èñëàìè  ãîäàìè íà÷àëà è êîíöà. Íåîáõîäèìî
îïðåäåëèòü, ïåðåñåêàëèñü ëè ñîáûòèÿ âî âðåìåíè, ïðè ýòîì åñëè îäíî ñîáûòèå íà÷àëîñü
â òîò ãîä, êîãäà çàêîí÷èëîñü äðóãîå  îíè ñ÷èòàþòñÿ ïåðåñåêàþùèìèñÿ.
Ïåðâàÿ èäåÿ çàêëþ÷àåòñÿ â òîì, ÷òîáû ðàññìîòðåòü âñå âîçìîæíûå âàðèàíòû ðàñïî-
ëîæåíèÿ ñîáûòèé è âûäåëèòü ñëåäóþùèé êðèòåðèé ïåðåñå÷åíèÿ: åñëè íà÷àëî èëè êîíåö
îäíîãî èç ñîáûòèé ëåæèò ìåæäó íà÷àëîì è êîíöîì äðóãîãî, òî îíè ïåðåñåêàþòñÿ.  âè-
äå ïðîãðàììû ýòî ìîæíî çàïèñàòü òàê:

i s 1 s t a r t I n 2 = s t a r t 2 <= s t a r t 1 <= f i n i s h 2
i s 1 f i n i s I n 2 = s t a r t 2 <= f i n i s h 1 <= f i n i s h 2
i s 1 i n 2 = i s 1 s t a r t I n 2 or i s 1 f i n i s h I n 2
i s 2 s t a r t I n 1 = s t a r t 1 <= s t a r t 2 <= f i n i s h 1
i s 2 f i n i s I n 1 = s t a r t 1 <= f i n i s h 2 <= f i n i s h 1
i s 2 i n 1 = i s 2 s t a r t I n 1 or i s 2 f i n i s h I n 1
answer = i s 1 i n 2 or i s 2 i n 1

Åñëè íåìíîãî ïîäóìàòü, òî ìîæíî ïðèäóìàòü áîëåå êîðîòêèé êðèòåðèé äëÿ ïðî-
âåðêè òàêîãî ïåðåñå÷åíèÿ: íåîáõîäèìî, ÷òîáû íà÷àëî ïåðâîãî ñîáûòèÿ ïðîèñõîäèëî íå
ïîçæå êîíöà âòîðîãî è íà÷àëî âòîðîãî ñîáûòèÿ ïðîèñõîäèëî ðàíüøå êîíöà âòîðîãî.

answer = s t a r t 1 <= f i n i s h 2 and s t a r t 2 <= f i n i s h 1

Òàêîé ñïîñîá çíà÷èòåëüíî ïðîùå.


 Ïèòîíå, êàê è âî ìíîãèõ äðóãèõ ÿçûêàõ ïðîãðàììèðîâàíèÿ, åñëè ðåçóëüòàò âû-
÷èñëåíèÿ âûðàæåíèÿ îäíîçíà÷íî ïîíÿòåí ïî óæå âû÷èñëåííîé ëåâîé ÷àñòè, òî ïðàâàÿ
÷àñòü âûðàæåíèÿ äàæå íå ñ÷èòàåòñÿ. Íàïðèìåð, âûðàæåíèå True or 5 // 0 == 42, íå
áóäåò âûçûâàòü îøèáêè äåëåíèÿ íà íîëü, ò.ê. ïî ëåâîé ÷àñòè âûðàæåíèÿ (True) óæå
ïîíÿòíî, ÷òî ðåçóëüòàò åãî âû÷èñëåíèÿ òàêæå áóäåò True è àðèôìåòè÷åñêîå âûðàæåíèå
â ïðàâîé ÷àñòè äàæå íå áóäåò âû÷èñëÿòüñÿ.
2.3. ВЫВОД И ПРЕОБРАЗОВАНИЕ ЛОГИЧЕСКИХ ВЫРАЖЕНИЙ 19

2.3 Вывод и преобразование логических выражений

Åñëè íàïå÷àòü ðåçóëüòàò âû÷èñëåíèÿ ëîãè÷åñêîãî âûðàæåíèÿ ñ ïîìîùüþ ôóíêöèè


print, òî áóäåò íàïå÷àòàíî ñëîâî True èëè False.
Ïî àíàëîãèè ñ ôóíêöèÿìè int è str, ñóùåñòâóåò ôóíêöèÿ bool, êîòîðàÿ ìîæåò ïðè-
âîäèòü ÷èñëà èëè ñòðîêè ê ëîãè÷åñêîìó òèïó. Ïðè ïðåîáðàçîâàíèè ÷èñåë, âñå ÷èñëà,
îòëè÷íûå îò 0 ïðåîáðàçóþòñÿ â True, à ÷èñëî 0  â False.
Ôóíêöèÿ bool ïðèìåíåííàÿ ê ïóñòîé ñòðîêå äàåò ðåçóëüòàò False, à ïðè ïðèìåíåíèè
ê àáñîëþòíî ëþáîé äðóãîé ñòðîêå äàåò ðåçóëüòàò True. Íàïðèìåð, bool("False") äàñò
ðåçóëüòàò True, ïîñêîëüêó ñòðîêà False íå ïóñòàÿ.
Åñëè ïðèìåíèòü ôóíêöèþ int ê ëîãè÷åñêîìó âûðàæåíèþ, òî True ïðåîáðàçóåòñÿ â
1, à False  â 0.
Ïðèìåíåíèå ôóíêöèè str ê ëîãè÷åñêîìó âûðàæåíèþ äàåò ñòðîêè "True"è "False".
Íåêîòîðûå ïðèâåäåíèÿ òèïîâ ìîãóò âûïîëíÿòüñÿ àâòîìàòè÷åñêè:
Òèï îïåðàíäà 1 Òèï îïåðàíäà 2 Îïåðàöèÿ Òèï ðåçóëüòàòà
bool int Àðèôìåòè÷åñêàÿ int
bool bool Àðèôìåòè÷åñêàÿ int
bool int Ëîãè÷åñêàÿ bool
int int Ëîãè÷åñêàÿ bool
Íåêîòîðûå îïåðàöèè äîïóñòèìû è äëÿ ïåðåìåííûõ ëîãè÷åñêîãî òèïà è ñòðîê, íî èõ
ïðèìåíåíèå ÿâëÿåòñÿ ýêçîòèêîé è èõ íå ñëåäóåò èñïîëüçîâàòü áåç ÿâíîãî ïðèâåäåíèÿ
òèïîâ.

2.4 Условный оператор

Íàèáîëåå ÷àñòîå ïðèìåíåíèå ëîãè÷åñêèå âûðàæåíèÿ íàõîäÿò â óñëîâíûõ îïåðàòîðàõ.


Óñëîâíûé îïåðàòîð ïîçâîëÿåò âûïîëíÿòü äåéñòâèÿ â çàâèñèìîñòè îò òîãî, âûïîëíå-
íî óñëîâèå èëè íåò. Çàïèñûâàåòñÿ óñëîâíûé îïåðàòîð êàê if <ëîãè÷åñêîå âûðàæåíèå>:,
äàëåå ñëåäóåò áëîê êîìàíä, êîòîðûé áóäåò âûïîëíåí òîëüêî åñëè ëîãè÷åñêîå âûðàæåíèå
ïðèíÿëî çíà÷åíèå True. Áëîê êîìàíä, êîòîðûé áóäåò âûïîëíÿòüñÿ, âûäåëÿåòñÿ îòñòó-
ïàìè â 4 ïðîáåëà (â IDE ìîæíî íàæèìàòü êëàâèøó tab).
Ðàññìîòðèì, íàïðèìåð, çàäà÷ó î íàõîæäåíèè ìîäóëÿ ÷èñëà. Åñëè ÷èñëî îòðèöàòåëü-
íîå, òî íåîáõîäèìî çàìåíèòü åãî íà ìèíóñ ýòî ÷èñëî. Ðåøåíèå âûãëÿäèò òàê:
x = i n t ( input ( ) )
if x < 0:
x = −x
print ( x )

 ýòîé ïðîãðàììå ñ îòñòóïîì çàïèñàíà òîëüêî îäíà ñòðîêà, x = -x. Ïðè íåîáõîäèìî-
ñòè âûïîëíèòü íåñêîëüêî êîìàíä âñå îíè äîëæíû áûòü çàïèñàíû ñ òåì æå îòñòóïîì.
Êîìàíäà print çàïèñàíà áåç îòñòóïà, ïîýòîìó îíà áóäåò âûïîëíÿòüñÿ â ëþáîì ñëó÷àå,
íåçàâèñèìî îò òîãî, áûëî ëè óñëîâèå â if'å èñòèííûì èëè íåò.
 äîïîëíåíèå ê if ìîæíî èñïîëüçîâàòü îïåðàòîð else: (èíà÷å). Áëîê êîìàíä, êîòîðûé
ñëåäóåò ïîñëå íåãî, áóäåò âûïîëíÿòüñÿ åñëè óñëîâèå áûëî ëîæíûì. Íàïðèìåð, òó æå
çàäà÷ó î âûâîäå ìîäóëÿ ÷èñëà ìîæíî áûëî ðåøèòü, íå ìåíÿÿ çíà÷åíèÿ ïåðåìåííîé x:
x = i n t ( input ( ) )
20ЛЕКЦИЯ 2. ЛОГИЧЕСКИЙ ТИП ДАННЫХ, УСЛОВНЫЙ ОПЕРАТОР, ЦИКЛ WHILE, ВЕЩЕС

if x > 0:
print ( x )
else :
print (− x )

Âñå êîìàíäû, êîòîðûå âûïîëíÿþòñÿ â áëîêå else, äîëæíû áûòü òàêæå çàïèñàíû ñ
îòñòóïîì. Else äîëæåí ñëåäîâàòü ñðàçó çà áëîêîì êîìàíä if, áåç ïðîìåæóòî÷íûõ êîìàíä,
âûïîëíÿåìûõ áåçóñëîâíî. Else áåç ñîîòâåòñòâóþùåãî if'à íå èìååò ñìûñëà.
Åñëè ïîñëå if çàïèñàíî íå ëîãè÷åñêîå âûðàæåíèå, òî îíî áóäåò ïðèâåäåíî ê ëîãè÷å-
ñêîìó, êàê åñëè áû îò íåãî áûëà âûçâàíà ôóíêöèÿ bool. Îäíàêî, çëîóïîòðåáëÿòü ýòèì
íå ñëåäóåò, ò.ê. ýòî óõóäøàåò ÷èòàåìîñòü êîäà.
Äëÿ ïîäñ÷åòà ìîäóëÿ ÷èñëà â Ïèòîíå ñóùåñòâóåò ôóíêöèÿ abs, êîòîðàÿ èçáàâëÿåò
îò íåîáõîäèìîñòè êàæäûé ðàç ïèñàòü ïîäñ÷åò ìîäóëÿ âðó÷íóþ.

2.5 Вложенный условный оператор

Âíóòðè áëîêà êîìàíä ìîãóò íàõîäèòüñÿ äðóãèå óñëîâíûå îïåðàòîðû. Ïîñìîòðèì


ñðàçó íà ïðèìåðå. Ïî çàäàííîìó êîëè÷åñòâó ãëàç è íîã íóæíî íàó÷èòüñÿ îòëè÷àòü
êîøêó, ïàóêà, ìîðñêîãî ãðåáåøêà è æó÷êà. Ó ìîðñêîãî ãðåáåøêà áûâàåò áîëåå ñîòíè
ãëàç, à ó ïàóêîâ èõ âîñåìü. Òàêæå ó ïàóêîâ âîñåìü íîã, à ó ìîðñêîãî ãðåáåøêà èõ íåò
ñîâñåì. Ó êîøêè ÷åòûðå íîãè, à ó æó÷êà  øåñòü íîã, íî ãëàç ó îáîèõ ïî äâà. Ðåøåíèå:
e y e s = i n t ( input ( ) )
l e g s = i n t ( input ( ) )
i f e y e s >= 8 :
i f l e g s == 8 :
print ( " s p i d e r " )
else :
print ( " s c a l l o p " )
else :
i f l e g s == 6 :
print ( "bug" )
else :
print ( " c a t " )

Åñëè âëîæåííûõ óñëîâíûõ îïåðàòîðîâ íåñêîëüêî, òî, ê êàêîìó èç íèõ îòíîñèòñÿ else,
ìîæíî ïîíÿòü ïî îòñòóïó. Îòñòóï ó else äîëæåí áûòü òàêîé æå, êàê ó if, ê êîòîðîìó îí
îòíîñèòñÿ.

2.6 Конструкция ”иначе-если”

 íåêîòîðûõ ñèòóàöèÿõ íåîáõîäèìî îñóùåñòâèòü âûáîð áîëüøå ÷åì èç äâóõ âàðèàí-


òîâ, êîòîðûå ìîãóò áûòü îáðàáîòàíû ñ ïîìîùüþ if-else. Ðàññìîòðèì ïðèìåð: íåîáõîäèìî
âûâåñòè ñëîâîì íàçâàíèå ÷èñëà 1 èëè 2 èëè ñîîáùèòü, ÷òî ýòî äðóãîå ÷èñëî:
number = i n t ( input ( ) )
i f number == 1 :
print ( ' One ' )
2.7. ЦИКЛ WHILE 21

e l i f number == 2 :
print ( 'Two ' )
else :
print ( ' Other ' )
Çäåñü èñïîëüçóåòñÿ ñïåöèàëüíàÿ êîíñòðóêöèÿ elif, îáîçíà÷àþùàÿ ¾èíà÷å, åñëè¿, ïî-
ñëå êîòîðîé çàïèñûâàåòñÿ óñëîâèå. Òàêàÿ êîíñòðóêöèÿ ââåäåíà â ÿçûê Ïèòîí, ïîòîìó
÷òî çàïèñü if-else ïðèâåäåò ê óâåëè÷åíèþ îòñòóïà è óõóäøåíèþ ÷èòàåìîñòè.
Êîíñòðóêöèé elif ìîæåò áûòü íåñêîëüêî, óñëîâèÿ ïðîâåðÿþòñÿ ïîñëåäîâàòåëüíî. Êàê
òîëüêî óñëîâèå âûïîëíåíî  çàïóñêàåòñÿ ñîîòâåòñòâóþùèé ýòîìó óñëîâèþ áëîê êîìàíä
è äàëüíåéøàÿ ïðîâåðêà íå âûïîëíÿåòñÿ. Áëîê else ÿâëÿåòñÿ íåîáÿçàòåëüíûì, êàê è â
îáû÷íîì if.

2.7 Цикл while

While ïåðåâîäèòñÿ êàê ¾ïîêà¿ è ïîçâîëÿåò âûïîëíÿòü êîìàíäû, äî òåõ ïîð, ïî-
êà óñëîâèå âåðíî. Ïîñëå îêîí÷àíèÿ âûïîëíåíèÿ áëîêà êîìàíä, îòíîñÿùèõñÿ ê while,
óïðàâëåíèå âîçâðàùàåòñÿ íà ñòðîêó ñ óñëîâèåì è, åñëè îíî âûïîëíåíî, òî âûïîëíåíèå
áëîêà êîìàíä ïîâòîðÿåòñÿ, à åñëè íå âûïîëíåíî, òî ïðîäîëæàåòñÿ âûïîëíåíèå êîìàíä,
çàïèñàííûõ ïîñëå while.
Ñ ïîìîùüþ while î÷åíü ëåãêî îðãàíèçîâàòü âå÷íûé öèêë, ïîýòîìó íåîáõîäèìî ñëå-
äèòü çà òåì, ÷òîáû â áëîêå êîìàíä ïðîèñõîäèëè èçìåíåíèÿ, êîòîðûå ïðèâåäóò ê òîìó,
÷òî â êàêîé-òî ìîìåíò óñëîâèå ïåðåñòàíåò áûòü èñòèííûì.
Ðàññìîòðèì íåñêîëüêî ïðèìåðîâ.
Åñòü ÷èñëî 𝑁 . Íåîáõîäèìî âûâåñòè âñå ÷èñëà ïî âîçðàñòàíèþ îò 1 äî 𝑁 . Äëÿ ðåøå-
íèÿ ýòîé çàäà÷è íóæíî çàâåñòè ñ÷¼ò÷èê (ïåðåìåííóþ i), êîòîðûé áóäåò ðàâåí òåêóùåìó
÷èñëó. Âíà÷àëå ýòî åäèíèöà. Ïîêà çíà÷åíèå ñ÷åò÷èêà íå ïðåâûñèò 𝑁 , íåîáõîäèìî âû-
âîäèòü åãî òåêóùåå çíà÷åíèå è êàæäûé ðàç óâåëè÷èòü åãî íà åäèíèöó:
n = i n t ( input ( ) )
i = 1
while i <= n :
print ( i )
i = i + 1
Åùå îäíà ÷àñòî âñòðå÷àþùàÿñÿ çàäà÷à  ïîèñê ìèíèìóìà (èëè ìàêñèìóìà) â ïîñëå-
äîâàòåëüíîñòè ÷èñåë. Ïóñòü çàäàíà ïîñëåäîâàòåëüíîñòü ÷èñåë, îêàí÷èâàþùàÿñÿ íóë¼ì.
Íåîáõîäèìî íàéòè ìèíèìàëüíîå ÷èñëî â ýòîé ïîñëåäîâàòåëüíîñòè. Ýòà çàäà÷à ìîæåò
áûòü ðåøåíà ÷åëîâåêîì: êàæäûé ðàç êîãäà åìó íàçûâàþò î÷åðåäíîå ÷èñëî, îí ñðàâíè-
âàåò åãî ñ òåêóùèì çàïîìíåííûì ìèíèìóìîì è, ïðè íåîáõîäèìîñòè, çàïîìèíàåò íîâîå
ìèíèìàëüíîå ÷èñëî.  êà÷åñòâå ïåðâîãî çàïîìíåííîãî ÷èñëà íóæíî âçÿòü ïåðâûé ýëå-
ìåíò ïîñëåäîâàòåëüíîñòè, êîòîðûé äîëæåí áûòü ñ÷èòàí îòäåëüíî äî öèêëà.
now = i n t ( input ( ) )
nowMin = now
while now != 0 :
i f now < nowMin :
nowMin = now
now = i n t ( input ( ) )
22ЛЕКЦИЯ 2. ЛОГИЧЕСКИЙ ТИП ДАННЫХ, УСЛОВНЫЙ ОПЕРАТОР, ЦИКЛ WHILE, ВЕЩЕС

print ( nowMin )

Òàêæå ÷àñòî âîçíèêàåò çàäà÷à î ïîäñ÷åòå ñóììû ïîñëåäîâàòåëüíîñòè. Äëÿ ïîäñ÷åòà


ñóììû ÷èñåë íåîáõîäèìî çàâåñòè ïåðåìåííóþ, êîòîðàÿ áóäåò õðàíèòü íàêîïëåííóþ íà
äàííûé ìîìåíò ñóììó è, ïðè ÷òåíèè î÷åðåäíîãî ÷èñëà, ïðèáàâëÿòü åãî ê íàêîïëåííîé
ñóììå:
now = i n t ( input ( ) )
seqSum = 0
while now != 0 :
seqSum = seqSum + now
now = i n t ( input ( ) )
print ( seqSum )

2.8 Инструкции управления циклом

Äëÿ óïðàâëåíèÿ ïîâåäåíèåì öèêëà ìîæíî èñïîëüçîâàòü äâå èíñòðóêöèè, êîòîðûå


ïîçâîëÿþò äîñðî÷íî ïðåðûâàòü âûïîëíåíèå öèêëà èëè íà÷èíàòü âûïîëíåíèå èíñòðóê-
öèé öèêëà ñíà÷àëà.
Ïåðâàÿ êîìàíäà íàçûâàåòñÿ break. Ïîñëå å¼ âûïîëíåíèÿ ðàáîòà öèêëà ïðåêðàùàåòñÿ
(êàê áóäòî íå áûëî âûïîëíåíî óñëîâèå öèêëà). Îñìûñëåííîå èñïîëüçîâàíèå êîíñòðóê-
öèè break âîçìîæíî, òîëüêî åñëè âûïîëíåíî êàêîå-òî óñëîâèå, òî åñòü break äîëæåí
âûçûâàòüñÿ òîëüêî âíóòðè if (íàõîäÿùåãîñÿ âíóòðè öèêëà). Èñïîëüçîâàíèå break 
ïëîõîé òîí, ïî âîçìîæíîñòè, ñëåäóåò îáõîäèòüñÿ áåç íåãî. Ðàññìîòðèì ïðèìåð âå÷íîãî
öèêëà, âûõîä èç êîòîðîãî îñóùåñòâëÿåòñÿ ñ ïîìîùüþ break. Äëÿ ýòîãî ðåøèì çàäà÷ó
î âûâîäå âñåõ öåëûõ ÷èñåë îò 1 äî 100. Èñïîëüçîâàòü break òàêèì îáðàçîì íè â êîåì
ñëó÷àå íå íóæíî, ýòî ïðîñòî ïðèìåð:
i = 1
while True :
print ( i )
i = i + 1
i f i > 100:
break

Êîìàíäà continue íà÷èíàåò èñïîëíåíèå òåëà öèêëà çàíîâî, íà÷èíàÿ ñ ïðîâåðêè óñëî-
âèÿ. ż íóæíî èñïîëüçîâàòü, åñëè íà÷èíàÿ ñ êàêîãî-òî ìåñòà â òåëå öèêëà è ïðè âûïîë-
íåíèè êàêèõ-òî óñëîâèé äàëüíåéøèå äåéñòâèÿ íåæåëàòåëüíû.
Ïðèâåä¼ì ïðèìåð èñïîëüçîâàíèÿ continue (õîòÿ ïðè ðåøåíèè ýòîé çàäà÷è ìîæíî è
íóæíî îáõîäèòüñÿ áåç íåãî): äàíà ïîñëåäîâàòåëüíîñòü ÷èñåë, îêàí÷èâàþùàÿñÿ íóë¼ì.
Íåîáõîäèìî âûâåñòè âñå ïîëîæèòåëüíûå ÷èñëà èç ýòîé ïîñëåäîâàòåëüíîñòè. Ðåøåíèå:
now = −1
while now != 0 :
now = i n t ( input ( ) )
i f now <= 0 :
continue ;
print ( now )
2.9. ОСНОВЫ РАБОТЫ С ВЕЩЕСТВЕННЫМИ ЧИСЛАМИ 23

 ýòîì ðåøåíèè åñòü èíòåðåñíûé ìîìåíò: ïåðåä öèêëîì ïåðåìåííàÿ èíèöèàëèçè-


ðóåòñÿ çàâåäîìî ïîäõîäÿùèì çíà÷åíèåì. Êîìàíäà âûâîäà áóäåò âûïîëíÿòüñÿ òîëüêî â
òîì ñëó÷àå, åñëè íå âûïîëíèòñÿ óñëîâèå â if.
 ÿçûêå Ïèòîí ê öèêëó while ìîæíî íàïèñàòü áëîê else. Êîìàíäû â ýòîì áëîêå
áóäóò âûïîëíÿòüñÿ, åñëè öèêë çàâåðøèë ñâîþ ðàáîòó íîðìàëüíûì îáðàçîì (ò.å. óñëîâèå
â êàêîé-òî ìîìåíò ïåðåñòàëî áûòü èñòèííûì) è íå áóäóò âûïîëíÿòüñÿ òîëüêî â ñëó÷àå,
åñëè âûõîä èç öèêëà ïðîèçîøåë ñ ïîìîùüþ êîìàíäû break.

2.9 Основы работы с вещественными числами

Êðîìå öåëûõ ÷èñåë â ÿçûêå Ïèòîí òàêæå èìåþòñÿ âåùåñòâåííûå ÷èñëà.  îòëè÷èå
îò öåëûõ ÷èñåë îíè èìåþò îãðàíè÷åííóþ òî÷íîñòü è èñïîëüçîâàòü èõ íóæíî òîëüêî â
ñèòóàöèÿõ, êîãäà öåëûå ÷èñëà èñïîëüçîâàòü ñîâåðøåííî íåâîçìîæíî.
Äëÿ ïðåîáðàçîâàíèÿ ñòðîêè â âåùåñòâåííîå ÷èñëî èñïîëüçóåòñÿ ôóíêöèÿ oat. Âå-
ùåñòâåííûå ÷èñëà ìîæíî èñïîëüçîâàòü â àðèôìåòè÷åñêèõ âûðàæåíèÿõ âìåñòå ñ öåëûìè
÷èñëàìè, ïðè ýòîì ðåçóëüòàò áóäåò âåùåñòâåííûì ÷èñëîì. Âñå àðèôìåòè÷åñêèå îïåðà-
öèè ñ öåëûìè ÷èñëàìè òàêæå ïðèìåíèìû è ê âåùåñòâåííûì ÷èñëàì ñ òåì æå ñìûñëîì.
Êðîìå äåëåíèÿ â öåëûõ ÷èñëàõ, ñóùåñòâóåò òàêæå îáû÷íîå äåëåíèå, êîòîðîå îáî-
çíà÷àåòñÿ çíàêîì /. Ðåçóëüòàò òàêîãî äåëåíèÿ âñåãäà ÿâëÿåòñÿ âåùåñòâåííûì ÷èñëîì,
äàæå åñëè îáà îïåðàíäà áûëè öåëûìè.
Áîëåå ïîäðîáíî âåùåñòâåííûå ÷èñëà áóäóò èçó÷åíû â ñëåäóþùåé ëåêöèè.
24ЛЕКЦИЯ 2. ЛОГИЧЕСКИЙ ТИП ДАННЫХ, УСЛОВНЫЙ ОПЕРАТОР, ЦИКЛ WHILE, ВЕЩЕС
Лекция 3

Вещественные числа и строки

3.1 Вещественные числа в памяти компьютера

 îòëè÷èå îò öåëûõ ÷èñåë, âåùåñòâåííûå ÷èñëà â ÿçûêå Ïèòîí èìåþò îãðàíè÷åííóþ


äëèíó.
Ïîäóìàåì, êàê õðàíèòü äåñÿòè÷íóþ äðîáü â ïàìÿòè. Ïîñêîëüêó âåùåñòâåííûõ ÷è-
ñåë áåñêîíå÷íî ìíîãî (äàæå áîëüøå, ÷åì íàòóðàëüíûõ), òî íàì ïðèäåòñÿ îãðàíè÷èòü
òî÷íîñòü. Íàïðèìåð, ìû ìîæåì õðàíèòü òîëüêî íåñêîëüêî ïåðâûõ çíà÷àùèõ öèôð, íå
õðàíÿ íåçíà÷àùèå íóëè. Áóäåì îòäåëüíî õðàíèòü öåëîå ÷èñëî ñ ïåðâûìè çíà÷àùàìè
öèôðàìè è îòäåëüíî õðàíèòü ñòåïåíü ÷èñëà 10, íà êîòîðóþ íóæíî óìíîæèòü ýòî ÷èñ-
ëî.
Íàïðèìåð, ÷èñëî 5.972 × 1024 (ýòî ìàññà Çåìëè â êèëîãðàììàõ) ìîæíî ñîõðàíèòü
êàê 5972 (öèôðû ÷èñëà, ìàíòèññà) è 21 (íà êàêóþ ñòåïåíü 10 íóæíî óìíîæèòü ÷èñëî,
ýêñïîíåíòà). Ñ ïîìîùüþ òàêîãî ïðåäñòàâëåíèÿ ìîæíî õðàíèòü âåùåñòâåííûå ÷èñëà
ëþáîé ðàçìåðíîñòè.
Ïðèìåðíî òàê è õðàíÿòñÿ ÷èñëà â ïàìÿòè êîìïüþòåðà, îäíàêî âìåñòî äåñÿòè÷íîé
ñèñòåìû èñïîëüçóåòñÿ äâîè÷íûå. Íà áîëüøèíñòâå àïïàðàòíûõ ñèñòåì â ÿçûêå Ïèòîí
äëÿ õðàíåíèÿ oat èñïîëüçóåòñÿ 64 áèòà, èç êîòîðûõ 1 áèò óõîäèò íà çíàê, 52 áèòà 
íà ìàíòèññó è 11 áèò  íà ýêñïîíåíòó.
53 áèòà äàþò îêîëî 15-16 äåñÿòè÷íûõ çíàêîâ, êîòîðûå áóäóò õðàíèòñÿ òî÷íî. 11
áèò íà ýêñïîíåíòó òàêæå íàêëàäûâàåò îãðàíè÷åíèÿ íà ðàçìåðíîñòü õðàíèìûõ ÷èñåë
(ïðèìåðíî îò 10−1000 äî 101000 ).
Ëþáîå âåùåñòâåííîå ÷èñëî íà ÿçûêå Ïèòîí ïðåäñòàâèìî â âèäå äðîáè, ãäå â ÷èñ-
ëèòåëå õðàíèòñÿ öåëîå ÷èñëî, à â çíàìåíàòåëå íàõîäèòñÿ êàêàÿ ëèáî ñòåïåíü äâîéêè.
Íàïðèìåð, 0.125 ïðåäñòàâèìî êàê 1/8, à 0.1 êàê 3602879701896397/36028797018963968.
Íåñëîæíî çàìåòèòü, ÷òî ýòà äðîáü íå ðàâíî 0.1, ò.å. õðàíåíèå ÷èñëà 0.1 òî÷íî â òèïå
oat íåâîçìîæíî, êàê è ìíîãèõ äðóãèõ ¾êðàñèâûõ¿ äåñÿòè÷íûõ äðîáåé.

3.2 Запись, ввод и вывод вещественных чисел

Äëÿ çàïèñè êîíñòàíò èëè ïðè ââîäå-âûâîäå ìîæåò èñïîëüçîâàòüñÿ êàê ïðèâû÷íîå
ïðåäñòàâëåíèå â âèäå äåñÿòè÷íî äðîáè, íàïðèìåð 123.456, òàê è ¾èíæåíåðíàÿ¿ çàïèñü
÷èñëà, ãäå ìàíòèññà çàïèñûâàåòñÿ â âèäå âåùåñòâåííîãî ÷èñëà ñ îäíîé öèôðîé äî òî÷-
êè è íåêîòîðûì êîëè÷åñòâîì öèôð ïîñëå òî÷êè, çàòåì ñëåäóåò áóêâà e (èëè E) è

25
26 ЛЕКЦИЯ 3. ВЕЩЕСТВЕННЫЕ ЧИСЛА И СТРОКИ

ýêñïîíåíòà. ×èñëî 123.456 â èíæåíåðíîé çàïèñè áóäåò âûãëÿäåòü êàê 1.23456e2, ÷òî
îçíà÷àåò, ÷òî 1.23456 íóæíî óìíîæèòü íà 102 . È ìàíòèññà è ýêñïîíåíòà ìîãóò áûòü
îòðèöàòåëüíûìè è çàïèñûâàþòñÿ â äåñÿòè÷íîé ñèñòåìå.
Òàêàÿ çàïèñü ÷èñåë ìîæåò ïðèìåíÿòüñÿ ïðè ñîçäàíèè âåùåñòâåííûõ êîíñòàíò, à òàê-
æå ïðè ââîäå è âûâîäå. Èíæåíåðíàÿ çàïèñü óäîáíà äëÿ õðàíåíèÿ î÷åíü áîëüøèõ èëè
î÷åíü ìàëåíüêèõ ÷èñåë, ÷òîáû íå ñ÷èòàòü êîëè÷åñòâî íóëåé â íà÷àëå èëè êîíöå ÷èñëà.
Åñëè õî÷åòñÿ âûâåñòè ÷èñëî íå â èíæåíåðíîé çàïèñè, à ñ ôèêñèðîâàííûì êîëè÷å-
ñòâîì çíàêîâ ïîñëå òî÷êè, òî ñëåäóåò âîñïîëüçîâàòüñÿ ìåòîäîì format, êîòîðûé èìååò
ìàññó âîçìîæíîñòåé. Íàì íóæåí òîëüêî âûâîä ôèêñèðîâàííîãî êîëè÷åñòâà çíàêîâ, ïî-
ýòîìó âîñïîëüçóåìñÿ ãîòîâûì ðåöåïòîì äëÿ âûâîäà 25 çíàêîâ ïîñëå äåñÿòè÷íîé òî÷êè
ó ÷èñëà 0.1:
x = 0.1
print ( ' { 0 : . 2 5 f } ' . format ( x ) )
Âûâîä òàêîé ïðîãðàììû áóäåò âûãëÿäåòü êàê 0.1000000000000000055511151, ÷òî åùå
ðàç ïîäòâåðæäàåò ìûñëü î òîì, ÷òî ÷èñëî 0.1 íåâîçìîæíî ñîõðàíèòü òî÷íî.

3.3 Проблемы вещественных чисел

Ðàññìîòðèì ïðîñòîé ïðèìåð:


if 0 . 1 + 0 . 2 == 0 . 3 :
print ( ' A l l r i g h t ' )
else :
print ( 'WTF? ! ' )
Åñëè çàïóñòèòü ýòó ïðîãðàììó, òî ìîæíî ëåãêî óáåäèòüñÿ â òîì, ÷òî 0.1 + 0.2 íå
ðàâíî 0.3. Õîòÿ ìîæíî áûëî íàäåÿòñÿ, ÷òî íåñìîòðÿ íà íåòî÷íîå ïðåäñòàâëåíèå, îíî
îêàæåòñÿ îäèíàêîâî íåòî÷íûì äëÿ âñåõ ÷èñåë.
Ïîýòîìó ïðè èñïîëüçîâàíèè âåùåñòâåííûõ ÷èñåë íóæíî ñëåäîâàòü íåñêîëüêèì ïðî-
ñòûì ïðàâèëàì:

1. Åñëè ìîæíî îáîéòèñü áåç èñïîëüçîâàíèÿ âåùåñòâåííûõ ÷èñåë  íóæíî ýòî ñäå-
ëàòü. Âåùåñòâåííûå ÷èñëà ïðîáëåìíûå, íåòî÷íûå è ìåäëåííûå.

2. Äâå âåùåñòâåííûõ ÷èñëà ðàâíû ìåæäó ñîáîé, åñëè îíè îòëè÷àþòñÿ íå áîëåå ÷åì
íà 𝜖. ×èñëî 𝑋 ìåíüøå ÷èñëà 𝑌 , åñëè 𝑋 < 𝑌 − 𝜖.

 öåëîì áóäåò ïîëåçíî ïðåäñòàâëÿòü ñåáå âåùåñòâåííîå ÷èñëî 𝑋 êàê îòðåçîê [𝑋 −


𝜖; 𝑋 + 𝜖]. Êàê æå îïðåäåëèòü âåëè÷èíó 𝜖?
Äëÿ ýòîãî íóæíî ïîíÿòü, ÷òî ïîãðåøíîñòü íå ÿâëÿåòñÿ àáñîëþòíîé, ò.å. îäèíàêî-
âîé äëÿ âñåõ ÷èñåë, à ÿâëÿåòñÿ îòíîñèòåëüíîé. Óïðîùåííî, àïïàðàòíóþ ïîãðåøíîñòü
õðàíåíèÿ ÷èñëà 𝑋 ìîæíî îöåíèòü êàê 𝑋 × 2−54 .
×àùå âñåãî â çàäà÷àõ âõîäíûå äàííûå èìåþò îïðåäåëåííóþ òî÷íîñòü. Ðàññìîòðèì íà
ïðèìåðå: çàäàíû äâà ÷èñëà 𝑋 è 𝑌 ñ òî÷íîñòüþ 6 çíàêîâ ïîñëå òî÷êè (çíà÷èò 𝜖 = 5*10−7 )
è ïî ìîäóëþ íå ïðåâîñõîäÿùèå 109 . Îöåíèòü àáñîëþòíóþ ïîãðåøíîñòü âû÷èñëåíèÿ 𝑋 ×
𝑌 . Ðàññìîòðèì õóäøèé ñëó÷àé, êîãäà 𝑋 è 𝑌 ðàâíû 109 è îòêëîíèëèñü íà ìàêñèìàëüíî
âîçìîæíîå çíà÷åíèå 𝜖 â îäíó ñòîðîíó. Òîãäà ðåçóëüòàò âû÷èñëåíèÿ áóäåò âûãëÿäåòü
òàê:
3.4. ОКРУГЛЕНИЕ ВЕЩЕСТВЕННЫХ ЧИСЕЛ 27

(𝑋 + 𝜖) × (𝑌 + 𝜖) = 𝑋𝑌 + (𝑋 + 𝑌 ) × 𝜖 + 𝜖2
Âåëè÷èíà 𝜖2 ïðåíåáðåæèìî ìàëà, 𝑋𝑌  ýòî ïðàâèëüíûé îòâåò, à (𝑋 + 𝑌 ) × 𝜖 
èñêîìîå çíà÷åíèå àáñîëþòíîé ïîãðåøíîñòè. Ïîäñòàâèì ÷èñëà è ïîëó÷èì:

2 × 109 × 5 * 10−7 = 103


Àáñîëþòíàÿ ïîãðåøíîñòü âû÷èñëåíèÿ ñîñòàâèëà 1000 (îäíó òûñÿ÷ó). ×òî äîâîëüíî
íåîæèäàííî è ãðóñòíî.
Òàêèì îáðàçîì, ñòàíîâèòñÿ ïîíÿòíî, ÷òî íóæíî àêêóðàòíî âû÷èñëÿòü çíà÷åíèå ïî-
ãðåøíîñòè äëÿ ñðàâåíèÿ âåùåñòâåííûõ ÷èñåë.
Êîä äëÿ ñðàâíåíèÿ äâóõ ÷èñåë, çàäàííûõ ñ òî÷íîñòüþ 6 çíàêîâ ïîñëå òî÷êè, âûãëÿ-
äèò òàê:
x = f l o a t ( input ( ) )
y = f l o a t ( input ( ) )
e p s i l o n = 5 * 10 **− 7
i f abs ( x − y ) < 2 * e p s i l o n :
print ( ' Equal ' )
else :
print ( ' Not e a u a l ' )
 ñëó÷àå, åñëè íàä ÷èñëàìè ñîâåðøàëèñü êàêèå-òî äåéñòâèÿ, òî çíà÷åíèÿ 𝜖 íóæíî
âû÷èñëÿòü êàê â ïðèâåäåííîì âûøå ïðèìåðå.  ó÷åáíûõ çàäà÷àõ ýòî ìîæíî ñäåëàòü íå
âíóòðè ïðîãðàììû, à îäèí ðàç ðóêàìè äëÿ õóäøåãî ñëó÷àÿ è ïðèìåíÿòü âû÷èñëåííîå
çíà÷åíèå êàê êîíñòàíòó.

3.4 Округление вещественных чисел

Ïðè èñïîëüçîâàíèè öåëûõ è âåùåñòâåííûõ ÷èñåë â îäíîì âûðàæåíèè âû÷èñëåíèÿ


ïðîèçâîäÿòñÿ â âåùåñòâåííûõ ÷èñëàõ. Òåì íå ìåíåå, èíîãäà âîçíèêàåò íåîáõîäèìîñòü
ïðåîáðàçîâàòü âåùåñòâåííîå ÷èñëî â öåëîå. Äëÿ ýòîãî ìîæíî èñïîëüçîâàòü íåñêîëüêî
âèäîâ ôóíêöèé îêðóãëåíèÿ:

∙ int  îêðóãëÿåò â ñòîðîíó íóëÿ (îòáðàñûâåò äðîáíóþ ÷àñòü)

∙ round  îêðóãëÿåò äî áëèæàéøåãî öåëîãî, åñëè áëèæàéøèõ öåëûõ íåñêîëüêî


(äðîáíàÿ ÷àñòü ðàâíî 0.5), òî ê ÷åòíîìó

∙ oor  îêðóãëÿåò â ìåíüøóþ ñòîðîíó

∙ ceil  îêðóãëÿåò â áîëüøóþ ñòîðîíó

Ïðèìåðû äëÿ ðàçëè÷íûõ ÷èñåë:


Ôóíêöèÿ 2.5 3.5 -2.5
int 2 3 -2
round 2 4 -2
oor 2 3 -3
ceil 3 4 -3
28 ЛЕКЦИЯ 3. ВЕЩЕСТВЕННЫЕ ЧИСЛА И СТРОКИ

Ôóíêöèè oor è ceil íàõîäÿòñÿ â áèáëèîòåêå math. Åñòü äâà ñïîñîáà ïîëó÷èòü âîñ-
ïîëüçîâàòüñÿ èìè â ñâîåé ïðîãðàììå.
 ïåðâîì ñïîñîáå èìïîðòèðóåòñÿ áèáëèîòåêà math, òîãäà ïåðåä êàæäûì âûçîâîì
ôóíêöèè îòòóäà íóæíî ïèñàòü ñëîâî math., à çàòåì èìÿ ôóíêöèè:

import math

print ( math . f l o o r ( − 2 . 5 ) )
print ( math . c e i l ( − 2 . 5 ) )

Âî âòîðîì ñïîñîáå èç áèáëèîòåêè èìïîðòèðóþòñÿ íåêîòîðûå ôóíêöèè è äîñòóï ê


íèì ìîæíî ïîëó÷èòü áåç íàïèñàíèÿ math.:

from math import f l o o r , ceil

print ( f l o o r ( − 2 . 5 ) )
print ( c e i l ( − 2 . 5 ) )

Âòîðîé ñïîñîá ïðåäïî÷òèòåëüíî ïðèìåíÿòü â ñëó÷àå, åñëè êàêèå-òî ôóíêöèè èñïîëü-


çóþòñÿ ÷àñòî è íåò êîíôëèêòà èìåí (ôóíêöèé ñ îäèíàêîâûìè èìåíàìè â íåñêîëüêèõ
ïîäêëþ÷åííûõ áèáëèîòåêàõ).
 áèáëèîòåêå math òàêæå åñòü ôóíêöèÿ îêðóãëåíèÿ trunc, êîòîðàÿ ðàáîòàåò àíàëî-
ãè÷íî int.

3.5 Полезные функции библиотеки math

Êðîìå ôóíêöèé îêðóãëåíèÿ â áèáëèîòåêå math íàõîäèòñÿ ìàññà ïîëåçíûõ ôóíêöèé,


êîòîðûå ïðèâåäåíû íèæå:
sqrt(x) Êâàäðàòíûé êîðåíü.
pow(a, b) Âîçâåäåíèå â ñòåïåíü, âîçâðàùàåò 𝑎𝑏 .
exp(x) Ýêñïîíåíòà, âîçâðàùàåò 𝑒𝑥 .
log(x) Íàòóðàëüíûé ëîãàðèôì.
log(x, b) Ëîãàðèôì x ïî îñíîâàíèþ b.
log10(x) Äåñÿòè÷íûé ëîãàðèôì.
e Îñíîâàíèå íàòóðàëüíûõ ëîãàðèôìîâ 𝑒 ≈ 2.71828.
sin(x) Ñèíóñ óãëà, çàäàâàåìîãî â ðàäèàíàõ.
cos(x) Êîñèíóñ óãëà, çàäàâàåìîãî â ðàäèàíàõ.
tan(x) Òàíãåíñ óãëà, çàäàâàåìîãî â ðàäèàíàõ.
asin(x) Àðêñèíóñ, âîçâðàùàåò çíà÷åíèå â ðàäèàíàõ.
acos(x) Àðêêîñèíóñ, âîçâðàùàåò çíà÷åíèå â ðàäèàíàõ.
atan(x) Àðêòàíãåíñ, âîçâðàùàåò çíà÷åíèå â ðàäèàíàõ.
atan2(y, x) Ïîëÿðíûé óãîë (â ðàäèàíàõ) òî÷êè ñ êîîðäèíàòàìè (x, y).
hypot(a, b) Äëèíà ãèïîòåíóçû ïðÿìîóãîëüíîãî òðåóãîëüíèêà ñ êàòåòàìè a è b.
degrees(x) Ïðåîáðàçóåò óãîë, çàäàííûé â ðàäèàíàõ, â ãðàäóñû.
radians(x) Ïðåîáðàçóåò óãîë, çàäàííûé â ãðàäóñàõ, â ðàäèàíû.
pi Êîíñòàíòà 𝜋 .
3.6. СРЕЗЫ СТРОК 29

3.6 Срезы строк

Íàì èçâåñòíû ñïîñîáû ñ÷èòûâàòü, âûâîäèòü è çàäàâàòü êîíñòàíòíûå ñòðîêè, à òàêæå


ñêëåèâàòü ñòðîêè ìåæäó ñîáîé è óìíîæàòü ñòðîêó íà ÷èñëî.
×òîáû îïðåäåëèòü äëèíó ñòðîêè s ìîæíî âîñïîëüçîâàòüñÿ ôóíêöèåé len(s)  îíà
âîçâðàùàåò öåëîå ÷èñëî, ðàâíîå äëèíå ñòðîêè.
Ñðåç  ýòî ñïîñîá èçâëå÷ü èç ñòðîêè îòäåëüíûå ñèìâîëû èëè ïîäñòðîêè. Ïðè ïðè-
ìåíåíèè ñðåçà êîíñòðóèðóåòñÿ íîâàÿ ñòðîêà, ñòðîêà, ê êîòîðîé áûë ïðèìåí¼í ñðåç,
îñòàåòñÿ áåç èçìåíåíèé.
Ïðîñòåéøèé âèä ñðåçà  ýòî îáðàùåíèå ê êîíêðåòíîìó ñèìâîëó ñòðîêè ïî íîìåðó.
×òîáû ïîëó÷èòü i-ûé ñèìâîë ñòðîêè íóæíî íàïèñàòü s[i].  ðåçóëüòàòå ýòîãî áóäåò
ñêîíñòðóèðîâàíà ñòðîêà, ñîäåðæàùàÿ òîëüêî îäèí ñèìâîë  òîò, êîòîðûé ñòîÿë íà
ìåñòå i. Íóìåðàöèÿ ñèìâîë èäåò ñ íóëÿ, ïðè ïîïûòêå îáðàòèòüñÿ ê ñèìâîëó ñ íîìåðîì
áîëüøå ëèáî ðàâíîì äëèíå ñòðîêè âîçíèêàåò îøèáêà.
 ÿçûêå Ïèòîí ïðèñóòñòâóåò è íóìåðàöèÿ ñèìâîëîâ ñòðîêè îòðèöàòåëüíûìè ÷èñëà-
ìè. Ïîñëåäíèé ñèìâîë ñòðîêè èìååò íîìåð −1, ïðåäïîñëåíäèé  −2 è òàê äàëåå. Ïðè
ïîïûòêå îáðàòèòüñÿ ê ñèìâîëó ñ íîìåðîì, ìåíüøèì ÷åì -len(s) âîçíèêàåò îøèáêà.
Íóìåðàöèÿ ñèìâîëîâ â ñòðîêå String ïðåäñòàâëåíà â òàáëèöå:
S t r i n g
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
Ïîëó÷èòü äîñòóï, íàïðèìåð, ê ñèìâîëó n, ìîæíî äâóìÿ ñïîñîáàìè s[4] è s[-2].
Òàêæå ñóùåñòâóþò ñðåçû ñ äâóìÿ ïàðàìåòðàìè: â ðåçóëüòàòå ïðèìåíåíèÿ ñðåçà s[a:b]
áóäåò ñêîíñòðóèðîâàíà ïîäñòðîêà íà÷èíàÿ ñ ñèìâîëà íà ïîçèöèè 𝑎 è çàêàí÷èâàÿ ñèì-
âîëîì íà ïîçèöèè 𝑏 − 1 (ïðàâàÿ ãðàíèöà íå âêëþ÷àåòñÿ). Êàæäûé èç èíäåêñîâ ìîæåò
áûòü êàê ïîëîæèòåëüíûì, òàê è îòðèöàòåëüíûì.
Íàïðèìåð, ïðè s = "String s[1:5] áóäåò ðàâíî "trin ýòî ìîæíî áûëî áû çàïèñàòü è êàê
s[1:-1]. Åñëè â êà÷åñòâå âòîðîãî ÷èñëà â ñðåçå âçÿòü ÷èñëî, áîëüøå ëèáî ðàâíîå äëèíå
ñòðîêè, òî îøèáêè íå âîçíèêíåò è áóäóò âçÿòû âñå ñèìâîëû äî êîíöà ñòðîêè.
 ñëó÷àå, åñëè íóæíî âçÿòü âñå ñèìâîëû ñòðîêè íà÷èíàÿ ñ ïîçèöèè a è äî êîíöà, òî
âòîðîé ïàðàìåòð ìîæíî îïóñêàòü. Íàïðèìåð, s[2:] áóäåò ðàâíî "ring".
Åñëè îïóñòèòü ïåðâûé ïàðàìåòð â ñðåçå, òî áóäåò âçÿòà ïîäñòðîêà ñ íà÷àëà, íàïðè-
ìåð s[:2] áóäåò ðàâíî "St". Åñëè æå íàïèñàòü S[:] òî áóäåò âçÿòà âñÿ ñòðîêà îò íà÷àëà
äî êîíöà.
Åñëè ïåðâûé ïàðàìåòð íàõîäèòñÿ ïðàâåå âòîðîãî, òî áóäåò ñãåíåíðèðîâàíà ïóñòàÿ
ñòðîêà.
Òàêæå ñóùåñòâóåò ñðåç ñ òðåìÿ ïàðàìåòðàìè, ãäå òðåòèé ïàðàìåòð çàäàåò øàã, ñ
êîòîðûì íóæíî áðàòü ñèìâîëû. Íàïðèìåð, ìîæíî âçÿòü âñå ñèìâîëû ñ íà÷àëà äî êîíöà
ñ øàãîì 2, ýòî áóäåò âûãëÿäåòü êàê s[::2], â ðåçóëüòàòå ÷åãî ïîëó÷èòñÿ ñòðîêà "Srn".
Åñòåñòâåíî, ïåðâûé è âòîðîé ïàðàìåòðû ìîæíî íå îïóñêàòü. Åñëè òðåòèé ïàðàìåòð íå
óêàçàí, ò.å. â êâàäðàòíûõ ñêîáêàõ çàïèñàíî òîëüêî îäíî äâîåòî÷èå, òî øàã ñ÷èòàåòñÿ
ðàâíûì 1.
Øàã â ñðåçå ìîæåò áûòü è îòðèöàòåëüíûì, â òàêîì ñëó÷àå ïåðâûé ïàðàìåòð äîëæåí
íàõîäèòñÿ ïðàâååå âòîðîãî. Íàïðèìåð, s[5:1:-2] äàñò ñòðîêó "gi- 5-ûé è 3-èé ñèìâîëû,
à ñèìâîë ñ íîìåðîì 1 óæå íå âõîäèò. Ðàçâåðíóòóþ ñòðîêó ìîæíî ïîëó÷èòü ñðåçîì s[::-
1] âñå ñèìâîëû îò ¾íà÷àëà¿ äî ¾êîíöà¿ â îáðàòíîì ïîðÿäêå. Åñëè òðåòèé ïàðàìåòð
îòðèöàòåëüíûé, òî íà÷àëîì ñðåçà ñ÷èòàåòñÿ ïîñëåäíèé ñèìâîë, à êîíöîì  ïîçèöèÿ
30 ЛЕКЦИЯ 3. ВЕЩЕСТВЕННЫЕ ЧИСЛА И СТРОКИ

ïåðåä íóëåâûì ñèìâîëîì.

3.7 Методы find и rfind

Ìåòîäû  ýòî ôóíêöèè, ïðèìåíÿåìûå ê îáúåêòàì. Ìåòîä âûçûâàåòñÿ ñ ïîìîùüþ


çàïèñè ÈìÿÎáúåêòà.ÍàçâàíèåÌåòîäà(Ïàðàìåòðû). Ìåòîäû î÷åíü ïîõîæè íà ôóíêöèè,
íî ïîçâîëÿþò ëó÷øèì îáðàçîì îðãàíèçîâûâàòü õðàíåíèå è îáðàáîòêó äàííûõ. Íàïðè-
ìåð, âû íàïèñàëè ñâîþ ñòðóêòóðó äàííûõ è õîòåëè áû, ÷òîáû ôóíêöèÿ len âîçâðàùàëà
äëèíó âàøåé ñòðóêòóðû. ×òîáû ýòî çàðàáîòàëî, âàì ïðèäåòñÿ ëåçòü â èñõîäíûé êîä èí-
òåðïðåòàòîðà Ïèòîíà è âíîñèòü èçìåíåíèÿ â ôóíêöèþ len. Åñëè áû len áûëî ìåòîäîì,
òî âû ìîãëè áû îïèñàòü ýòîò ìåòîä ïðè ñîçäàíèè ñòðóêòóðû è íèêàêèõ èçìåíåíèé â êî-
äå èíòåðïðåòàòîðà èëè ñòàíäàðòíîé áèáëèîòåêè íå ïîòðåáîâàëîñü áû. Ïîýòîìó ìåòîäû
ïðåäïî÷òèòåëüíåå äëÿ ñëîæíûõ ñòðóêòóð, íàïðèìåð, òàêèõ êàê ñòðîêè.
Ó ñòðîê åñòü ìíîæåñòâî ðàçëè÷íûõ ìåòîäîâ.  ýòîì ðàçäåëå ìû ðàññìîòðèì ìåòîäû
ïîèñêà ïîäñòðîêè â ñòðîêå. Ìåòîä nd âîçâðàùàåò èíäåêñ ïåðâîãî âõîæäåíèÿ ïîäñòðîêè
â ñòðîêó, à åñëè îíà íå íàøëàñü  −1. Íàïðèìåð, 'String'.nd('ing') âåðíåò 3  èíäåêñ,
ñ êîòîðîãî íà÷èíàåòñÿ âõîæäåíèå ïîäñòðîêè ing.
Ìåòîä rnd èùåò ñàìîå ïðàâîå âõîæäåíèå.
Ñóùåñòâóþò ìîäèôèêàöèè ýòèõ ìåòîäîâ ñ äâóìÿ ïàðàìåòðàìè. s.nd(substring, from)
áóäåò îñóùåñòâëÿòü ïîèñê â ïîäñòðîêå s[from:]. Íàïðèìåð, 'String'.nd('ing', 1) âåðíåò
3 (íóìåðàöèÿ ñèìâîëîâ îñòàåòñÿ êàê â èñõîäíîé ñòðîêå). Ïî àíàëîãèè ñî ñðåçàìè ïàðà-
ìåòðû ìîãóò áûòü è îòðèöàòåëüíûìè.
Òàêæå åñòü ìîäèôèêàöèè ñ òðåìÿ ïàðàìåòðàìè: îíè èùóò ïîäñòðîêó â ñðåçó s[a:b].
×àñòî âîçíèêàåò çàäà÷à íàéòè è âûâåñòè âñå âõîæäåíèÿ ïîäñòðîêè â ñòðîêó, âêëþ÷àÿ
íàêëàäûâàþùèåñÿ. Íàïðèìåð, äëÿ ñòðîêè 'ABABA' è ïîäñòðîêè 'ABA' îòâåò äîëæåí
áûòü 0, 2. Åå ðåøåíèå âûãëÿäèò òàê:
s t r i n g = input ( )
s u b s t r i n g = input ( )
pos = s t r i n g . f i n d ( s u b s t r i n g )
while pos != − 1:
print ( pos )
pos = s t r i n g . f i n d ( s u b s t r i n g , pos + 1 )

3.8 Методы replace и count

Ìåòîä replace(old, new) ïîçâîëÿåò çàìåíèòü âñå âõîæäåíèÿ ïîäñòðîêè old íà ïîäñòðî-
êó new. Ïðè ýòîì êîíñòðóèðóåòñÿ íîâàÿ ñòðîêà, ãäå áûëè ïðîèçâåäåíû çàìåíû. Íóæíî
îáðàòèòü âíèìàíèå, ÷òî ìåòîä replace çàìåíÿåò âõîæäåíèÿ ïîäñòðîê áåç ó÷åòà ïðåäûäó-
ùèõ ñîâåðøåííûõ çàìåí. Åñëè ïðèìåíèòü ñëåäóþùóþ îïåðàöèþ 'AAAAAA'.replace('AA',
'A'), òî â ðåçóëüòàòå ïîëó÷èòñÿ ñòðîêà 'AAA', à íå 'A', êàê ìîæíî áûëî áû îæèäàòü.
Ôàêòè÷åñêè, ìîæíî ñ÷èòàòü, ÷òî ìåòîä replace íàõîäèò î÷åðåäíîå âõîæäåíèå ïîä-
ñòðîêè old, îñóùåñòâëÿåò çàìåíó è ïðîäîëæàåò ïîèñê ñ ïîçèöèè ïîñëå âñåõ çàìåííåííûõ
ñèìâîëîâ (áåç íàëîæåíèÿ è ïîèñêà â ñâåæåçàìåíåííîé ÷àñòè).
Ñóùåñòâóåò ìîäèôèêàöèÿ replace(old, new, count), êîòîðàÿ îñóùåñòâëÿåò íå áîëåå
count çàìåí ñàìûõ ëåâûõ âõîæäåíèé ïîäñòðîêè old.
3.8. МЕТОДЫ REPLACE И COUNT 31

Òàêæå äëÿ ñòðîê ñóùåñòâóåò ìåòîä count, êîòîðûé ïîçâîëÿåò ïîäñ÷èòàòü êîëè÷åñòâî
âõîæäåíèé ïîäñòðîêè. Ïî àíàëîãèè ñ ìåòîäîì nd îïðåäåëåíû ìåòîäû count ñ äâóìÿ è
òðåìÿ ïàðàìåòðàìè.
32 ЛЕКЦИЯ 3. ВЕЩЕСТВЕННЫЕ ЧИСЛА И СТРОКИ
Лекция 4

Функции и рекурсия

4.1 Создание простой функции

Ôóíêöèè  ÷àñòè ïðîãðàììû, êîòîðûå ìîæíî ïîâòîðíî âûçûâàòü ñ ðàçíûìè ïà-


ðàìåòðàìè, ÷òîáû íå ïèñàòü ìíîãî ðàç îäíî è òî æå. Ôóíêöèè â ïðîãðàììèðîâàíèè
íåìíîãî îòëè÷àþòñÿ îò ìàòåìàòè÷åñêèõ ôóíêöèé.  ìàòåìàòèêå ôóíêöèè ìîãóò òîëü-
êî ïîëó÷èòü ïàðàìåòðû è äàòü îòâåò, â ïðîãðàììèðîâàíèè æå ôóíêöèè óìåþò äåëàòü
÷òî-íèáóäü ïîëåçíîå, íàïðèìåð, íè÷åãî íå âîçâðàùàòü, íî ÷òî-òî ïå÷àòàòü.
Ôóíêöèè ÷ðåçâû÷àéíî ïîëåçíû, åñëè îäíè è òå æå äåéñòâèÿ íóæíî âûïîëíÿòü íåñêîëü-
êî ðàç. Íî íåêîòîðûå ëîãè÷åñêèå áëîêè ðàáîòû ñ ïðîãðàììîé èíîãäà òîæå óäîáíî
îôîðìëÿòü â âèäå ôóíêöèè. Ýòî ñâÿçàíî ñ òåì, ÷òî ÷åëîâåê ìîæåò îäíîâðåìåííî äåð-
æàòü â ãîëîâå îãðàíè÷åííîå êîëè÷åñòâî âåùåé. Êîãäà ïðîãðàììà ðàçðàñòàåòñÿ, îòñëå-
äèòü âñå óæå î÷åíü ñëîæíî.  ïðåäåëàõ îäíîé íåáîëüøîé ôóíêöèè çàïóòàòüñÿ ãîðàçäî
ñëîæíåå  èçâåñòíî, ÷òî îíà ïîëó÷àåò íà âõîä, ÷òî äîëæíà âûäàòü, à îá îñòàëüíîé
ïðîãðàììå â ýòî âðåìÿ ìîæíî íå äóìàòü.
 ïðîãðàììèðîâàíèè òàêæå ñ÷èòàåòñÿ õîðîøèì ñòèëåì ïèñàòü ôóíêöèè, óìåùàþ-
ùèåñÿ íà îäèí ýêðàí. Òîãäà ìîæíî îäíîâðåìåííî îêèíóòü âçãëÿäîì âñþ ôóíêöèþ è
íå íóæíî êðóòèòü òåêñò òóäà-ñþäà. Ïîýòîìó, åñëè ïîëó÷èëîñü ÷òî-òî î÷åíü äëèííîå,
òî íóæíî íàðåçàòü åãî íà êóñî÷êè òàê, ÷òîáû êàæäûé èç íèõ áûë ëîãè÷íûì (äåëàë
êàêîå-òî îïðåäåëåííîå äåéñòâèå, êîòîðîå ìîæíî íàçâàòü) è íå ïðåâûøàë ïðè ýòîì 10-
15 ñòðîê.
Ìû óæå èñïîëüçîâàëè ãîòîâûå ôóíêöèè, òàêèå êàê print, len è íåêîòîðûå äðóãèå.
Ýòè ôóíêöèè îïèñàíû â ñòàíäàðòíîé áèáëèîòåêå èëè äðóãèõ ïîäêëþ÷àåìûõ áèáëèîòå-
êàõ. Ñåãîäíÿ ìû íàó÷èìñÿ ñîçäàâàòü ñâîè ôóíêöèè.
Ðàññìîòðèì, êàê ñîçäàòü ñâîþ ôóíêöèþ, íà ïðèìåðå âû÷èñëåíèÿ ôàêòîðèàëà. Òåêñò
ïðîãðàììû áåç ôóíêöèè âûãëÿäèò òàê:
n = i n t ( input ( ) )
fact = 1
i = 2
while i <= n :
f a c t *= i
i += 1
print ( f a c t )

33
34 ЛЕКЦИЯ 4. ФУНКЦИИ И РЕКУРСИЯ

Âû÷èñëåíèå ôàêòîðèàëà ìîæíî âûíåñòè â ôóíêöèþ, òîãäà ýòà æå ïðîãðàììà áóäåò


âûãëÿäåòü òàê:
def f a c t o r i a l (num ) :
fact = 1
i = 2
while i <= num :
f a c t *= i
i += 1
return f a c t

n = i n t ( input ( ) )
print ( f a c t o r i a l ( n ) )

Îïèñàíèå ôóíêöèè äîëæíî èäòè â íà÷àëå ïðîãðàììû. Íà ñàìîì äåëå, îíî ìîæåò
áûòü â ëþáîì ìåñòå, äî ïåðâîãî âûçîâà ôóíêöèè factorial.
Îïðåäåëåíèå ôóíêöèè äîëæíî íà÷èíàòüñÿ ñî ñëîâà def (ñîêðàùåíèå îò dene, îïðå-
äåëèòü). Äàëüøå èäåò èìÿ ôóíêöèè, ïîñëå êîòîðîãî â ñêîáêàõ ÷åðåç çàïÿòóþ ïåðå÷èñ-
ëÿþòñÿ ïàðàìåòðû (ó íàøåé ôóíêöèè âñåãî îäèí ïàðàìåòð). Ïîñëå çàêðûòèÿ ñêîáêè
äîëæíî ñòîÿòü äâîåòî÷èå.
Êîìàíäû, âûïîëíÿåìûå â ôóíêöèè äîëæíû çàïèñûâàòüñÿ ñ îòñòóïîì, êàê â áëîêàõ
êîìàíä if èëè while.
 íàøåé ôóíêöèè num  ýòî ïàðàìåòð, íà åãî ìåñòî ïîäñòàâëÿåòñÿ òî çíà÷åíèå,
ñ êîòîðûì ôóíêöèÿ áûëà âûçâàíà. Äåéñòâèÿ âíóòðè ôóíêöèè òî÷íî òàêèå æå, êàê â
îáû÷íîé ïðîãðàììå, êðîìå äîïîëíèòåëüíîé êîìàíäû return. Êîìàíäà return âîçâðàùà-
åò çíà÷åíèå ôóíêöèè (îíî äîëæíî áûòü çàïèñàíî ÷åðåç ïðîáåë ïîñëå ñëîâà return) è
ïðåêðàùàåò å¼ ðàáîòó. Âîçâðàùåííîå çíà÷åíèå ïîäñòàâëÿåòñÿ íà òî ìåñòî, ãäå îñóùåñòâ-
ëÿëñÿ âûçîâ ôóíêöèè.
Êîìàíäà return ìîæåò âñòðå÷àòüñÿ â ëþáîì ìåñòå ôóíêöèè. Ïîñëå òîãî êàê îíà
âûïîëíèòñÿ, ðàáîòà ôóíêöèè áóäåò ïðåêðàùåíà. Çäåñü åñòü íåêîòîðàÿ àíàëîãèÿ ñ êî-
ìàíäîé break, ïðèìåíÿåìîé äëÿ âûõîäà èç öèêëà.

4.2 Вызовы функций из функции

Ôóíêöèþ ïîäñ÷åòà ôàêòîðèàëà ìîæíî èñïîëüçîâàòü äëÿ ïîäñ÷åòà áèíîìèàëüíûõ


êîýôôèöèåíòîâ (÷èñëà ñî÷åòàíèé). Ôîðìóëà äëÿ ïîäñ÷åòà ÷èñëà ñî÷åòàíèé âûãëÿäèò
òàê: 𝑘!×(𝑛−𝑘)!
𝑛!
.
Åñëè áû ìû íå ïîëüçîâàëèñü ôóíêöèÿìè, òî íàì ïîòðåáîâàëîñü áû òðè ðàçà çàïèñàòü
ïî÷òè îäíî è òî æå. Ñ ïîìîùüþ ôóíêöèé âû÷èñëåíèå âûãëÿäèò íàìíîãî ïðîùå:
print ( f a c t o r i a l ( n ) // ( f a c t o r i a l ( k ) * f a c t o r i a l ( n−k ) ) )

Ïîäñ÷åò áèíîìèàëüíûõ êîýôôèöèåíòîâ ìîæíî òàêæå îôîðìèòü â âèäå ôóíêöèè ñ


äâóìÿ ïàðàìåòðàìè:
def b i n o m i a l ( n , k ) :
return f a c t o r i a l ( n ) // ( f a c t o r i a l ( k ) * f a c t o r i a l ( n − k ) )
4.3. НЕСКОЛЬКО RETURN В ФУНКЦИИ 35

4.3 Несколько return в функции

Êàê áûëî ñêàçàíî âûøå, âûïîëíåíèå ôóíêöèè ïðåðûâàåòñÿ ïî êîìàíäå return. Äëÿ
ïðèìåðà ðàññìîòðèì ôóíêöèþ ïîèñêà ìàêñèìóìà èç äâóõ ÷èñåë, êîòîðûå ïåðåäàþòñÿ
åé â êà÷åñòâå ïàðàìåòðîâ:
def max2 ( a , b ) :
if a > b:
return a
else :
return b

ż ìîæíî áûëî áû çàïèñàòü è ïî-äðóãîìó:


def max2 ( a , b ) :
if a > b:
return a
return b

Åñëè óñëîâèå â if'å áûëî èñòèííûì, òî âûïîëíèòñÿ êîìàíäà return a è âûïîëíåíèå


ôóíêöèè áóäåò ïðåêðàùåíî  äî êîìàíäû return b âûïîëíåíèå ïðîñòî íå äîéäåò.
Ñ ïîìîùüþ ôóíêöèè max2 ìîæíî ðåàëèçîâàòü ôóíêöèþ max3, âîçâðàùàþùóþ ìàê-
ñèìóì èç òðåõ ÷èñåë:
def max3 ( a , b , c ) :
return max2 ( max2 ( a , b ) , c )

Ýòà ôóíêöèÿ äâàæäû âûçûâàåò max2: ñíà÷àëà äëÿ âûáîðà ìàêñèìóìà ñðåäè ÷èñåë a
è b, à çàòåì äëÿ âûáîðà ìàêñèìóìà ìåæäó íàéäåííûì çíà÷åíèåì è îñòàâøèìñÿ ÷èñëîì
c.
Çäåñü íóæíî îáðàòèòü âíèìàíèå, ÷òî â êà÷åñòâå àðãóìåíòà ôóíêöèè ìîæåò ïåðå-
äàâàòüñÿ íå òîëüêî ïåðåìåííàÿ èëè êîíñòàíòíîå çíà÷åíèå, íî è ðåçóëüòàò âû÷èñëå-
íèÿ ëþáîãî àðèôìåòè÷åñêîãî âûðàæåíèÿ. Íàïðèìåð, ðåçóëüòàò, âîçâðàùåííîé äðóãîé
ôóíêöèåé.
Íàøè ôóíêöèè max2 è max3 áóäóò ðàáîòàòü íå òîëüêî äëÿ ÷èñåë, íî è äëÿ ëþáûõ
ñðàâíèìûõ îáúåêòîâ, íàïðèìåð, äëÿ ñòðîê.

4.4 Локальные и глобальные переменные

Âñå ïåðåìåííûå, êîòîðûìè ìû ïîëüçîâàëèñü äî ñåãîäíÿøíåãî äíÿ, áûëè ãëîáàëüíû-


ìè. Ãëîáàëüíûå ïåðåìåííûå âèäíû âî âñåõ ôóíêöèÿõ ïðîãðàììû.
Íàïðèìåð, òàêîé êîä:
def f ( ) :
print a
a = 1
f ()
íàïå÷àòàåò 1 è âûïîëíèòñÿ áåç îøèáîê. Ïåðåìåííàÿ a  ãëîáàëüíàÿ, ïîýòîìó ìû
ìîæåì ñìîòðåòü íà å¼ çíà÷åíèå èç ëþáîé ôóíêöèè. Íà ìîìåíò âûçîâà ôóíêöèè f ïåðå-
ìåííàÿ a óæå ñîçäàíà, õîòÿ îïèñàíèå ôóíêöèè è èäåò ðàíüøå ïðèñâàèâàíèÿ.
36 ЛЕКЦИЯ 4. ФУНКЦИИ И РЕКУРСИЯ

Åñëè æå èíèöèàëèçèðîâàòü ïåðåìåííóþ âíóòðè ôóíêöèè, òî èñïîëüçîâàòü å¼ âíå


ôóíêöèè íåâîçìîæíî. Íàïðèìåð, òàêîé êîä:
def f ( ) :
a = 1
f ()
print ( a )

çàâåðøèòñÿ ñ îøèáêîé "builtins.NameError: name 'a' is not dened"(ïåðåìåííàÿ a


íå îïðåäåëåíà). Ïåðåìåííûå, çíà÷åíèÿ êîòîðûõ èçìåíÿþòñÿ âíóòðè ôóíêöèè ïî óìîë-
÷àíèþ ñ÷èòàþòñÿ ëîêàëüíûìè, ò.å. äîñòóïíûìè òîëüêî âíóòðè ôóíêöèè. Êàê òîëüêî
ôóíêöèÿ çàêàí÷èâàåò ñâîþ ðàáîòó, òî ïåðåìåííàÿ óíè÷òîæàåòñÿ.
Òàêèì îáðàçîì, åñëè â ôóíêöèè ïðîèñõîäèëî ïðèñâàèâàíèå êàêîé-òî ïåðåìåííîé, òî
ýòà ïåðåìåííàÿ ñ÷èòàåòñÿ ëîêàëüíîé. Åñëè ïðèñâàèâàíèé íå ïðîèñõîäèëî, òî ïåðåìåí-
íàÿ ñ÷èòàåòñÿ ãëîáàëüíîé.
Ëîêàëüíûå ïåðåìåííûå ìîæíî íàçûâàòü òàêèìè æå èìåíàìè, êàê è ãëîáàëüíûå.
Íàïðèìåð, âûâîä òàêîãî êîäà:
def f ( ) :
a = 1
print ( a , end= ' ')
a = 0
f ()
print ( a )

Áóäåò "1 0". Ñíà÷àëà ïðîèçîéäåò âûçîâ ôóíêöèè f, â êîòîðîé áóäåò ñîçäàíà ëî-
êàëüíàÿ ïåðåìåííàÿ a ñî çíà÷åíèåì 1 (ïîëó÷èòü äîñòóï ê ãëîáàëüíîé ïåðåìåííîé a
èç ôóíêöèè òåïåðü íåëüçÿ), çàòåì ôóíêöèÿ çàêîí÷èò ñâîþ ðàáîòó è áóäåò âûâåäåíà
ãëîáàëüíàÿ ïåðåìåííàÿ a, ñî çíà÷åíèåì êîòîðîé íè÷åãî íå ñëó÷èëîñü.
Ïåðåìåííàÿ ñ÷èòàåòñÿ ëîêàëüíîé äàæå â ñëó÷àå, åñëè å¼ ïðèñâàèâàíèå ïðîèñõîäèëî
âíóòðè óñëîâíîãî îïåðàòîðà (äàæå åñëè îí íèêîãäà íå âûïîëíèòñÿ):
def f ( ) :
print ( a )
i f False :
a = 0
a = 1
f ()
Ýòà ïðîãðàììà çàâåðøèòñÿ ñ îøèáêîé builtins.UnboundLocalError: local variable 'a'
referenced before assignment (îáðàùåíèå ê ïåðåìåííîé äî èíèöèàëèçàöèè). Ëþáîå ïðè-
ñâàèâàíèå çíà÷åíèÿ ïåðåìåííîé âíóòðè òåëà ôóíêöèè äåëàåò ïåðåìåííóþ ëîêàëüíîé.
Ñ ïîìîùüþ ñïåöèàëüíîé êîìàíäû global ìîæíî ñäåëàòü òàê, ÷òî ôóíêöèÿ ñìîæåò
èçìåíèòü çíà÷åíèå ãëîáàëüíîé ïåðåìåííîé. Äëÿ ýòîãî íóæíî çàïèñàòü â íà÷àëå ôóíê-
öèè ñëîâî global, à çàòåì ÷åðåç çàïÿòóþ ïåðå÷èñëèòü èìåíà ãëîáàëüíûõ ïåðåìåííûõ,
êîòîðûå ôóíêöèÿ ñìîæåò ìåíÿòü. Íàïðèìåð, òàêîé êîä:
def f ( ) :
global a
a = 1
print ( a , end= ' ')
4.5. ВОЗВРАТ НЕСКОЛЬКИХ ЗНАЧЕНИЙ ФУНКЦИЕЙ 37

a = 0
f ()
print ( a )

âûâåäåò "1 1 ò.ê. çíà÷åíèå ãëîáàëüíîé ïåðåìåííîé áóäåò èçìåíåíî âíóòðè ôóíêöèè.
Âñå ïàðàìåòðû ôóíêöèè ÿâëÿþòñÿ ëîêàëüíûìè ïåðåìåííûìè ñî çíà÷åíèÿìè, êî-
òîðûå áûëè ïåðåäàíû â ôóíêöèþ. Ïàðàìåòðû òàêæå ìîæíî èçìåíÿòü è ýòî íèêàê íå
ïîâëèÿåò íà çíà÷åíèÿ ïåðåìåííûõ â òîì ìåñòå, îòêóäà áûëà âûçâàíà ôóíêöèÿ (åñëè
òèï îáúåêòîâ-ïàðàìåòðîâ áûë íåèçìåíÿåìûì).-
Èñïîëüçîâàíèå ãëîáàëüíûõ ïåðåìåííûõ êàê íà ÷òåíèå, òàê è íà çàïèñü âíóòðè ôóíê-
öèé  î÷åíü ïëîõîé òîí. Ýòî ñâÿçàíî ñ òåì, ÷òî äðóãèå ëþäè ìîãóò çàõîòåòü èñïîëü-
çîâàòü íåêîòîðûå îòäåëüíûå ôóíêöèè èç âàøåãî êîäà, êîòîðûå íå áóäóò ðàáîòàòü âíå
âàøåé ïðîãðàììû â ñëó÷àå èñïîëüçîâàíèÿ ãëîáàëüíûõ ïåðåìåííûõ.
Ïîýòîìó èñïîëüçîâàíèå ãëîáàëüíûõ ïåðåìåííûõ âíóòðè ôóíêöèé â íàøåì êóðñå
строго запрещено. Âñå íóæíîå äëÿ ðàáîòû ôóíêöèè äîëæíî ïåðåäàâàòüñÿ â êà÷åñòâå
ïàðàìåòðîâ.

4.5 Возврат нескольких значений функцией

Ðàññìîòðèì ñëó÷àé, êîãäà ôóíêöèÿ äîëæíà âåðíóòü íåñêîëüêî çíà÷åíèé íà ïðèìåðå


ôóíêöèè, óïîðÿäî÷èâàþùåé äâà ÷èñëà. ×òîáû âåðíóòü íåñêîëüêî çíà÷åíèé, äîñòàòî÷íî
çàïèñàòü èõ â return ÷åðåç çàïÿòóþ. Àíàëîãè÷íî, ÷åðåç çàïÿòóþ äîëæíû áûòü ïåðå÷èñ-
ëåíû ïåðåìåííûå, â êîòîðûå áóäóò ïîïàäàòü âû÷èñëåííûå çíà÷åíèÿ.
def s o r t 2 ( a , b ) :
if a < b:
return a , b
else :
return b , a
a = i n t ( input ( ) )
b = i n t ( input ( ) )
minimum , maximum = s o r t 2 ( a , b )
print ( minimum , maximum)

Íà ñàìîì äåëå, ïðè ïåðå÷èñëåíèè çíà÷åíèé ÷åðåç çàïÿòóþ, ôîðìèðóþòñÿ îáúåêòû


òèïà ¾êîðòåæ¿, èõ ïîäðîáíîå èçó÷åíèå áóäåò íà ñëåäóþùåé ëåêöèè. Èìåþùèõñÿ çíàíèé
äîñòàòî÷íî äëÿ èñïîëüçîâàíèÿ ôóíêöèé, âîçâðàùàþùèõ íåñêîëüêî çíà÷åíèé.

4.6 Возврат логических значений

Èíîãäà óäîáíî îôîðìëÿòü äàæå ïðîñòûå âåùè â âèäå ôóíêöèé, ÷òîáû ïîâûñèòü
÷èòàåìîñòü ïðîãðàììû. Íàïðèìåð, åñëè íóæíî ïðîâåðèòü ÷èñëî íà ÷åòíîñòü, òî ãîðàçäî
ïîíÿòíåå áóäåò êàæäûé ðàç âûçûâàòü ôóíêöèþ isEven(n), à íå ïèñàòü êàæäûé ðàç n
Òàêàÿ ôóíêöèÿ ìîæåò âûãëÿäåòü òàê:
def i s E v e n ( n ) :
return n % 2 == 0
38 ЛЕКЦИЯ 4. ФУНКЦИИ И РЕКУРСИЯ

Ðåçóëüòàòîì ðàáîòû ýòîé ôóíêöèè áóäåò èñòèíà èëè ëîæü. Òåïåðü ôóíêöèþ î÷åíü
óäîáíî ïðèìåíÿòü â if'àõ:
i f isEven (n ) :
print ( "EVEN" )
else :
print ( "ODD" )
Åñëè åñòü ñëîæíîå ëîãè÷åñêîå âûðàæåíèå, òî ëó÷øå îôîðìèòü åãî â âèäå ôóíêöèè
ñ ãîâîðÿùèì íàçâàíèåì  òàê ïðîãðàììó áóäåò ëåã÷å ÷èòàòü, à âåðîÿòíîñòü îøèáîê â
íåé ðåçêî ñíèçèòñÿ.

4.7 Механизм запуска функций

Ðàáîòàÿ ñ ôóíêöèÿìè, íóæíî ðàçëè÷àòü äâå ñóùíîñòè: ïîñëåäîâàòåëüíîñòü êîìàíä,


êîòîðûå âûïîëíÿþòñÿ â ôóíêöèè, è ëîêàëüíûå ïåðåìåííûå êîíêðåòíîãî ýêçåìïëÿðà
ôóíêöèè. Êðîìå ýòîãî êàæäûé ýêçåìïëÿð ôóíêöèè ïîìíèò, êóäà îí äîëæåí âåðíóòüñÿ
ïîñëå çàâåðøåíèÿ ðàáîòû.
Ýòèì ñâîéñòâîì ïîìíèòü, ñ êàêîãî ìåñòà íóæíî ïðîäîëæèòü ðàáîòó ôóíêöèè ìû
ïîëüçóåìñÿ ïðè ëþáîì çàïóñêå ôóíêöèè  âûïîëíåíèå íà âðåìÿ óõîäèò â ôóíêöèþ,
à ïîñëå âûïîëíåíèÿ âñåõ êîìàíä óïðàâëåíèå âîçâðàùàåòñÿ ðîâíî íà òî ìåñòî, ãäå áûë
ïðîèçâåäåí âûçîâ ôóíêöèè.

4.8 Рекурсия

Ìû óæå ïðîáîâàëè çàïóñêàòü ôóíêöèþ èç äðóãîé ôóíêöèè è âñå ðàáîòàëî. Íè÷òî


íå ìåøàåò çàïóñòèòü èç ôóíêöèè ñàìó ñåáÿ  òîãäà ïðîñòî ñîçäàñòñÿ íîâûé ýêçåì-
ïëÿð ôóíêöèè, êîòîðûå áóäåò âûïîëíÿòü òå æå êîìàíäû. Òàêîé ïðîöåññ íàçûâàåòñÿ
ðåêóðñèåé.
Ïðåäñòàâèì ñåáå, ÷òî ó íàñ åñòü ìèëëèàðä ÷åëîâåê (ýòî áóäóùèå ýêçåìïëÿðû ôóíê-
öèè), ñèäÿùèõ â ðÿä, è ó êàæäîãî èç íèõ åñòü ëèñòî÷åê äëÿ çàïèñè (ýòî åãî ëîêàëüíàÿ
ïàìÿòü). Íàì íóæíî ïðîèçíîñèòü ÷èñëà è íàïèñàòü èíñòðóêöèþ äëÿ ëþäåé òàê, ÷òîáû
îíè â èòîãå ñêàçàëè âñå ÷èñëà èç ïîñëåäîâàòåëüíîñòè â îáðàòíîì ïîðÿäêå. Ïóñòü êàæ-
äûé èç íèõ áóäåò çàïèñûâàòü íà ñâîåì ëèñòî÷êå òîëüêî îäíî ÷èñëî. Òîãäà èíñòðóêöèÿ
äëÿ ÷åëîâåêà áóäåò âûãëÿäåòü òàê:

1. Çàïèøè íàçâàííîå ÷èñëî

2. Åñëè ÷èñëî íå ïîñëåäíåå  ïîòåðåáè ñëåäóþùåãî çà òîáîé ÷åëîâåêà, ïðèøëà åãî


î÷åðåäü ðàáîòàòü

3. Êîãäà ñëåäóþùèé çà òîáîé ÷åëîâåê ñêàçàë, ÷òî îí çàêîí÷èë  íàçîâè çàïèñàííîå


÷èñëî

4. Ñêàæè òîìó, êòî òåáÿ òåðåáèë (ïðåäûäóùèé ÷åëîâåê), ÷òî òû çàêîí÷èë

Ôîðìàëèçóåì çàäà÷ó. Ïóñòü çàäàåòñÿ ïîñëåäîâàòåëüíîñòü íàòóðàëüíûõ ÷èñåë, çà-


êàí÷èâàþùàÿñÿ íóëåì. Íåîáõîäèìî ðàçâåðíóòü åå ñ ïîìîùüþ ðåêóðñèè.
4.8. РЕКУРСИЯ 39

def r e c ( ) :
n = i n t ( input ( ) )
i f n != 0 :
rec ()
print ( n )
rec ()

Ýòà ôóíêöèÿ îñóùåñòâëÿåò äåéñòâèå (âûâîä ÷èñëà) íà ðåêóðñèâíîì ñïóñêå, ò.å. ïîñëå
ðåêóðñèâíîãî âûçîâà.
Ðàññìîòðèì çàäà÷ó, ãäå äåéñòâèÿ âûïîëíÿþòñÿ êàê íà ðåêóðñèâíîì ïîäú¼ìå, òàê
è íà ðåêóðñèâíîì ñïóñêå. Ïóñòü äàíà ïîñëåäîâàòåëüíîñòü, êîòîðàÿ îêàí÷èâàåòñÿ íó-
ë¼ì. Íåîáõîäèìî âûâåñòè âñå ÷¼òíûå ÷ëåíû ïîñëåäîâàòåëüíîñòè â ïðÿìîì ïîðÿäêå, à
çàòåì âñå íå÷¼òíûå ÷ëåíû ïîñëåäîâàòåëüíîñòè â îáðàòíîì ïîðÿäêå. ż ðåøåíèå áóäåò
âûãëÿäåòü òàê:
def r e c ( ) :
n = i n t ( input ( ) )
i f n != 0 :
i f n % 2 == 0 :
print ( n )
rec ()
i f n % 2 != 0 :
print ( n )
rec ()

Êàæäûé ýêçåìïëÿð ôóíêöèè ñ÷èòûâàåò â ñâîþ ëîêàëüíóþ ïåðåìåííóþ n ÷èñëî, åñëè


îíî ÷¼òíîå, òî ñðàçó âûâîäèò åãî è çàïóñêàåò ñëåäóþùèé ýêçåìïëÿð. Ïîñëå òîãî, êàê
âñå ïîñëåäóþùèå ýêçåìïëÿðû ôóíêöèè îêîí÷èëè ðàáîòó (è âûâåëè íå÷¼òíûå ÷èñëà â
îáðàòíîì ïîðÿäêå), ôóíêöèÿ âûâîäèò ÷èñëî, åñëè îíî áûëî íå÷åòíûì.
Ðàññìîòðèì åùå îäèí ïðèìåð: ïîäñ÷èòàòü ôàêòîðèàë ÷èñëà, íå ïîëüçóÿñü öèêëàìè:
def f a c t o r i a l ( n ) :
i f n == 0 :
return 1
return n * f a c t o r i a l ( n − 1 )
n = i n t ( input ( ) )
print ( f a c t o r i a l ( n ) )

Òåì, êòî çíàêîì ñ ìåòîäîì ìàòåìàòè÷åñêîé èíäóêöèè, áóäåò äîâîëüíî ïðîñòî îñî-
çíàòü ðåêóðñèþ. Êàê è â ìàòåìàòè÷åñêîé èíäóêöèè, â ðåêóðñèè äîëæíà áûòü áàçà (ìî-
ìåíò, êîãäà ôóíêöèÿ íå âûçûâàåò äðóãóþ ðåêóðñèâíóþ ôóíêöèþ) è ïåðåõîä (ïðàâèëî,
ïî êîòîðîìó ñ÷èòàåòñÿ ðåçóëüòàò ïî èçâåñòíîìó ðåçóëüòàòó äëÿ ìåíüøåãî ïàðàìåòðà).
Íàøà ôóíêöèÿ ïîäñ÷åòà ôàêòîðèàëà äåëàåò òîëüêî ñâîþ ðàáîòó, íî ïîëüçóåòñÿ ðå-
çóëüòàòàìè ÷óæîãî òðóäà. Íàïðèìåð, åñëè ôóíêöèÿ ïîëó÷èëà íà âõîä ïàðàìåòð 4, òî
äîëæíà âåðíóòü 4 óìíîæåííîå íà 3! (êîòîðûé áóäåò ïîñ÷èòàí äðóãèìè ôóíêöèÿìè). Â
ñëó÷àå ôàêòîðèàëà àíàëîãîì ¾áàçû èíäóêöèè¿ ìîæåò âûñòóïàòü 0!  ïî îïðåäåëåíèþ
îí ðàâåí åäèíèöå.
Ýòè ïðèìåðû èëëþñòðèðóþò îáùóþ ñõåìó íàïèñàíèÿ ðåêóðñèâíûõ ôóíêöèé: ñíà-
÷àëà ïðîâåðÿåòñÿ óñëîâèå, êîãäà ôóíêöèÿ äîëæíà çàêîí÷èòüñÿ, à äàëüøå äåëàåòñÿ âñå
40 ЛЕКЦИЯ 4. ФУНКЦИИ И РЕКУРСИЯ

îñòàëüíîå. Ïðè ýòîì ïàðàìåòð äîëæåí ñõîäèòüñÿ ê çíà÷åíèþ áàçû. Îáû÷íî ýòî îçíà÷à-
åò, ÷òî ïðè êàæäîì ñëåäóþùåì âûçîâå ðåêóðñèè ïàðàìåòð äîëæåí óìåíüøàòüñÿ.
Лекция 5

Кортежи, цикл for, списки

5.1 Кортежи

Ïî àíàëîãèè ñî ñòðîêàìè, êîòîðûå ìîãóò õðàíèòü â ñåáå îòäåëüíûå ñèìâîëû, â ÿçû-


êå Ïèòîí ñóùåñòâóþò òèï êîðòåæ, êîòîðûé ïîçâîëÿåò õðàíèòü â ñåáå ïðîèçâîëüíûå
ýëåìåíòû.
Êîðòåæ ìîæåò ñîñòîÿòü èç ýëåìåíòîâ ïðîèçâîëüíûõ òèïîâ è ÿâëÿåòñÿ íåèçìåíÿå-
ìûì òèïîì, ò.å. íåëüçÿ ìåíÿòü îòäåëüíûå ýëåìåíòû êîðòåæà, êàê è ñèìâîëû ñòðîêè.
Êîíñòàíòíûå êîðòåæè ìîæíî ñîçäàâàòü â ïðîãðàììå, çàïèñûâàÿ ýëåìåíòû ÷åðåç çà-
ïÿòóþ è îêðóæàÿ ñêîáêàìè. Íàïðèìåð, testTuple = (1, 2, 3).  ñëó÷àå, åñëè êîðòåæ
ÿâëÿåòñÿ åäèíñòâåííûì âûðàæåíèåì ñëåâà èëè ñïðàâà îò çíàêà ïðèñâàèâàíèÿ, òî ñêîá-
êè ìîãóò áûòü îïóùåíû. Âî âñåõ îñòàëüíûõ ñëó÷àÿõ ñêîáêè îïóñêàòü íå ñëåäóåò ýòî
ìîæåò ïðèâåñòè ê îøèáêàì.
Ìíîãèå ïðèåìû è ôóíêöèè äëÿ ðàáîòû ñî ñòðîêàìè òàêæå ïîäõîäÿò è äëÿ êîðòåæåé,
íàïðèìåð, ìîæíî ñêëàäûâàòü äâà êîðòåæà:
a = (1 , 2 , 3)
b = (4 , 5 , 6)
print ( a + b )
 ðåçóëüòàòå ïðèìåíåíèÿ ýòîé îïåðàöèè áóäåò âûâåäåíî (1, 2, 3, 4, 5, 6).  ñëó÷àå
ñëîæåíèÿ ñîçäàåòñÿ íîâûé êîðòåæ, êîòîðûé ñîäåðæèò â ñåáå ýëåìåíòû ñíà÷àëà èç ïåð-
âîãî, à çàòåì âòîðîãî êîðòåæà (òî÷íî òàêæå êàê è â ñëó÷àå ñî ñòðîêàìè). Òàêæå êîðòåæ
ìîæíî óìíîæèòü íà ÷èñëî, ðåçóëüòàò ýòîé îïåðàöèè àíàëîãè÷åí óìíîæåíèþ ñòðîêè íà
÷èñëî.
Êîðòåæ ìîæíî ïîëó÷èòü èç ñòðîêè, âûçâàâ ôóíêöèþ tuple îò ñòðîêè.  ðåçóëüòà-
òå êàæäàÿ áóêâà ñòàíåò ýëåìåíòîì êîðòåæà. Ê êîðòåæó ìîæíî ïðèìåíÿòü ôóíêöèþ
str, êîòîðàÿ âåðíåò òåêñòîâîå ïðåäñòàâëåíèå êîðòåæà (ýëåìåíòû, ïåðå÷èñëåííûå ÷åðåç
çàïÿòóþ ñ ïðîáåëîì è ðàçäåëåííûå ïðîáåëàìè).

5.2 Работа с кортежами

Ê êîðòåæó ìîæíî ïðèìåíÿòü ôóíêöèþ len è îáðàùàòüñÿ ê ýëåìåíòàì ïî èíäåêñó (â


òîì ÷èñëå ïî îòðèöàòåëüíîìó) òàêæå êàê è ê ñòðîêàì.
 îäíîì êîðòåæå ìîãóò õðàíèòüñÿ ýëåìåíòû ðàçëè÷íûõ òèïîâ, íàïðèìåð, ñòðîêè,
÷èñëà è äðóãèå êîðòåæè âïåðåìåøêó. Íàïðèìåð, â êîðòåæå myTuple = (('a', 1, 3.14),

41
42 ЛЕКЦИЯ 5. КОРТЕЖИ, ЦИКЛ FOR, СПИСКИ

'abc', ((1), (2, ))), myTuple[0] áóäåò êîðòåæåì ('a', 1, 3.14), myTuple[1] ñòðîêîé 'abc', à
myTuple[2] êîðòåæåì ñîñòîÿùèì èç ÷èñëà 1 è êîðòåæà èç îäíîãî ýëåìåíòà (2, ). ×èñ-
ëà, çàïèñàííûå â ñêîáêàõ, èíòåðïðåòèðóþòñÿ êàê ÷èñëà, â ñëó÷àå âîçíèêíîâåíèÿ íåîá-
õîäèìîñòè ñîçäàòü êîðòåæ èç îäíîãî ýëåìåíòà íåîáõîäèìî ïîñëå çíà÷åíèÿ ýëåìåíòà
íàïèñàòü çàïÿòóþ. Åñëè âûâåñòè myTuple[2][1], òî íàïå÷àòàåòñÿ (2,), à åñëè âûâåñòè
myTuple[2][1][0], òî áóäåò íàïå÷àòàíî ÷èñëî 2.
Êîðòåæ, ñîäåðæàùèé â ñåáå îäèí ýëåìåíò íàçûâàåòñÿ ñèíãëòîíîì. Êàê è ê ñòðîêàì, ê
êîðòåæàì ìîæíî ïðèìåíÿòü îïåðàöèþ ñðåçà ñ òåì æå ñìûñëîì ïàðàìåòðîâ. Åñëè â ñðåçå
îäèí ïàðàìåòð, òî áóäåò âîçâðàùåíà ññûëêà íà ýëåìåíò ñ ñîîòâåòñòâóþùèì íîìåðîì.
Íàïðèìåð, print((1, 2, 3)[2]) íàïå÷àòåò 3. Åñëè æå â ñðåçå áîëåå îäíîãî ïàðàìåòðà, òî
áóäåò ñêîíñòðóèðîâàí êîðòåæ, äàæå åñëè îí áóäåò ñèíãëòîíîì. Íàïðèìåð, â ñëó÷àå
âûçîâà print((1, 2, 3)[1:]) áóäåò íàïå÷àòíî (2, 3), à â ñëó÷àå âûçîâà print((1, 2, 3)[2:])
áóäåò íàïå÷àòàí ñèíãëòîí (3,).
Êîðòåæè, îáû÷íî, ïðåäíàçíà÷àþòñÿ äëÿ õðàíåíèÿ ðàçíîòèïîâûõ çíà÷åíèé, äîñòóï
ê êîòîðûì ìîæåò áûòü ïîëó÷åí â ðåçóëüòàòå îáðàùåíèÿ ïî èíäåêñó èëè ñ ïîìîùüþ
îïåðàöèè ðàñïàêîâêè.
Ðàñïàêîâêîé íàçûâàåòñÿ ïðîöåññ ïðèñâàèâàíèÿ, â êîòîðîì êîðòåæ, ñîñòàâëåííûé èç
îòäåëüíûõ ïåðåìåííûõ íàõîäèòñÿ â ëåâîé ÷àñòè âûðàæåíèÿ.  òàêîì âûðàæåíèè ñïðàâà
äîëæåí íàõîäèòñÿ êîðòåæ òîé æå äëèíû. Íàïðèìåð, â ðåçóëüòàòå âûïîëíåíèÿ òàêîãî
êîäà:
manDesc = ( " Ivan " , " Ivanov " , 2 8 )
name , surname , age = manDesc
 ïåðåìåííîé name êàæåòñÿ Ivan, â surname  Ivanov, à â ïåðåìåííîé age ÷èñëî
28. Íà àíãëèéñêîì ðàñïàêîâêà êîðòåæà íàçûâàåòñÿ tuple unpacking.
Ïðîöåññ ñîçäàíèÿ êîðòåæà íàçûâàåòñÿ óïàêîâêîé êîðòåæà. Åñëè â îäíîì âûðàæåíèè
ïðèñâàèâàíèÿ ïðîèñõîäèò è óïàêîâêà è ðàñïàêîâêà êîðòåæà, òî ñíà÷àëà âûïîëíÿåòñÿ
óïàêîâêà, à çàòåì ðàñïàêîâêà êîðòåæà. Òàê, â ðåçóëüòàòå ðàáîòû ïðîãðàììû:
a, b, c = 1, 2, 3
a, b, c = c , b, a
print ( a , b , c )
áóäåò âûâåäåíî 3 2 1. Îáðàòèòå âíèìàíèå, ÷òî ôóíêöèè print ïåðåäàåòñÿ â êà÷åñòâå
ïàðàìåòðà íå êîðòåæ, à òðè öåëûõ ÷èñëà.
Ãëàâíîå ÷òî íóæíî ïîíÿòü, ÷òî çàïèñàòü âèäà (a, b, c) = (c, b, a) íå ýêâèâàëåíòíà
öåïî÷êå ïðèñâàèâàíèé âèäà a = c; b = b; c = a. Òàêàÿ öåïî÷êà ïðèñâàèâàíèé ïðèâåëà
áû ê òîìó, ÷òî â ïåðåìåííûõ a, b, c îêàçàëèñü áû çíà÷åíèÿ 3, 2, 3.

5.3 Функция range

 ÿçûêå Ïèòîí åñòü ôóíêöèÿ range, êîòîðàÿ ïîçâîëÿåò ãåíåðèðîâàòü îáúåêòû òèïà
iterable (ê ýëåìåíòàì êîòîðûõ ìîæíî ïîëó÷àòü ïîñëåäîâàòåëüíûé äîñòóï) ñîñòîÿùèå
èç öåëûõ ÷èñåë.
Äëÿ âûâîäà îáúåêòîâ òèïà iterable ìû áóäåì ïîëüçîâàòüñÿ ôóíêöèåé tuple, êîòîðàÿ
ïîçâîëÿåò ñäåëàòü êîðòåæ, ñîñòîÿùèé èç âñåõ ýëåìåíòîâ iterable, çàïèñàííûõ ïîñëåäî-
âàòåëüíî.
Íàïðèìåð, åñë çàïóñòèòü ïðîãðàììó
5.4. ЦИКЛ FOR 43

print ( tuple ( range ( 1 0 ) ) )

òî áóäåò íàïå÷àòàíî (0, 1, 2, 3, 4, 5, 6, 7, 8, 9). Ôóíêöèÿ range ñ îäíèì ïàðàìåòðîì


n ãåíåðèðóåò iterable, ñîäåðæàùèé ïîñëåäîâàòåëüíûå ÷èñëà îò 0 äî n-1.
Ñóùåñòâóåò âàðèàíò range ñ äâóìÿ ïàðàìåòðàìè, range(from, to) ñãåíåðèðóåò iterable
ñî âñåìè ÷èñëàìè îò 𝑓 𝑟𝑜𝑚 äî 𝑡𝑜 − 1 âêëþ÷èòåëüíî.
Òàêæå ñóùåñòâóåò range ñ òðåìÿ ïàðàìåòðàìè range(from, to, step), êîòîðûé ñãåíåðè-
ðóåò iterable ñ ÷èñëàìè îò 𝑓 𝑟𝑜𝑚, íå ïðåâûøàþùèå 𝑡𝑜 ñ øàãîì èçìåíåíèÿ 𝑠𝑡𝑒𝑝. Åñëè øàã
îòðèöàòåëåí, òî 𝑓 𝑟𝑜𝑚 äîëæåí áûòü áîëüøå 𝑡𝑜. Íàïðèìåð, range(10, 0, -2) ñãåíåðèðóåò
ïîñëåäîâàòåëüíîñòü ÷èñåë 10, 8, 6, 4, 2. 0 íå áóäåò âõîäèòü â ýòó ïîñëåäîâàòåëüíîñòü.
Âî ìíîãîì ïàðàìåòðû range íàïîìèíàþò çíà÷åíèÿ ïàðàìåòðîâ â ñðåçàõ ñòðîê.

5.4 Цикл for

Öèêë for ïîçâîëÿåò ïîî÷åðåäíî ïåðåáðàòü ýëåìåíòû èç ÷åãî-íèáóäü èòåðèðóåìîãî


(iterable èëè tuple). Íàïðèìåð, ìû ìîæåì ïåðåáðàòü íàçâàíèÿ öâåòîâ ÿáëîê òàêèì ñïî-
ñîáîì:
f o r c o l o r in ( ' r e d ' , ' g r e e n ' , ' yellow ' ) :
print ( c o l o r , ' a p p l e ' )

 ðåçóëüòàòå âûïîëíåíèÿ ýòîé ïðîãðàììû áóäåò íàïå÷àòàíî:


red apple
green apple
yellow apple
Íà ìåñòî ïåðåìåííîé color áóäóò ïîî÷åðåäíî ïîäñòàâëÿòüñÿ çíà÷åíèÿ èç êîðòåæà. Â
îáùåì ñëó÷àå öèêë for âûãëÿäèò òàê for èìÿÏåðåìåííîé in íå÷òîÈòåðèðóåìîå:
Âñå äåéñòâèÿ, êîòîðûå äîëæíû âûïîëíÿòüñÿ â for, äîëæíû âûäåëÿòüñÿ îòñòóïîì,
êàê è â if èëè while. Ðàáîòà öèêë for ìîæåò áûòü ïðåðâàíà ñ ïîìîùüþ êîìàíäû break
èëè ìîæåò áûòü îñóùåñòâëåí ïåðåõîä ê ñëåäóþùåé èòåðàöèè ñ ïîìîùüþ continue. Ýòè
êîìàíäû èìåþò òîò æå ýôôåêò, ÷òî è ïðè ðàáîòå ñ öèêëîì while.
×àñòî for ñïîëüçóåòñÿ âìåñòå ñ ôóíêöèåé range. Íàïðèìåð, ñ ïîìîùüþ for ìîæíî
íàïå÷àòàòü íå÷åòíûå ÷èñëà îò 1 äî 100:
f o r i in range ( 1 , 1 0 0 , 2 ) :
print ( i )

Âíóòðè for ìîæåò áûòü ðàñïîëîæåí è äðóãîé for. Âîò òàê âûãëÿäèò êîä äëÿ âûâîäà
òàáëèû óìíîæåíèÿ âñåõ ÷èñåë îò 1 äî 10 (íå î÷åíü êðàñèâîé):
f o r i in range ( 1 , 1 1 ) :
f o r j in range ( 1 , 1 1 ) :
print ( i * j , end= ' ')
print ( )

Êàê âû ìîæåòå çàìåòèòü, ïðè èñïîëüçîâàíèè ôóíêöèè range â for ìû íå ïðåîáðàçî-


âûâàëè iterable â tuple. Ýòî ñâÿçàíî ñ òåì, ÷òî for êàê ðàç õî÷åò ïîëó÷àòü ïîñëåäîâà-
òåëüíûé äîñòóï, êîòîðûé óìååò äàâàòü iterable. Tuple óìååò íàìíîãî áîëüøå, íî çäåñü
åãî èñïîëüçîâàíèå ïðèâåäåò ê íåíóæíûì çàòðàòàì âðåìåíè è ïàìÿòè.
44 ЛЕКЦИЯ 5. КОРТЕЖИ, ЦИКЛ FOR, СПИСКИ

5.5 Списки

Ñïèñîê â Ïèòîíå ÿâëÿåòñÿ àíàëîãîì ìàññèâîâ â äðóãèõ ÿçûêàõ ïðîãðàììèðîâàíèÿ.


Ñïèñîê  ýòî íàáîð ññûëîê íà îáúåêòû (òàêæå êàê è êîðòåæ), îäíàêî îí ÿâëÿåòñÿ
èçìåíÿåìûì.
Êîíàñòíàíòíûå ñïèñêè çàïèñûâàþòñÿ â êâàäðàòíûõ ñêîáêàõ, âñå îñòàëüíîå â íèõ
àíàëîãè÷íî êîðòåæàì. Íàïðèìåð ìîæíî ñîçäàòü ñïèñîê ñ ÷èñëàìè îò 1 äî 5: myList =
[1, 2, 3, 4, 5].
Ñïèñêè è êîðòåæè ëåãêî ïðåîáðàçóþòñÿ äðóã â äðóãà. Äëÿ ïðåîáðàçîâàíèÿ ñïèñêà
â êîðòåæ íàäî èñïîëüçîâàòü óæå èçâåñòíóþ íàì ôóíêöèþ tuple, à äëÿ ïðåîáðàçîâàíèÿ
êîðòåæà â ñòðîêó íóæíà ôóíêöèÿ list. Òàêæå ôóíêöèþ list ìîæíî ïðèìåíèòü ê ñòðîêå. Â
ðåçóëüòàòå ýòîãî ïîëó÷èòñÿ ñïèñîê, êàæäûì ýëåìåíòîì êîòîðîãî áóäåò áóêâà èç ñòðîêè.
Òàê list('abc') áóäåò âûãëÿäåòü êàê ['a', 'b', 'c'].
Ê ñïèñêàì òàêæå ïðèìåíèìà ôóíêöèÿ len è ñðåçû, êîòîðûå ðàáîòàþò òàêæå êàê â
êîðòåæàõ.
Ãëàâíûì îòëè÷èåì ñïèñêà îò êîðòåæà ÿâëÿåòñÿ èçìåíÿåìîñòü. Òî åñòü ìîæíî âçÿòü
îïðåäåëåííûé ýëåìåíò ñïèñêà è èçìåíèòü åãî (îí ìîæåò áûòü â ëåâîé ÷àñòè îïåðàöèè
ïðèñâàèâàíèÿ).
Íàïðèìåð, â ðåçóëüòàòå âûïîëíåíèÿ òàêîãî êîäà:
myList = [ 1 , 2 , 3 ]
myList [ 1 ] = 4
print ( myList )
áóäåò íàïå÷àòàíî [1, 4, 3].
Èçìåíåíèå ñèìâîëà (èëè ýëåìåíòà â êîðòåæå) ìîæíî áûëî ðåàëèçîâàòü, ñäåëàâ äâà
ñðåçà è êîíêàòåíàöèÿ ïåðâîé ÷àñòè ñòðîêè, íîâîãî ñèìâîëà è ¾õâîñòà¿ ñòðîêè. Ýòî
î÷åíü ìåäëåííàÿ îïåðàöèÿ, âðåìÿ åå âûïîëíåíèÿ ïðîïîðöèîíàëüíî äëèíå ñòðîêè. Çà-
ìåíà ýëåìåíòà â ñïèñêå îñóùåñòâëÿåòñÿ çà 𝑂(1), ò.å. íå çàâèñèò îò äëèíû ñïèñêà.

5.6 Изменение списков

Ñïèñîê, êàê è äðóãèå òèïû â ÿçûêå Ïèòîí, ÿâëÿåòñÿ ññûëêîé íà ñïèñîê ññûëîê. Ïðè
ýòîì ñïèñîê ÿâëÿåòñÿ èçìåíÿåìûì îáúåêòîì, ò.å. ñîäåðæèìîå ïî ýòîé ññûëêå ìîæåò
ïîìåíÿòüñÿ. ðàññìàîòðèì òàêîé ïðèìåð:
a = [1 , 2]
b = a
b[0] = 3
print ( a )
 ðåçóëüòàòå âûïîëíåíèÿ ýòîé ïðîãðàììû áóäåò íàïå÷àòàíî [3, 2]. Ýòî ñâÿçàíî ñ òåì,
÷òî ïðèñâàèâàíèå â Ïèòîíå  ýòî ïðîñòî ¾ïðèâÿçûâàíèå¿ íîâîãî ¾ÿðëû÷êà¿ îáúåêòó.
Ïîñëå ïðèñâàèâàíèÿ b = a îáå ññûëêè íà÷èíàþò ïîêàçûâàòü íà îäèí è òîò æå îáúåêò
è åñëè îí èçìåíåíåí ïî îäíîé ññûëêå, òî ïî âòîðîé ññûëêå îí òàæêå áóäåò äîñòóïåí â
èçìåíåííîì ñîñòîÿíèè.
Åñëè æå íàïèñàòü òàêîé êîä:
a = [1 , 2]
b = [1 , 2]
5.6. ИЗМЕНЕНИЕ СПИСКОВ 45

a[0] = 3
print ( b )

òî áóäåò âûâåäåíî [1, 2]. Íåñìîòðÿ íà òî, ÷òî îáúåêòû èìåþò îäèíàêîâîå çíà÷åíèå
èç-çà èõ ìóòàáåëüíîñòè (èçìåíÿåìîñòè) äëÿ êàæäîãî çíà÷åíèÿ áóäåò ñîçäàí îòäåëüíûé
îáúåêò è ññûëêè a è b áóäóò ïîêàçûâàòü íà ðàçíûå îáúåêòû. Èçìåíåíèå îäíîãî èç íèõ,
åñòåòñòâåííî, íå ïðèâîäèò ê èçìåíåíèþ äðóãîãî.
 ðåçóëüòàòå âûïîëíåíèÿ òàêîãî êîäà:

a = [1 , 2]
b = a
a = [3 , 4]
print ( b )

áóäåò âûâåäåíî [1, 2]. Ñíà÷àëà â ïàìÿòè ñîçäàåòñÿ îáúåêò [1, 2] è ê íåìó ïðèâÿçû-
âàåòñÿ ññûëêà a, çàòåì ê òîìó æå îáúåêòó ïðèâÿçûâàåòñÿ ññûëêà b, à çàòåì ñîçäàåòñÿ
íîâûé îáúåêò [2, 3], ê êîòîðîìó ïðèâÿçûâàåòñÿ ññûëêà a (îòâÿçàâøèñü îò ñâîåãî ïðåäû-
äóùåãî çíà÷åíèÿ). Ïðè ýòîì ññûëêà b íå èçìåíèëàñü (îíà ìîæåò èçìåíèòüñÿ òîëüêî
åñëè b áóäåò ó÷àñòâîâàòü â ëåâîé ÷àñòè ïðèñâàèâàíèÿ) è ïî-ïðåæíåìó ïîêàçûâàåò íà
[1, 2].
Åñëè ñïèñêè ïåðåäàíû â ôóíêöèþ â êà÷åñòâå ïàðàìåòðîâ, òî èõ ñîäåðæèìîå òàêæå
ìîæåò áûòü èçìåíåíî ýòîé ôóíêöèåé:

def r e p l a c e F i r s t ( myList ) :
myList [ 0 ] = ' x '

nowList = l i s t ( ' a b c d e f ' )


r e p l a c e F i r s t ( nowList )
print ( nowList )

Âûâîäå ýòîé ïðîãðàììû áóäåò ['x', 'b', 'c', 'd', 'e', 'f'].
Îäíàêî, ñàìà ññûëêà âíóòðè ôóíêöèè íå ìîæåò áûòü èçìåíåíà, åñëè îíà ïåðåäàíà
êàê ïàðàìåòð ôóíêöèè. Ðàññìîòðèì ïðèìåð:

def r e v e r s e L i s t ( f u n c L i s t ) :
funcList = funcList [:: −1]

m a i n L i s t = l i s t ( ' abc ' )


r e v e r s e L i s t ( mainList )
print ( m a i n L i s t )

Ýòà ïðîãðàììà íå ðàçâåðíåò ñïèñîê, ò.å. âûâîä áóäåò ['a', 'b', 'c'].
Çäåñü â îñíîâíîé ïðîãðàììå êîíñòðóèðóåòñÿ îáúåêò ['a', 'b', 'c'] è ê íåìó ïðèâÿçûâà-
åòñÿ ññûëêà mainList. Ïðè ïåðåäà÷å mainList â êà÷åñòâå ïàðàìåòðà â ôóíêöèþ ñîçäàñòñÿ
åùå îäíà ññûëêà funcList, ïîêàçûâàþùàÿ íà îáúåêò ['a', 'b', 'c']. Â ðåçóëüòàòå ïðèìå-
íåíèÿ ñðåçà ñîçäàñòñÿ íîâûé îáúåêò ['c', 'b', 'a'] è ññûëêà funcList íà÷íåò óêàçûâàòü
íà íåãî. Îäíàêî, çíà÷åíèå ññûëêè mainList ïðè ýòîì íå èçìåíèòñÿ è ñî çíà÷åíèÿìè ïî
ññûëêå mainList òàêæå íè÷åãî íå ïðîèçîéäåò (íàïîìíèì, ÷òî îïåðàöèÿ ñðåçà ñîçäàåò
íîâûé îáúåêò, íå èçìåíÿÿ ñòàðûé).
46 ЛЕКЦИЯ 5. КОРТЕЖИ, ЦИКЛ FOR, СПИСКИ

5.7 Методы split и join, функция map

Ñòðîêè èìåþò äâà ïîëåçíûõ ìåòîäà, êîòîðûå ïðèãîäÿòñÿ ïðè ðàáîòå ñî ñïèñêàìè.
Ìåòîä split ïîçâîëÿåò ðàçðåçàòü ñòðîêó (string) íà îòäåëüíûå ñëîâà (¾òîêåíû¿). Â
êà÷åñòâå ðàçäåëèòåëÿ ìîæåò âûñòóïàòü ïðîáåë, ñèìâîë òàáóëÿöèè èëè ïåðåâîäà ñòðîêè.
Ýòîò ìåòîä íå èçìåíÿåò ñòðîêó è âîçâðàùàåò ñïèñîê ñòðîê-òîêåíîâ.
Íàïðèìåð, åñëè çàóïñòèòü òàêóþ ïðîãðàììó
print ( ' r e d g r e e n blue ' . s p l i t ( ) )
òî áóäåò íàïå÷àòàíî ['red', 'green', 'blue']. Êîëè÷åñòâî ðàçäåëèòåëåé ìåæäó òîêåíàìè
íå èãðàåò ðîëè.
×òîáû íàó÷èòüñÿ ÷èòàòü ÷èñëà èç îäíîé ñòðîêè íóæíî íàó÷èòüñÿ åùå îäíîé ôóíê-
öèè  map. Ôóíêöèÿ map ïðèíèìàåò äâà ïàðàìåòðà: ïåðâûé ýòî ôóíêöèè, à âòîðîé 
iterable ýëåìåíòîâ, ê êîòîðîìó íóæíî ïðèìåíèòü ýòó ôóíêöèþ.  ðåçóëüòàòå ïîëó÷àåòñÿ
iterable ñ ðåçóëüòàòîì ïðèìåíåíèÿ ôóíêöèè ê êàæäîìó ýëåìåíòó ñïèñêà ïàðàìåòðà.
Íàïðèìåð, òàêîé êîä:
print ( l i s t (map( len , [ ' red ' , ' green ' , ' blue ' ] ) ) )
íàïå÷àòàåò [3, 5, 4]  ñïèñîê ñ ðåçóëüòàòîì ïðèìåíåíèÿ ôóíêöèè len ê ñïèñêó ['red',
'green', 'blue'].
Ìåòîä split â ñî÷åòàíèè ñ ôóíêöèåé map óäîáíî èñïîëüçîâàòü äëÿ ñ÷èòûâàíèÿ ñïèñêà
÷èñåë, çàïèñàííûõ â îäíó ñòðîêó è ðàçäåëåííûõ ïðîáåëàìè. Òàêîå ñ÷èòûâàíèå áóäåò
âûãëÿäåòü òàê:
numList = l i s t (map( int , input ( ) . s p l i t ( ) ) )
Ñíà÷àëà îñóùåñòâëÿåòñÿ ñ÷èòûâàíèå ñòðîêè, çàòåì âûïîëíÿåòñÿ ìåòîä split, êîòî-
ðûé ñîçäàåò ñïèñîê òîêåíîâ, ñîñòîÿùèõ èç öèôð, à çàòåì ê êàæäîìó òîêåíó ïðèìåíÿåòñÿ
ôóíêöèÿ int.  ðåçóëüòàòå ýòîãî ïîëó÷àåòñÿ ñïèñîê öèôð.
Ìåòîä join ïîçâîëÿåò îáúåäèíèòü iterable ñòðîê, èñïîëüçóÿ òó ñòðîêó, ê êîòîðîé îí
ïðèìåíåí, â êà÷åñòâå ðàçäåëèòåëÿ. Íàïðèìåð, òàêîé êîä:
print ( ' , ' . j o i n ( [ ' Veni ' , ' V i d i ' , ' V i c i ' ] ) )
âûâåäåò Veni, Vidi, Vici. Ñòðîêà ', ' áóäåò âûñòóïàòü â êà÷åñòâå ðàçäåëèòåëÿ êîòîðûé
áóäåò âñòàâëÿòüñÿ ïîñëå êàæäîé ñòðîêè èç ñïèñêà-ïàðàìåòðà (êðîìå ïîñëåäíåé).
Ìåòîä join ïîçâîëÿåò áûñòðî è êîðîòêî âûâîäèòü ñïèñêè ÷èñåë. Ïðîáëåìà â òîì, ÷òî
îí óìååò ïðèíèìàòü â êà÷åñòâå ïàðàìåòðà òîëüêî iterable ñòðîê. Íî ñ ïîìîùüþ ôóíêöèè
map ìû ìîæåì ëåãêî ïîëó÷èòü iterable èç ñïèñêà ÷èñåë, ïðèìåíèâ ê êàæäîìó ýëåìåíòó
ôóíêöèþ str. Âûâîä ñïèñêà ÷èñåë numList ðàçäåëåííûõ ïðîáåëàìè áóäåò âûãëÿäåòü
òàê:
numList = [ 1 , 2 , 3 ]
print ( ' ' . j o i n (map( str , numList ) ) )

5.8 Другие полезные методы для работы со списками

Ê ïåðåìåííûì òèïà ñïèñîê ìîæíî ïðèìåíÿòü ìåòîäû, ïåðå÷èñëèì íåêîòîðûå èç


íèõ:
Ìåòîäû, íå èçìåíÿþùèå ñïèñîê è âîçâðàùàþùèå çíà÷åíèå:
5.9. ПОЧЕМУ СОЗДАНИЕ НОВОГО ЛУЧШЕ УДАЛЕНИЯ 47

count(x)  ïîäñ÷èòûâàåò ÷èñëî âõîæäåíèé çíà÷åíèÿ x â ñïèñîê. Работает за время


O(N)
index(x)  íàõîäèò ïîçèöèþ ïåðâîãî âõîæäåíèÿ çíà÷åíèÿ x â ñïèñîê. Работает за
время O(N)
index(x, from)  íàõîäèò ïîçèöèþ ïåðâîãî âõîæäåíèÿ çíà÷åíèÿ x â ñïèñîê, íà÷èíàÿ
ñ ïîçèöèè from. Работает за время O(N)
Ìåòîäû, íå âîçâðàùàþùèå çíà÷åíèå, íî èçìåíÿþùèå ñïèñîê:
append(x)  äîáàâëÿåò çíà÷åíèå x â êîíåö ñïèñêà
extend(otherList)  äîáàâëÿåò âñå ñîäåðæèìîå ñïèñêà otherList â êîíåö ñïèñêà. Â
îòëè÷èå îò îïåðàöèè + èçìåíÿåò îáúåêò ê êîòîðîìó ïðèìåíåí, à íå ñîçäàåò íîâûé
remove(x)  óäàëÿåò ïåðâîå âõîæäåíèå ÷èñëà x â ñïèñîê. Работает за время O(N)
insert(index, x)  âñòàâëÿåò ÷èñëî x â ñïèñîê òàê, ÷òî îíî îêàçûâàåòñÿ íà ïîçèöèè
index. ×èñëî, ñòîÿâøåå íà ïîçèöèè index è âñå ÷èñëà ïðàâåå íåãî ñäâèãàþòñÿ íà îäèí
âïðàâî. Работает за время O(N)
reverse()  Ðàçâîðà÷èâàåò ñïèñîê (ìåíÿåò çíà÷åíèå ïî ññûëêå, à íå ñîçäàåò íîâûé
ñïèñîê êàê myList[::-1]). Работает за время O(N)
Ìåòîäû, âîçâðàùàþùèå çíà÷åíèå è èçìåíÿþùèå ñïèñîê:
pop()  âîçâðàùàåò ïîñëåäíèé ýëåìåíò ñïèñêà è óäàëÿåò åãî
pop(index)  âîçâðàùàåò ýëåìåíò ñïèñêà íà ïîçèöèè index è óäàëÿåò åãî. Работает
за время O(N)

5.9 Почему создание нового лучше удаления

Ðàññìîòðèì òàêóþ çàäà÷ó: íåîáõîäèìî âûáðàòü âñå íå÷åòíûå ýëåìåíòû ñïèñêà myList
è óäàëèòü èõ èç íåãî.
Ïîïðîáóåì ðåøèòü çàäà÷ó â ëîá  ïðîñòî áóäåì ïåðåáèðàòü âñå ïîçèöèè â ñòðîêå è,
åñëè íà ýòîé ïîçèöèè ñòîèò íå÷åòíîå ÷èñëî, áóäåì óäàëÿòü åãî.
numbers = l i s t (map( int , input ( ) . s p l i t ( ) ) )
f o r i in range ( len ( numbers ) ) :
i f numbers [ i ] % 2 != 0 :
numbers . pop ( i )
print ( ' ' . j o i n (map( str , numbers ) ) )

Òàêîå ðåøåíèå áóäåò ðàáîòàòü íåïðàâèëüíî â ñèòóàöèè, êîãäà â ñïèñêå åñòü õîòü
îäíî íå÷åòíîå ÷èñëî. Ýòî ñâÿçàíî ñ òåì, ÷òî îáúåêò áåç íàçâàíèÿ ñ òèïîì iterable è
çíà÷åíèåì range(len(numbers)) ñãåíåðèðóåòñÿ îäèí ðàç, êîãäà èíòåðïðåòàòîð âïåðâûå
äîéäåò äî ýòîãî ìåñòà è óæå íèêîãäà íå èçìåíèòñÿ. Åñëè â ïðîöåññå ìû âûêèíåì èç
ñïèñêà numbers õîòü îäíî çíà÷åíèå, òî â ïðîöåññå ïåðåáîðà âñåõ èíäåêñîâ âûéäåì çà
ïðåäåëû íàøåãî ñïèñêà. range, èñïîëüçóåìûé â for, íå áóäåò ìåíÿòü ñâîå çíà÷åíèå åñëè
â ïðîöåññå ðàáîòû èçìåíèëèñü ïàðàìåòðû ôóíêöèè range.
Ðåøåíèå ìîæíî ïåðåïèñàòü ñ ïîìîùüþ while:
numbers = l i s t (map( int , input ( ) . s p l i t ( ) ) )
i = 0
while i < len ( numbers ) :
i f numbers [ i ] % 2 != 0 :
numbers . pop ( i )
48 ЛЕКЦИЯ 5. КОРТЕЖИ, ЦИКЛ FOR, СПИСКИ

else :
i += 1
print ( ' ' . j o i n (map( str , numbers ) ) )
Òàêîå ðåøåíèå áóäåò ðàáîòàòü, íî îíî íå î÷åíü ýôôåêòèâíî. Êàæäûé ðàç ïðè óäàëå-
íèè ýëåìåíòà íàì ïðèäåòñÿ ñîâåðøàòü êîëè÷åñòâî îïåðàöèé, ïðîïîðöèîíàëüíîå äëèíå
ñïèñêà. Èòîãîâîå êîëè÷åñòâî îïåðàöèé â õóäøåì ñëó÷àå áóäåò ïðîïîðöèîíàëüíî êâà-
äàðòó êîëè÷åñòâà ýëåìåíòîâ â ñïèñêå.
 ñëó÷àå, åñëè íåò î÷åíü ñòðîãîãî îãðàíè÷åíèÿ â ïàìÿòè, â çàäà÷àõ, ãäå íóæíî
óäàëèòü ÷àñòü ýëåìåíòîâ ñïèñêà ãîðàçäî ïðîùå ñîçäàòü íîâûé ñïèñîê, â êîòîðûé íóæíî
äîáàâëÿòü òîëüêî ïîäõîäÿùèå ýëåìåíòû.
numbers = l i s t (map( int , input ( ) . s p l i t ( ) ) )
newList = [ ]
f o r i in range ( len ( numbers ) ) :
i f numbers [ i ] % 2 == 0 :
newList . append ( numbers [ i ] )
print ( ' ' . j o i n (map( str , newList ) ) )
Ñëîæíîñòü òàêîãî ðåøåíèÿ ïðîïîðöèîíàëüíà äëèíå èñõîäíîãî ñïèñêà, ÷òî íàìíîãî
ëó÷øå.
Лекция 6

Сортировка, лямбда-функции,

именованные параметры

6.1 Сортировка списков

 ïðîãðàììèðîâàíèè î÷åíü ÷àñòî óäîáíåå ðàáîòàòü ñ îòñîðòèðîâàííûìè äàííûìè.


 ÿçûêå Ïèòîí ñóùåñòâóåò âîçìîæíîñòü îòñîðòèðîâàòü ñïèñêè äâóìÿ ñïîñîáàìè. Ðàñ-
ñìîòðèì èõ íà ïðèìåðå ðåøåíèÿ ïðîñòîé çàäà÷è î ñîðòèðîâêå ïîñëåäîâàòåëüíîñòè ÷èñåë
ïî íåóáûâàíèþ (ýòî êàê ïî âîçðàñòàíèþ, íî, âîçìîæíî, ñ îäèíàêîâûìè ÷èñëàìè). Âîò
ïåðâûé ñïîñîá óïîðÿäî÷èòü åãî:
myList = l i s t (map( int , input ( ) . s p l i t ( ) ) )
myList . s o r t ( )
print ( ' ' . j o i n (map( str , myList ) ) )
 ýòîì ïðèìåðå èñïîëüçóåòñÿ ìåòîä sort, ïðèìåíÿåìûé ê ñïèñêó. Ýòîò ìåòîä èçìå-
íÿåò ñîäåðæèìîå ñïèñêà  ïîñëå ïðèìåíåíèÿ ìåòîäà sort ýëåìåíòû â ñïèñêå ñòàíîâÿòñÿ
óïîðÿäî÷åííûìè. Òàêîé ìåòîä îïðåäåëåí òîëüêî äëÿ îáúåêòîâ òèïà ñïèñîê, åãî íåëüçÿ
ïðèìåíèòü ê êîðòåæó èëè iterable èëè ñòðîêå.
Âòîðîé ñïîñîá ñîñòîèò â ïðèìåíåíèè ôóíêöèè sorted, êîòîðàÿ âîçâðàùàåò îòñîðòè-
ðîâàííûé ñïèñîê, íî íå èçìåíÿåò çíà÷åíèå ñâîåãî ïàðàìåòðà:
myList = l i s t (map( int , input ( ) . s p l i t ( ) ) )
s o r t e d L i s t = sorted ( myList )
print ( ' ' . j o i n (map( str , s o r t e d L i s t ) ) )
Èñïîëüçîâàíèå ôóíêöèè sorted îïðàâäàíî â ñëó÷àå, åñëè èñõîäíûå äàííûå íóæíî
ñîõðàíèòü â íåèçìåííîì âèäå ñ êàêîé-òî öåëüþ. Íàïðèìåð, sorted ìîæíî èñïîëüçîâàòü
âíóòðè ñâîåé ôóíêöèè äëÿ ñîçäàíèÿ îòñîðòèðîâàííîé êîïèè, ÷òîáû íå ïîðòèòü ïåðå-
äàííûé íàì ñïèñîê.
×òîáû îòñîðòèðîâàòü ñïèñîê ïî íåâîçðàñòàíèþ (óáûâàíèþ), íåîáõîäèìî ïåðåäàòü â
ìåòîä èëè ôóêíöèþ èìåíîâàííûé ïàðàìåòð reversed. Íàïðèìåð, ýòî áóäåò âûãëÿäåòü
êàê myList.sort(reversed=True) èëè sorted(myList, reversed=True).
Ôóíêöèÿ sorted ìîæåò ïðèíèìàòü â êà÷åñòâå ïàðàìåòðà íå òîëüêî ñïèñîê, íî è ÷òî
óãîäíî èòåðèðóåìîå: êîðòåæè, iterable èëè ñòðîêè:
print ( sorted ( ( 1 , 3 , 2 ) ) )
print ( sorted ( range ( 1 0 , − 1, − 2)))

49
50ЛЕКЦИЯ 6. СОРТИРОВКА, ЛЯМБДА-ФУНКЦИИ, ИМЕНОВАННЫЕ ПАРАМЕТРЫ

print ( sorted ( " cba " ) )


Ïðè ýòîì sorted âñåãäà âîçâðàùàåò ñïèñîê, ò.å. âûâîä ýòîé ïðîãðàììû áóäåò òàêîé:

[1, 2, 3]
[0, 2, 4, 6, 8, 10]
[’a’, ’b’, ’c’]

Ñîðòèðîâêó ìîæíî ïðèìåíÿòü ê ñïèñêàì, âñå ýëåìåíòû êîòîðûõ ñðàâíèìû ìåæäó


ñîáîé. Îáû÷íî ýòî îäíîðîäíûå ñïèñêè (ñîñòîÿùèå èç ýëåìåíòîâ îäíîãî òèïà) èëè, â
ðåäêèõ ñëó÷àÿõ, öåëûå è âåùåñòâåííûå ÷èñëà âïåðåìåøêó.

6.2 Сравнение кортежей и списков

Äâà êîðòåæà èëè ñïèñêà ìîæíî òàêæå ñðàâíèâàòü ìåæäó ñîáîé. Íàïðèìåð, âûðà-
æåíèå (1, 2, 3) < (2, 3, 4) áóäåòå èñòèííûì, à [1, 2, 3] < [1, 2] ëîæíûì. Ñðàâíåíèå
êîðòåæåé è ñïèñêîâ ïðîèñõîäèò ïîýëåìåíòíî, êàê è ñðàâíåíèå ñòðîê. Êàê òîëüêî íà
êàêèõ-òî ïîçèöèÿõ êîðòåæà èëè ñïèñêà âñòðåòèëèñü ðàçëè÷íûå ýëåìåíòû, òî âçàèìíûé
ïîðÿäîê êîðòåæåé òàêîé æå, êàê ó ýòèõ ýëåìåíòîâ. Åñëè æå ðàçëè÷èé íàéäåíî íå áûëî,
òî ìåíüøå òîò êîðòåæ, êîòîðûé êîðî÷å. Âñ¼ â òî÷íîñòè êàê ïðè ñðàâíåíèè ñòðîê.
Åñòåñòâåííî, ñðàâíèâàåìûå êîðòåæè èëè ñïèñêè äîëæíû ñîäåðæàòü íà ñîîòâåòñòâó-
þùèõ ïîçèöèÿõ ñðàâíèìûå ýëåìåíòû. Ïîïûòêà ñðàâíèòü êîðòåæ (1, 2) ñ êîðòåæåì
("Some text 42) ïðèâåäåò ê îøèáêå (à ñðàâíåíèå (1, 2) ñ (42, "Some text") ê îøèáêå
íå ïðèâåäåò). Îáû÷íî, âñ¼ æå, ñðàâíèâàþòñÿ êîðòåæè, ñîñòîÿùèå èç ýëåìåíòîâ îäèíà-
êîâîãî òèïà.
Ýòî ñâîéñòâî êîðòåæåé ìîæíî èñïîëüçîâàòü äëÿ ðåøåíèÿ ñëîæíûõ çàäà÷ íà ñîðòè-
ðîâêó. Íàïðèìåð, äëÿ êàæäîãî ÷åëîâåêà çàäàí åãî ðîñò è èìÿ, íåîáõîäèìî îïðåäåëèòü
óïîðÿäî÷èòü ñïèñîê ëþäåé ïî ðîñòó, à â ñëó÷àå îäèíàêîãî ðîñòà  â àëôàâèòíîì ïîðÿä-
êå. Ïðè ðåøåíèè ýòîé çàäà÷è äîñòàòî÷íî õðàíèòü îïèñàíèå êàæäîãî ÷åëîâåêà â âèäå
êîðòåæà, ãäå ïåðâûì ýëåìåíòîì áóäåò ðîñò, à âòîðûì  ôàìèëèÿ.
Ðàññìîòðèì ïðèìåð: äëÿ êàæäîãî ÷åëîâåêà çàäàí ðîñò è åãî èìÿ. Íåîáõîäèìî óïîðÿ-
äî÷èòü èõ ïî âîçðàñòàíèþ ðîñòà, à â ñëó÷àå îäèíàêîâîãî ðîñòà  â àëôàâèòíîì ïîðÿäêå.
n = i n t ( input ( ) )
peopleList = [ ]
f o r i in range ( n ) :
tempManData = input ( ) . s p l i t ( )
manData = ( i n t ( tempManData [ 0 ] ) , tempManData [ 1 ] )
p e o p l e L i s t . append ( manData )
peopleList . sort ()
f o r manData in p e o p l e L i s t :
print ( ' ' . j o i n (map( str , manData ) ) )
 ýòîì ïðèìåðå íàì ïîâåçëî è óäàëîñü ñîñòàâèòü êîðòåæ, êîòîðûé ñîäåðæèò ïàðà-
ìåòðû ñðàâíèâàåìûõ ëþäåé ðîâíî â íóæíîì ïîðÿäêå. ×àñòî âñòðå÷àþòñÿ áîëåå íåïðè-
ÿòíûå ñèòóàöèè. Ðàññìîòðèì òó æå çàäà÷ó, íî òåïåðü ëþäåé íóæíî óïîðÿäî÷èòü ïî
óáûâàíèþ ðîñòà, íî â ñëó÷àå îäèíàêîâîãî ðîñòà îíè ïî-ïðåæíåìó äîëæíû áûòü óïîðÿ-
äî÷åíû ïî àëôàâèòó. Ïðîñòîå èñïîëüçîâàíèå reversed=True íå ïðèâåäåò ê æåëàåìîìó
ðåçóëüòàòó: ëþäè ñ îäèíàêîâûì ðîñòîì áóäóò ñòîÿòü â íåïðàâèëüíîì ïîðÿäêå.
6.3. ПАРАМЕТР KEY В ФУНКЦИИ SORT 51

Çäåñü ìîæíî ïðèìåíèòü õèòðîñòü è ïðåâðàòèòü ðîñò êàæäîãî ÷åëîâåêà â îòðèöà-


òåëüíîå ÷èñëî, ìîäóëü êîòîðîãî áóäåò ðàâåí èñõîäíîìó ðîñòó. Ïîñëå ýòîãî ñïèñîê ìîæíî
ïðîñòî óïîðÿäî÷èòü ïî âîçðàñòàíèþ  ñàìûå âûñîêèå ëþäè áóäóò èìåòü íàèìåíüøèé
îòðèöàòåëüíûé ¾ðîñò¿, ïî êîòîðîìó ïðîèñõîäèò ñðàâíåíèå â ïåðâóþ î÷åðåäü. Ïåðåä
âûâîäîì íåîáõîäèìî ïðåâðàòèòü ðîñò îáðàòíî â ïîëîæèòåëüíîå ÷èñëî.
n = i n t ( input ( ) )
peopleList = [ ]
f o r i in range ( n ) :
tempManData = input ( ) . s p l i t ( )
manData = (− i n t ( tempManData [ 0 ] ) , tempManData [ 1 ] )
p e o p l e L i s t . append ( manData )
peopleList . sort ()
f o r badManData in p e o p l e L i s t :
manData = (−badManData [ 0 ] , badManData [ 1 ] )
print ( ' ' . j o i n (map( str , manData ) ) )

Ýòîò êîä ìàëîïîíÿòåí è ïëîõ.

6.3 Параметр key в функции sort

Äëÿ ðåàëèçàöèè íåñòàíäàðòíûõ ñîðòèðîâîê ëó÷øå íå óðîäîâàòü èñõîäíûå äàííûå,


à èñïîëüçîâàòü ïàðàìåòð key, ïåðåäàþùèéñÿ â ôóíêöèþ ñîðòèðîâêè.
Çíà÷åíèåì ýòîãî ïàðàìåòðà äîëæíà áûòü ôóíêöèÿ, êîòîðàÿ ïðèìåíÿåòñÿ ê êàæäîìó
ýëåìåíòó ñïèñêà è çàòåì ñðàâíåíèå ýëåìåíòîâ ïðîèñõîäèò ïî çíà÷åíèþ ýòîé ôóíêöèè
(îíî íàçûâàåòñÿ êëþ÷îì).
Ðàññìîòðèì òàêîé ïðèìåð: íåîáõîäèìî óïîðÿäî÷èòü ââåä¼ííûå ñòðîêè ïî äëèíå, à
â ñëó÷àå ðàâíîé äëèíû îñòàâèòü èõ â òîì ïîðÿäêå, êàê îíè øëè âî âõîäíîì ôàéëå.
Íàïðèìåð, äëÿ âõîäíûõ ñòðîê c, abb, b ïðàâèëüíûì îòâåòîì äîëæíî áûòü c, b,
abb (c èäåò ðàíüøå b, ò.ê. îíè èìåþò ðàâíóþ äëèíó, à c ñòîÿëî âî âõîäíûõ äàííûõ
ðàíüøå b).
Ê ñ÷àñòüþ, ñîðòèðîâêà, èñïîëüçóåìàÿ â Ïèòîíå îáëàäàåò ñâîéñòâîì óñòîé÷èâîñòè
(stable), ò.å. äëÿ ýëåìåíòîâ ñ ðàâíûì êëþ÷îì ñîõðàíÿåòñÿ èõ âçàèìíûé ïîðÿäîê.
Ðåøåíèå ýòîé çàäà÷è áóäåò âûãëÿäåòü ñëåäóþùèì îáðàçîì:
n = i n t ( input ( ) )
strings = [ ]
f o r i in range ( n ) :
s t r i n g s . append ( input ( ) )
print ( ' \n ' . j o i n ( sorted ( s t r i n g s , key=len ) ) )

 êà÷åñòâå åùå îäíîãî ïðèìåðà ðàññìîòðèì çàäà÷ó î ñîðòèðîâêå òî÷åê íà ïëîñ-


êîñòè, çàäàííûõ ïàðîé öåëûõ êîîðäèíàò 𝑥 è 𝑦 ïî íåóáûâàíèþ ðàññòîÿíèÿ îò íà÷àëà
êîîðäèíàò.  äàííîì ñëó÷àå â êà÷åñòâå ôóíêöèè äëÿ ãåíåðàöèè êëþ÷à, ïî êîòîðîìó
áóäóò ñðàâíèâàòüñÿ ýëåìåíòû, ìû íàïèøåì ñâîþ ôóíêöèþ, êîòîðàÿ áóäåò âîçâðàùàòü
êâàäðàò ðàññòîÿíèÿ îò òî÷êè äî íà÷àëà êîîðäèíàò. Êâàäðàò ðàññòîÿíèÿ ìû èñïîëüçó-
åì äëÿ òîãî, ÷òîáû îñòàâàòüñÿ â öåëûõ ÷èñëàõ è èçáàâèòñÿ îò íåîáõîäèìîñòè ñ÷èòàòü
êâàäðàòíûé êîðåíü (ìåäëåííî è íåòî÷íî):
52ЛЕКЦИЯ 6. СОРТИРОВКА, ЛЯМБДА-ФУНКЦИИ, ИМЕНОВАННЫЕ ПАРАМЕТРЫ

def d i s t ( p o i n t ) :
return p o i n t [ 0 ] ** 2 + p o i n t [ 1 ] ** 2

n = i n t ( input ( ) )
points = [ ]
f o r i in range ( n ) :
p o i n t = tuple (map( int , input ( ) . s p l i t ( ) ) )
p o i n t s . append ( p o i n t )
p o i n t s . s o r t ( key=d i s t )
f o r p o i n t in p o i n t s :
print ( ' ' . j o i n (map( str , p o i n t ) ) )
Çäåñü êàæäûé ýëåìåíò ñïèñêà  êîðòåæ èç äâóõ ÷èñåë. Èìåííî òàêîé ïàðàìåòð
ïðèíèìàåò íàøà ôóíêöèÿ. Âîçìîæíî, âû õîòåëè áû èñïîëüçîâàòü ôóíêöèþ hypot èç
áèáëèîòåêè math, ÷òîáû íå ïèñàòü ñâîþ ôóíêöèþ ïîäñ÷åòà êëþ÷à, îäíàêî ýòî íåâîç-
ìîæíî  îíà îæèäàåò íà âõîä äâà ÷èñëîâûõ ïàðàìåòðà, à íå êîðòåæ.

6.4 «Структуры» в Питоне

Äëÿ õðàíåíèÿ ñëîæíûõ çàïèñåé âî ìíîãèõ ÿçûêàõ åñòü ñïåöèàëüíûå òèïû äàííûõ,
òàêèå êàê struct â C++ èëè record â Ïàñêàëå.
Ïåðåìåííàÿ òèïà ñòðóêòóðà ñîäåðæèò â ñåáå íåñêîëüêî èìåíîâàííûõ ïîëåé. Íàïðè-
ìåð, âîçâðàùàÿñü ê çàäà÷å ñîðòèðîâêè ëþäåé ïî óáûâàíèþ ðîñòà, íàì áûëî áû óäîáíî
õðàíèòü îïèñàíèå êàæäîãî ÷åëîâåêà â âèäå ñòðóêòóðû ñ äâóìÿ ïîëÿìè: ðîñòîì è èìå-
íåì.
 ÷èñòîì âèäå òèïà äàííûõ ¾ñòðóêòóðà¿ â ñòàíäàðòå ÿçûêà Ïèòîí íåò. Åñòü íåñêîëü-
êî ñïîñîáîâ ðåàëèçàöèè àíàëîãà ñòðóêòóð: namedtuple èç áèáëèîòåêè collections, èñïîëü-
çîâàíèå ñëîâàðåé (áóäåò ðàññìîòðåíî â ñëåäóþùèõ ëåêöèÿõ) èëè èñïîëüçîâàíèå êëàññîâ
â êà÷åñòâå ñòðóêòóð. Ðàññìîòðèì íà ïðèìåðå ïîñëåäíèé ñïîñîá.
Íàïîìíèì óñëîâèå çàäà÷è: ëþäåé íóæíî óïîðÿäî÷èòü ïî óáûâàíèþ ðîñòà, íî â ñëó-
÷àå îäèíàêîâîãî ðîñòà îíè äîëæíû áûòü óïîðÿäî÷åíû ïî ôàìèëèè. Ðåøåíèå ñ èñïîëü-
çîâàíèåì êëàññîâ â êà÷åñòâå ñòðóêòóð áóäåò âûãëÿäåòü òàê:
c l a s s Man :
height = 0
name = ' '

def manKey (man ) :


return (−man . h e i g h t , man . name )

n = i n t ( input ( ) )
peopleList = [ ]
f o r i in range ( n ) :
tempManData = input ( ) . s p l i t ( )
man = Man( )
man . h e i g h t = i n t ( tempManData [ 0 ] )
man . name = tempManData [ 1 ]
p e o p l e L i s t . append (man)
6.5. ЛЯМБДА-ФУНКЦИИ 53

p e o p l e L i s t . s o r t ( key=manKey )
f o r man in p e o p l e L i s t :
print (man . h e i g h t , man . name )
Äëÿ òîãî ÷òîáû ïîëüçîâàòüñÿ êëàññàìè êàê ñòðóêòóðàìè ìû ñîçäàåì íîâûé òèï
äàííûõ Man.  îïèñàíèè êëàññà ìû ïåðå÷èñëÿåì èìåíà âñåõ ïîëåé è èõ çíà÷åíèÿ ïî-
óìîë÷àíèþ.
 äàëüíåéøåì ìû ìîæåì ñîçäàâàòü îáúåêòû êëàññà Man (ýòî äåëàåòñÿ ñòðîêîé man
= Man()), êîòîðûå ñíà÷àëà ïðîèíèöèàëèçèðóþò ñâîè ïîëÿ çíà÷åíèÿìè ïî óìîë÷àíèþ.
Äîñòóï ê ïîëÿì êëàññà îñóùåñòâëÿåòñÿ ÷åðåç òî÷êó.
Ôóíêöèÿ ñðàâíåíèÿ ïðèíèìàåò îáúåêò êëàññà è ãåíåðèðóåò êëþ÷, ïî êîòîðîìó ýòè
îáúåêòû áóäóò ñðàâíèâàòüñÿ ïðè ñîðòèðîâêå.
Èñïîëüçîâàíèå ñòðóêòóð äëÿ îïèñàíèÿ ñëîæíûõ îáúåêòîâ íàìíîãî ïðåäïî÷òèòåëü-
íåå, ÷åì èñïîëüçîâàíèå êîðòåæåé. Ïðè êîëè÷åñòâå ïàðàìåòðîâ áîëüøå äâóõ èñïîëüçîâà-
íèå êîðòåæåé çàïóòûâàåò ÷èòàòåëÿ è ïèñàòåëÿ êîäà, ò.ê. ñîâåðøåííî íåâîçìîæíî ïîíÿòü
÷òî õðàíèòñÿ â badNamedTuple[13] è ëåãêî ïîíÿòü ÷òî õðàíèòñÿ â goodNamedStruct.goodNamedField.

6.5 Лямбда-функции

 ðÿäå ñëó÷àåâ ôóíêöèè, èñïîëüçóåìûå äëÿ ïîëó÷åíèÿ êëþ÷à ñîðòèðîâêè, òàê ïðî-
ñòû, ÷òî íå õî÷åòñÿ îôîðìëÿòü èõ ñòàíäàðòíûì îáðàçîì, à õî÷åòñÿ íàïèñàòü èõ ïðÿìî
íà ìåñòå è äàæå íå äàâàòü èì èìåíè.
Ýòî ìîæíî îñóùåñòâèòü ñ ïîìîùüþ ëÿìáäà-ôóíêöèé, êîòîðûå ìîãóò çàìåíèòü ñîáîé
ôóíêöèè, ñîäåðæàùèå â ñâîåì òåëå òîëüêî îïåðàòîð return. Çàïèñü ëÿìáäà-ôóíêöèè,
âîçâîäÿùåé ÷èñëî â êâàäðàò ìîæåò âûãëÿäåòü òàê:
lambda x : x ** 2
×òî ýêâèâàëåíòíî ïðèâû÷íîé çàïèñè ôóíêöèè:
def s q r ( x ) :
return x ** 2
Îòëè÷èå ëÿìáäà-ôóíêöèè òàêæå çàêëþ÷àåòñÿ â òîì, ÷òî ó íå¼ íåò èìåíè è, ñëå-
äîâàòåëüíî, âûçîâ å¼ ïî èìåíè íåâîçìîæåí. Ïîêà åäèíñòâåííûì ïðèìåíåíèåì ëÿìáäà-
ôóíêöèé äëÿ íàñ ìîæåò ñëóæèòü èõ ïåðåäà÷à â êà÷åñòâå ïàðàìåòðà â òàêèå ôóíêöèè
êàê sort èëè map. Íàïðèìåð, ñ ïîìîùüþ ëÿìáäà-ôóíêöèè ìû ìîæåì âûâåñòè ñïèñîê
êâàäðàòîâ âñåõ ÷èñåë îò 1 äî 100 âñåãî â îäíó ñòðîêó:
print ( ' ' . j o i n (map( lambda x : s t r ( x * * 2 ) , range ( 1 , 1 0 1 ) ) ) )
 ýòîé ïðîãðàììå ëÿìáäà ôóíêöèÿ ïðèíèìàåò â êà÷åñòâå ïàðàìåòðà ÷èñëî, à âîç-
âðàùàåò ñòðîêîâîå ïðåäñòàâëåíèå åãî êâàäðàòà.
Âåðíåìñÿ ê çàäà÷å ñîðòèðîâêè òî÷åê ïî óäàëåííîñòè îò íà÷àëà êîîðäèíàò. Ýòà çà-
äà÷à òàêæå ìîæåò áûòü ðåøåíà ñ èñïîëüçîâàíèåì ëÿìáäà-ôóíêöèè:
n = i n t ( input ( ) )
points = [ ]
f o r i in range ( n ) :
p o i n t = tuple (map( int , input ( ) . s p l i t ( ) ) )
p o i n t s . append ( p o i n t )
54ЛЕКЦИЯ 6. СОРТИРОВКА, ЛЯМБДА-ФУНКЦИИ, ИМЕНОВАННЫЕ ПАРАМЕТРЫ

p o i n t s . s o r t ( key=lambda p o i n t : p o i n t [ 0 ] * * 2 + p o i n t [ 1 ] * * 2 )
f o r p o i n t in p o i n t s :
print ( ' ' . j o i n (map( str , p o i n t ) ) )

Ëÿìáäà-ôóíêöèÿ ìîæåò ïðèíèìàòü íåñêîëüêî ïàðàìåòðîâ (òîãäà ïîñëå ñëîâà lambda


íóæíî çàïèñàòü èõ èìåíà ÷åðåç çàïÿòóþ), îäíàêî ïðè èñïîëüçîâàíèè èõ â sort èëè map
ïàðàìåòð äîëæåí áûòü âñåãäà îäèí.
 ÿçûêå Ïèòîí ôóíêöèÿ òàêæå ÿâëÿåòñÿ îáúåêòîì è ìû ìîæåì ñîçäàòü ññûëêó íà
îáúåêò òèïà ôóíêöèÿ. Íàïðèìåð, äâå çàïèñè ôóíêöèè âîçâåäåíèÿ â êâàäðàò ýêâèâà-
ëåíòíû:
def t r a d i t i o n a l S q r ( x ) :
return x ** 2

lambdaSqr = lambda x : x ** 2
print ( t r a d i t i o n a l S q r ( 3 ) )
print ( lambdaSqr ( 3 ) )

Òàêîé ïîäõîä ïîçâîëÿåò ïåðåèñïîëüçîâàòü ëÿìáäà-ôóíêöèè, íî â ïîäàâëÿþùåì áîëü-


øèíñòâå ñëó÷àåâ ñòîèò ïîëüçîâàòüñÿ ñòàíäàðòíûì îáúÿâëåíèåì ôóíêöèè  ýòî óïðî-
ùàåò ÷òåíèå è îòëàäêó ïðîãðàììû.

6.6 Именованные параметры и неопределенное число


параметров

Ìû óæå ìíîãî ðàç ïîëüçîâàëèñü ôóíêöèÿìè, êîòîðûå ìîãóò ïðèíèìàòü (èëè íå


ïðèíèìàòü) èìåíîâàííûå ïàðàìåòðû. Íàïðèìåð, ýòî íåîáÿçàòåëüíûå èìåíîâàííûå èëè
íåèìåíîâàííûå ïàðàìåòðû sep è end äëÿ ôóíêöèè print èëè ïàðàìåòð key äëÿ ìåòîäà
sort è ôóíêöèè sorted.
Ñåé÷àñ ìû íàó÷èìñÿ ñîçäàâàòü ôóíêöèè, êîòîðûå ïðèíèìàþò èìåíîâàííûå ïàðà-
ìåòðû. Íàïðèìåð, íàïèøåì ôóíêöèþ, ïå÷àòàþùóþ ÷òî óãîäíî èòåðèðóåìîå, ñîñòîÿùåå
èç ÷åãî óãîäíî ïðèâîäèìîãî ê ñòðîêå, ñ èìåíîâàííûì ïàðàìåòðîì sep, ïî-óìîë÷àíèþ
ðàâíûì ïðîáåëó:
def p r i n t L i s t ( myList , s e p= ' ' ) :
print ( s e p . j o i n (map( str , myList ) ) )

printList ([1 , 2 , 3])


p r i n t L i s t ( [ 3 , 2 , 1 ] , s e p= ' \n ' )
Èìåíîâàííûé ïàðàìåòð â îáúÿâëåíèè ôóíêöèè äîëæåí èäòè ïîñëå îñíîâíûõ ïàðà-
ìåòðîâ.  ñïèñêå ïàðàìåòðîâ çàïèñûâàåòñÿ åãî èìÿ, à çàòåì çíà÷åíèå ïî-óìîë÷àíèþ
(ò.å. òî çíà÷åíèå, êîòîðîå áóäåò ïîäñòàâëÿòüñÿ íà ìåñòî ñîîòâåòñòâóþùåãî ïàðàìåòðà,
åñëè îí íå áûë ïåðåäàí ïðè âûçîâå ôóíêöèè).
Òàêæå ìû ïîëüçîâàëèñü ôóíêöèÿìè, êîòîðûå óìåþò ïðèíèìàòü ïðîèçâîëüíîå êî-
ëè÷åñòâî ïàðàìåòðîâ. Íàïðèìåð, â ôóíêöèþ print ìîæíî ïåðåäàòü ëþáîå êîëè÷åñòâî
ïàðàìåòðîâ. Ìîæíî íàïèñàòü ñîáñòâåííûå ôóíêöèè, êîòîðûå áóäóò ïðèíèìàòü ïðî-
èçâîëüíîå êîëè÷åñòâî ïàðàìåòðîâ. Ïðè ýòîì ïàðàìåòðû ôóíêöèè áóäóò óïàêîâàíû â
6.7. ЧТЕНИЕ ДО КОНЦА ВВОДА 55

ñïèñîê. Íàïðèìåð, ôóíêöèÿ ïîäñ÷åòà ñóììû âñåõ ïåðåäàííûõ ïàðàìåòðîâ ìîæåò âû-
ãëÿäåòü òàê:
def mySum( * a r g s ) :
nowSum = 0
f o r now in a r g s :
nowSum += now
return nowSum

print (mySum( 1 , 2 ) )
print (mySum( 1 , 2 , 3 , 4 ) )

Ôóíêöèÿ ïðèíèìàåò îäèí ïàðàìåòð, ïåðåä êîòîðûì íàïèñàíà çâåçäî÷êà  ýòî ïðè-
çíàê òîãî, ÷òî àðãóìåíòû áóäóò óïàêîâàíû â ñïèñîê.
Ìîæíî ïèñàòü ôóíêöèè, êîòîðûå ïðèíèìàþò íå ìåíåå îïðåäåëåííîãî êîëè÷åñòâà
ïàðàìåòðîâ. Íàïðèìåð, ìû ìîæåì íàïèñàòü ôóíêöèþ ïîèñêà ìèíèìóìà ñðåäè íåîïðå-
äåëåííîãî ÷èñëà àðãóìåíòîâ, íî â íåå äîëæíî áûòü ïåðåäàíî íå ìåíåå îäíîãî àðãóìåíòà:
def myMin( f i r s t , * o t h e r s ) :
nowMin = f i r s t
f o r now in o t h e r s :
i f now < nowMin :
nowMin = now
return nowMin

print (myMin ( 1 ) )
print (myMin ( 3 , 1 , 2 ) )

Ïàðàìåòð ñî çâåçäî÷êîé âñåãäà äîëæåí áûòü ïîñëåäíèì, çà èñêëþ÷åíèåì ñèòóàöèè,


êîãäà â ôóíêöèè òàêæå îïðåäåëåíû èìåíîâàííûå ïàðàìåòðû.

6.7 Чтение до конца ввода

Âî ìíîãèõ çàäà÷àõ çàðàíåå íåèçâåñòíî, ñêîëüêî äàííûõ íàì ïðåäñòîèò ñ÷èòàòü. Îñî-
áåííî ÿðêèé ïðèìåð  ýòî îáðàáîòêà òåêñòà, êîãäà ìû çàðàíåå íå çíàåì, ñêîëüêî ñòðîê
íàì áóäåò ââåäåíî.
Íàèáîëåå óäîáíî ðàáîòàòü ñ òàêèìè äàííûìè íå ïîëüçóÿñü ôóíêöèåé input, èñïîëü-
çóÿ ìåòîäû ÷òåíèÿ ôàéëà (èëè ââîäà ñ êîíñîëè) öåëèêîì èëè ïîñòðî÷íî.
Ðàñììîòðèì ïðîñòîé ïðèìåð: ñ÷èòàòü âñå ñòðîêè ôàéëà input.txt è âûâåñòè êàæäóþ
ñòðîêó ðàçâåðíóòîé â ôàéë output.txt:
i n F i l e = open ( ' i n p u t . t x t ' , ' r ' , e n c o d i n g= ' u t f 8 ' )
o u t F i l e = open ( ' output . t x t ' , 'w ' , e n c o d i n g= ' u t f 8 ' )
lines = inFile . readlines ()
f o r l i n e in l i n e s :
print ( l i n e [ − 2 : : − 1 ] , f i l e =o u t F i l e )
inFile . close ()
outFile . close ()
56ЛЕКЦИЯ 6. СОРТИРОВКА, ЛЯМБДА-ФУНКЦИИ, ИМЕНОВАННЫЕ ПАРАМЕТРЫ

Äëÿ îòêðûòèÿ ôàéëà èñïîëüçóåòñÿ ôóíêöèÿ open, ïðèíèìàþùàÿ äâà ïàðàìåòðà:


èìÿ ôàéëà è ðåæèì îòêðûòèÿ (r äëÿ ÷òåíèÿ è w äëÿ çàïèñè), à òàêæå èìåíîâàííûé
ïàðàìåòð encoding (çíà÷åíèå êîäèðîâêè utf8 ïîäõîäèò äëÿ áîëüøèíñòâà ñîâðåìåííûõ
òåêñòîâûõ ôàéëîâ). Ýòà ôóíêöèÿ âîçâðàùàåò ññûëêó íà îáúåêò òèïà ôàéë.
Äëÿ ÷òåíèÿ âñåõ ñòðîê èç ôàéëà èñïîëüçóåòñÿ ìåòîä readlines, êîòîðûé âîçâðàùàåò
ñïèñîê âñåõ ñòðîê (â ñìûñëå lines) ôàéëà. Îáðàòèòå âíèìàíèå, ÷òî ñòðîêè ïîïàäàþò â
ñïèñîê âìåñòå ñ ñèìâîëîì ïåðåâîäà ñòðîêè, â íàøåé ïðîãðàììå ýòî ó÷èòûâàåòñÿ ïðè
ñîçäàíèè ñðåçà (ýòîò ñèìâîë ïîñëåäíèé â ñòðîêå). Â òåñòèðóþùåé ñèñòåìå âñå âõîäíûå
ôàéëû èìåþò ïåðåíîñ ñòðîêè ïîñëå ïîñëåäíåé ñòðîêè, â ðåàëüíîé æèçíè ýòî ìîæåò
îêàçàòüñÿ íå òàê è òîãäà ïðîãðàììà áóäåò ðàáîòàòü íåâåðíî.
Äëÿ ïå÷àòè â ôàéë ìû ïîëüçóåìñÿ ñòàíäàðòíîé ôóíêöèåé print, êîòîðîé ïåðåäàåòñÿ
èìåíîâàííûé ïàðàìåòð le ñ óêàçàíèåì, â êàêîé ôàéë ïå÷àòàòü.
Ïîñëå îêîí÷àíèÿ ðàáîòû ñ ôàéëàìè íóæíî âûçâàòü äëÿ íèõ ìåòîäû close.
 ýòîé çàäà÷å, íà ñàìîì äåëå, ìîæíî áûëî îáîéòèñü áåç çàïîìèíàíèÿ âñåãî ôàéëà â
ïàìÿòè (÷òî îñîáåííî àêòóàëüíî äëÿ áîëüøèõ ôàéëîâ). Ðåøåíèå áåç çàïîìèíàíèÿ âñåãî
ôàéëà ìîæíî áûëî ðåàëèçîâàòü òàê:
i n F i l e = open ( ' i n p u t . t x t ' , ' r ' , e n c o d i n g= ' u t f 8 ' )
o u t F i l e = open ( ' output . t x t ' , 'w ' , e n c o d i n g= ' u t f 8 ' )
f o r l i n e in i n F i l e :
print ( l i n e [ − 2 : : − 1 ] , f i l e =o u t F i l e )
inFile . close ()
outFile . close ()
Ïåðåìåííûå òèïà ôàéë ÿâëÿþòñÿ iterable è óìåþò âîçâðàùàòü î÷åðåäíóþ ñòðîêó èç
ôàéëà, íå õðàíÿ åãî öåëèêîì â ïàìÿòè.
Òàêæå ñóùåñòâóåò ìåòîä read, êîòîðûé ïîçâîëÿåò ñ÷èòàòü âñå ñîäåðæèìîå ôàéëà â
îäíó ñòðîêîâóþ ïåðåìåííóþ (ïðè ýòîì ñîäåðæàùóþ â ñåáå ïåðåâîäû ñòðîêè ∖𝑛).
 ïðèíöèïå, ÷èòàòü äî êîíöà ââîäà ìîæíî è èç êîíñîëè. Äëÿ ýòîãî íóæíî ïîäêëþ-
÷èòü áèáëèîòåêó sys è èñïîëüçîâàòü îïðåäåëåííûé â íåé ôàéëîâûé äåñêðèïòîð stdin â
êà÷åñòâå ôàéëà. Ââåñòè ïðèçíàê êîíöà ôàéëà â êîíñîëè ìîæíî íàæàâ Ctrl+Z â Windows
èëè Ctrl+D â Unix-ñèñòåìàõ.

6.8 Сортировка подсчетом

 ðÿäå çàäà÷ âîçìîæíûå çíà÷åíèÿ â ñîðòèðóåìîì ñïèñêå ñèëüíî îãðàíè÷åíû. Íàïðè-


ìåð, åñëè ìû õîòèì îòñîðòèðîâàòü îöåíêè îò 0 äî 10, òî ìîæåò îêàçàòüñÿ ýôôåêòèâíåå
ïîäñ÷èòàòü, ñêîëüêî ðàç âñòðå÷àëàñü êàæäàÿ èç îöåíîê è çàòåì âûâåñòè å¼ ñòîëüêî ðàç.
Ðåàëèçàöèÿ òàêîãî ïîäõîäà î÷åíü ïðîñòà:
marks = map( int , input ( ) . s p l i t ( ) )
cntMarks = [ 0 ] * 11
f o r mark in marks :
cntMarks [ mark ] += 1
f o r nowMark in range ( 1 1 ) :
print ( ( s t r ( nowMark ) + ' ' ) * cntMarks [ nowMark ] , end= ' ' )
 ýòîé ïðîãðàììå ìû ñîçäàëè ñïèñîê, ñîñòîÿùèé èç 11 íóëåé â îäíó ñòðîêó. Ýòîò
ïðè¼ì ÷àñòî ïðèãîæäàåòñÿ è â äðóãèõ çàäà÷àõ.
6.9. СВЯЗЬ ЗАДАЧ ПОИСКА И СОРТИРОВКИ 57

6.9 Связь задач поиска и сортировки

Âî ìíîãèõ çàäà÷àõ ëèíåéíîãî ïîèñêà (íàïðèìåð, ïîèñê ìèíèìàëüíîãî ýëåìåíòà) âîç-


íèêàåò ñîáëàçí âîñïîëüçîâàòüñÿ ñîðòèðîâêîé.
Ñ ýòèì ñîáëàçíîì ñëåäóåò áîðîòüñÿ, ò.ê. ñëîæíîñòü ñîðòèðîâêè â ÿçûêå Ïèòîí ñî-
ñòàâëÿåò 𝑂(𝑁 𝑙𝑜𝑔𝑁 ), ò.å. äëÿ ñîðòèðîâêè ñïèñêà èç 𝑁 ýëåìåíòîâ íóæíî ñîâåðøèòü ïî-
ðÿäêà 𝑁 𝑙𝑜𝑔𝑁 äåéñòâèé.
Ïðè ýòîì àëãîðèòìû ëèíåéíîãî ïîèñêà ðàáîòàþò çà 𝑂(𝑁 ), ÷òî çàìåòíî àñèìïòîòè-
÷åñêè áûñòðåå, ÷åì ñîðòèðîâêà. Ïîýòîìó â çàäà÷àõ ëèíåéíîãî ïîèñêà (äàæå äëÿ ïîèñêà
òðåòüåãî ïî âåëè÷èíå ýëåìåíòà) ñëåäóåò ðåàëèçîâûâàòü ëèíåéíûé ïîèñê, à íå ïîëüçî-
âàòüñÿ ñîðòèðîâêîé.
Ïî èðîíèè ñóäüáû, ñîðòèðîâêà â èíòåðïðåòàòîðå CPython ìîæåò îêàçàòüñÿ áûñòðåå
ðóêîïèñíîãî ëèíåéíîãî ïîèñêà (èç-çà òîãî, ÷òî îíà ðåàëèçîâàíî ìàêñèìàëüíî ýôôåêòèâ-
íî è íà ÿçûêå Ñè). Íî ýòî äîñàäíîå íåäîðàçóìåíèå íå äîëæíî ïîáîðîòü â âàñ æåëàíèå
ïèñàòü ëèíåéíûé ïîèñê ðóêàìè.
58ЛЕКЦИЯ 6. СОРТИРОВКА, ЛЯМБДА-ФУНКЦИИ, ИМЕНОВАННЫЕ ПАРАМЕТРЫ
Лекция 7

Множества, словари, полезные методы

для строк

7.1 Множества и хеш-функции

 ÿçûêå Ïèòîí ìíîæåñòâà èìåþò òîò æå ñìûñë, ÷òî è â ìàòåìàòèêå: íàáîð îáú-
åêòîâ áåç îïðåäåëåííîãî ïîðÿäêà. Â ìíîæåñòâî ìîæíî äîáàâëÿòü è óäàëÿòü îáúåêòû,
ïðîâåðÿòü ïðèíàäëåæíîñòü îáúåêòó ìíîæåñòâà è ïåðåáèðàòü âñå îáúåêòû ìíîæåñòâà.
Òàêæå íàä ìíîæåñòâàìè ìîæíî ñîâåðøàòü ãðóïïîâûå îïåðàöèè, íàïðèìåð, ïåðåñå-
êàòü è îáúåäèíÿòü äâà ìíîæåñòâà.
Ïðîâåðêà ïðèíàäëåæíîñòè ýëåìåíòà ìíîæåñòâó, à òàêæå îïåðàöèè óäàëåíèÿ è äî-
áàâëåíèÿ ýëåìåíòîâ, îñóùåñòâëÿþòñÿ çà 𝑂(1) (åñëè áû ìû õðàíèëè ýëåìåíòû â ñïèñêå è
õîòåëè áû ïðîâåðèòü ïðèíàäëåæíîñòü ýëåìåíòà ñïèñêó, òî íàì ïîòðåáîâàëîñü áû 𝑂(𝑁 )
îïåðàöèé, ãäå 𝑁  äëèíà ñïèñêà).
Òàêàÿ ñêîðîñòü äîñòèãàåòñÿ èñïîëüçîâàíèåì õåø-òàáëèö. Õåø-òàáëèöà  ýòî ìàñ-
ñèâ äîñòàòî÷íî áîëüøîãî ðàçìåðà (íàçîâåì ýòîò ðàçìåð 𝐾 ). Êàæäîìó íåèçìåíÿåìîìó
îáúåêòó ìîæíî ñîïîñòàâèòü ïî íåêîòîðîìó ïðàâèëó ÷èñëî 𝑀 îò 0 äî 𝐾 è ïîìåñòèòü
ýòîò îáúåêò â ÿ÷åéêó ñïèñêà ñ èíäåêñîì 𝑀 . Íàïðèìåð, äëÿ öåëûõ ÷èñåë òàêèì ïðàâè-
ëîì ñîïîñòàâëåíèÿ ìîæåò áûòü ïðîñòî ïîäñ÷åò îñòàòêà îò äåëåíèÿ öåëîãî ÷èñëà íà 𝐾 .
Îïåðàöèþ âçÿòèÿ îñòàòêà áóäåò íàøåé õåø-ôóíêöèåé.
Òåïåðü åñëè íàì íóæíî ïðîâåðèòü, ïðèíàäëåæèò ëè íåêîòîðîå ÷èñëî ìíîæåñòâó,
ìû ïðîñòî ñ÷èòàåì õåø-ôóíêöèþ îò íåãî è ïðîâåðÿåì, ëåæèò ëè â ÿ÷åéêå ñ èíäåêñîì,
ðàâíûì ðåçóëüòàòó âû÷èñëåíèÿ õåø-ôóíêöèè íàø îáúåêò èëè íåò. Äëÿ äðóãèõ òèïîâ
äàííûõ ìîæíî ïðèìåíèòü òàêîé ïîäõîä: ëþáîé îáúåêò òàê èëè èíà÷å ÿâëÿåòñÿ ïîñëå-
äîâàòåëüíîñòüþ áàéò. Áóäåì èíòåðïðåòèðîâàòü ýòó ïîñëåäîâàòåëüíîñòü áàéò êàê ÷èñëî
è ïîäñ÷èòàåì õåø-ôóíêöèþ äëÿ ýòîãî ÷èñëà.
Åñòåñòâåííî, ìîæåò îêàçàòüñÿ, ÷òî íåñêîëüêî îáúåêòîâ äàþò îäèí è òîò æå õåø
(îòîáðàæåíèå ìåæäó îãðîìíûì ìíîæåñòâîì ðàçëè÷íûõ îáúåêòîâ è ñêðîìíûì ðàçìå-
ðîì ìíîæåñòâà äîïóñòèìûõ õåøåé íå ìîæåò áûòü áèåêòèâíûì). Òàêèå ïðîáëåìû ìîæíî
ðàçðåøèòü, íå óõóäøàÿ àñèìïòîòè÷åñêóþ ñëîæíîñòü. Ïîäðîáíåå òàêèå ìåòîäû âû áó-
äåòå èçó÷àòü íà êóðñå àëãîðèòìîâ.
Ïîñêîëüêó, íàïðèìåð, ÷èñëà, ìîãóò áûòü äîñòàòî÷íî äëèííûìè, òî îïåðàöèÿ ïîäñ÷å-
òà õåø-ôóíêöèè ïðè êàæäîé îïåðàöèè ñ ýòèì îáúåêòîâ â ìíîæåñòâå ìîæåò áûòü î÷åíü
ìåäëåííîé. Ïîýòîìó êàæäûé íåèçìåíÿåìûé îáúåêò â Ïèòîíå èìååò çàðàíåå íàñ÷èòàí-
íûé õåø, êîòîðûé ïîäñ÷èòûâàåòñÿ îäèí ðàç ïðè åãî ñîçäàíèè. Êñòàòè, ñ ïîìîùüþ ýòèõ

59
60 ЛЕКЦИЯ 7. МНОЖЕСТВА, СЛОВАРИ, ПОЛЕЗНЫЕ МЕТОДЫ ДЛЯ СТРОК

æå õåøåé ìîæíî ïîíèìàòü, åñòü ëè óæå îáúåêò â ïàìÿòè è íå ñîçäàâàòü íîâûõ îáúåêòîâ,
à ïðîñòî ïîäâåøèâàòü åùå îäíó ññûëêó íà óæå ñóùåñòâóþùèé îáúåêò.
Èçìåíÿåìûå òèïû, òàêèå êàê ñïèñîê, íå èìåþò çàðàíåå íàñ÷èòàííûõ õåøåé. Èçìå-
íåíèå âñåãî îäíîãî ýëåìåíòà â ñïèñêå ïðèâåëî áû ê ïîëíîìó ïåðåñ÷åòó õåøà äëÿ âñåãî
ñïèñêà, ÷òî êàòàñòðîôè÷åñêè çàìåäëèëî áû ðàáîòó ñî ñïèñêàìè. Ïîýòîìó ó èçìåíÿåìûõ
îáúåêòîâ íåò õåøà è îíè íå ìîãóò áûòü äîáàâëåíû â ìíîæåñòâî.
Ñàìî ìíîæåñòâî òàêæå ÿâëÿåòñÿ èçìåíÿåìûì îáúåêòîì è íå ìîæåò áûòü, íàïðèìåð,
ýëåìåíòîì äðóãîãî ìíîæåñòâà.
Ñóùåñòâóþò òàêæå íåèçìåíÿåìûå ìíîæåñòâà, êîòîðûå ñîçäàþòñÿ ñ ïîìîùüþ ôóíê-
öèè frozenset.

7.2 Создание множеств

Ìíîæåñòâî â òåëå ïðîãðàììû ìîæåò áûòü ñîçäàíî ñ ïîìîùüþ çàïèñè ýëåìåíòîâ


÷åðåç çàïÿòóþ â ôèãóðíûõ ñêîáêàõ:
mySet = { 3 , 1 , 2}
print ( mySet )
Âûâîä ñ ïîìîùüþ print îñóùåñòâëÿåòñÿ â òîì æå ôîðìàòå. Ïîðÿäîê ýëåìåíòîâ â
ìíîæåñòâå ìîæåò áûòü ñëó÷àéíûì, ò.ê. õåø ôóíêöèÿ íå ãàðàíòèðóåò, ÷òî åñëè 𝐴 > 𝐵 ,
òî ℎ(𝐴) > ℎ(𝐵).
Åñëè ïðè çàäàíèè ìíîæåñòâà ïðèñóòñòâîâàëî íåñêîëüêî îäèíàêîâûõ ýëåìåíòîâ, òî
îíè ïîïàäóò â ìíîæåñòâî â åäèíñòâåííîì ýêçåìïëÿðå:
f i r s t S e t = { 1 , 2 , 1 , 3}
s e c o n d S e t = { 3 , 2 , 1}
print ( f i r s t S e t == s e c o n d S e t )
Ýòà ïðîãðàììû âûâåäåò True (ìíîæåñòâà ìîæíî ñðàâíèâàòü íà ðàâåíñòâî).
Òàêæå ìíîæåñòâà ìîæíî ñîçäàâàòü ñ ïîìîùüþ ôóíêöèè set, êîòîðàÿ ìîæåò ïðèíè-
ìàòü â êà÷åñòâå ïàðàìåòðà ÷òî óãîäíî èòåðèðóåìîå:
setFromList = set ( [ 1 , 2 , 3 ] )
print ( s e t F r o m L i s t )
setFromTuple = s e t ( ( 4 , 5 , 6 ) )
print ( setFromTuple )
setFromStr = s e t ( " l o l " )
print ( setFromStr )
setFromRange = s e t ( range ( 2 , 2 2 , 3 ) )
print ( setFromRange )
setFromMap = s e t (map( abs , ( 1 , 2 , 3 , − 2, − 4)))
print ( setFromMap )
setFromSet = s e t ( { 1 , 2 , 3 } )
print ( setFromSet )
Âûâîä ýòîé ïðîãðàììû òàêîé:

{1, 2, 3}
{4, 5, 6}
7.3. РАБОТА С ЭЛЕМЕНТАМИ МНОЖЕСТВ 61

{’l’, ’o’}
{2, 5, 8, 11, 14, 17, 20}
{1, 2, 3, 4}
{1, 2, 3}

Ìíîæåñòâî òàêæå ÿâëÿåòñÿ èòåðèðóåìûì îáúåêòîì (åùå ðàç: îáúåêòû èäóò â ¾ñëó-
÷àéíîì¿ ïîðÿäêå, íå ïî âîçðàñòàíèþ!).
Ìíîæåñòâî ìîæåò ñîäåðæàòü â ñåáå îáúåêòû ðàçíûõ òèïîâ:
mixedSet = { 1 , 3 . 1 4 , ( 1 , 2 , 3 ) , " i have no i d e a why i 'm h e r e " }
print ( mixedSet )
Ïî àíàëîãèè ñî ñòðîêàìè, ñïèñêàìè è êîðòåæàìè, êîëè÷åñòâî ýëåìåíòîâ â ìíîæåñòâå
ìîæíî óçíàòü ñ ïîìîùüþ ôóíêöèè len.
Èç ìíîæåñòâà ìîæíî ñäåëàòü ñïèñîê èëè êîðòåæ ñ ïîìîùüþ ôóíêöèé list è tuple ñî-
îòâåòñòâåííî. Ïðèìåíåíèå ôóíêöèè str ê ìíîæåñòâó äàñò íàì òåêñòîâîå ïðåäñòàâëåíèå
(ýëåìåíòû â ôèãóðíûõ ñêîáêàõ, ðàçäåëåííûå çàïÿòûìè).
×àñòîé îïåðàöèåé ÿâëÿåòñÿ âûâîä óïîðÿäî÷åííûõ ýëåìåíòîâ ìíîæåñòâà. Ýòî ìîæíî
ñäåëàòü, ïðèìåíèâ ôóíêöèþ sorted ñðàçó ê ìíîæåñòâó (âåäü îíî èòåðèðóåìî):
mySet = { ' abba ' , ' a ' , ' l o n g s t r i n g ' }
print ( ' , ' . j o i n ( mySet ) )
print ( ' , ' . j o i n ( sorted ( mySet ) ) )
Âûâîä ýòîé ïðîãðàììû áóäåò:

long string, a, abba


a, abba, long string

Ê ìíîæåñòâó ìîæíî ïðèìåíÿòü ôóíêöèþ map.

7.3 Работа с элементами множеств

×òîáû ñîçäàòü ïóñòîå ìíîæåñòâî íóæíî íàïèñàòü:


emptySet = s e t ( )
Ïèñàòü ïóñòûå ôèãóðíûå ñêîáêè íåëüçÿ (âî âòîðîé ÷àñòè ëåêöèè óçíàåòå ïî÷åìó).
Äîáàâëåíèå ýëåìåíòà â ìíîæåñòâî îñóùåñòâëÿåòñÿ ñ ïîìîùüþ ìåòîäà add, åñëè ýëå-
ìåíò óæå áûë â ìíîæåñòâå, òî îíî íå èçìåíèòñÿ.
Ïåðåáðàòü ýëåìåíòû ìíîæåñòâà ìîæíî ñ ïîìîùüþ for (for óìååò õîäèòü ïî ëþáûì
èòåðèðóåìûì îáúåêòàì):
mySet = { 1 , ' 2 ' , 2 , ' 1 ' }
f o r elem in mySet :
print ( elem , end= ' ' )
Âûâîä òàêîé ïðîãðàììû áóäåò 1 1 2 2, íî óïîðÿäî÷åííîñòü ÿâëÿåòñÿ ÷èñòîé ñëó-
÷àéíîñòüþ.
×òîáû ïðîâåðèòü, âõîäèò ëè ýëåìåíò X â ìíîæåñòâî A äîñòàòî÷íî íàïèñàòü X in
A. Ðåçóëüòàòîì ýòîé îïåðàöèè áóäåò True èëè False. ×òîáû ïðîâåðèòü, ÷òî ýëåìåíò íå
ëåæèò â ìíîæåñòâå ìîæíî ïèñàòü not X in A, èëè, áîëåå ïî-÷åëîâå÷åñêè X not in A.
62 ЛЕКЦИЯ 7. МНОЖЕСТВА, СЛОВАРИ, ПОЛЕЗНЫЕ МЕТОДЫ ДЛЯ СТРОК

mySet = { 1 , 2 , 3}
i f 1 in mySet :
print ( ' 1 i n s e t ')
else :
print ( ' 1 not i n set ' )
x = 42
i f x not in mySet :
print ( ' x not i n set ' )
else :
print ( ' x i n s e t ')
Âûâîä ýòîé ïðîãðàììû áóäåò:
1 in set
x not in set
×òîáû óäàëèòü ýëåìåíò èç ìíîæåñòâà, ìîæíî âîñïîëüçîâàòüñÿ îäíèì èç äâóõ ìåòî-
äîâ: discard èëè remove. Åñëè óäàëÿåìîãî ýëåìåíòà â ìíîæåñòâå íå áûëî, òî discard íå
èçìåíèò ñîñòîÿíèÿ ìíîæåñòâà, à remove âûïàäåò ñ îøèáêîé.

7.4 Групповые операции над множествами

 Ïèòîíå ìîæíî ðàáîòàòü íå òîëüêî ñ îòäåëüíûìè ýëåìåíòàìè ìíîæåñòâ, íî è ñ


ìíîæåñòâàìè â öåëîì. Íàïðèìåð, äëÿ ìíîæåñòâ îïðåäåëåíû ñëåäóþùèå îïåðàöèè:
Îïåðàöèÿ Îïèñàíèå
A|B Îáúåäèíåíèå ìíîæåñòâ
A&B Ïåðåñå÷åíèå ìíîæåñòâ
A-B Ìíîæåñòâî, ãäå ýëåìåíòû âõîäÿò â A, íî íå âõîäÿò â B
AB Ýëåìåíòû âõîäÿò â A | B, íå íå âõîäÿò â A & B
 ðåçóëüòàòå ýòèõ îïåðàöèé ñîçäàåòñÿ íîâîå ìíîæåñòâî, îäíàêî äëÿ íèõ îïðåäåëå-
íà è ñîêðàùåííàÿ çàïèñü: | =, &=, -= è =. Òàêèå îïåðàöèè èçìåíÿþò ìíîæåñòâî,
íàõîäÿùååñÿ ñëåâà îò çíàêà îïåðàöèè.
Äëÿ ìíîæåñòâ òàêæå îïðåäåëåíû îïåðàöèè ñðàâíåíèÿ:
Îïåðàöèÿ Îïèñàíèå
A == B Âñå ýëåìåíòû ñîâïàäàþò
A != B Åñòü ðàçëè÷íûå ýëåìåíòû
A <= B Âñå ýëåìåíòû A âõîäÿò â B
A >= B Âñå ýëåìåíòû B âõîäÿò â A
A>B A >= B è A != B
A<B A <= B è A != B
Âñå ãðóïïîâûå îïåðàöèè è ñðàâíåíèÿ ïðîâîäÿòñÿ íàä ìíîæåñòâàìè çà âðåìÿ, ïðî-
ïîðöèîíàëüíîå êîëè÷åñòâó ýëåìåíòîâ â ìíîæåñòâàõ.

7.5 Словари

 æèçíè íåðåäêî âîçíèêàåò íåîáõîäèìîñòü ñîïîñòàâèòü êëþ÷ó çíà÷åíèå. Íàïðèìåð,


â àíãëî-ðóññêîì ñëîâàðå àíãëèéñêîìó ñëîâó ñîïîñòîâëÿåòñÿ îäíî èëè íåñêîëüêî ðóññêèõ
ñëîâ. Çäåñü àíãëèéñêîå ñëîâî ÿâëÿåòñÿ êëþ÷àì, à ðóññêîå  çíà÷åíèåì.
7.5. СЛОВАРИ 63

 ÿçûêå Ïèòîí åñòü ñòðóêòóðà äàííûõ ñëîâàðü, êîòîðàÿ ïîçâîëÿåò ðåàëèçîâûâàòü


ïîäîáíûå îïåðàöèè. Ïðè ýòîì îáúåêòû-êëþ÷è óíèêàëüíû è êàæäîìó èç íèõ ñîïîñòàâ-
ëåí íåêîòîðûé îáúåêò-çíà÷åíèå. Îãðàíè÷åíèÿ íà êëþ÷è òàêèå æå, êàê íà ýëåìåíòû
ìíîæåñòâà, à âîò çíà÷åíèÿ ìîãóò áûòü è èçìåíÿåìûìè.
Ïî-ñóòè, ñëîâàðü ÿâëÿåòñÿ ìíîæåñòâîì, ãäå êàæäîìó ýëåìåíòó-êëþ÷ó ñîïîñòàâëåí
åùå è îáúåêò-çíà÷åíèå.
Ñîçäàòü ñëîâàðü â èñõîäíîì òåêñòå ïðîãðàììû ìîæíî çàïèñàâ â ôèãóðíûõ ñêîá-
êàõ ïàðû êëþ÷-çíà÷åíèÿ ÷åðåç çàïÿòóþ, à âíóòðè ïàðû êëþ÷ îòäåëÿåòñÿ îò çíà÷åíèÿ
äâîåòî÷èåì:
c o u n t r i e s = { ' R u s s i a ' : ' Europe ' , ' Germany ' : ' Europe ' , ' A u s t r a l i a ' : ' A u s t r a
Äîáàâëÿòü ïàðû êëþ÷ çíà÷åíèå â ñëîâàðü î÷åíü ïðîñòî: ýòî äåëàåòñÿ ïî àíàëîãèè
ñî ñïèñêàìè:
sqrs = {}
sqrs[1] = 1
sqrs[2] = 4
sqrs[ 1 0 ] = 100
print ( s q r s )

Ïóñòîé ñëîâàðü ìîæíî ñîçäàòü, íàïèñàâ ïóñòûå ôèãóðíûå ñêîáêè (ýòî áóäåò ñëîâàðü,
à íå ìíîæåñòâî).
Ñëîâàðü òàêæå ìîæíî êîíñòðóèðîâàòü èç äðóãèõ îáúåêòîâ ñ ïîìîùüþ ôóíêöèè dict:
myDict = d i c t ( [ [ ' key1 ' , ' v a l u e 1 ' ] , ( ' key2 ' , ' v a l u e 2 ' ) ] )
print ( myDict )

Íà âõîä ôóíêöèè äîëæåí ïîäàâàòü iterable, êàæäûé ýëåìåíò êîòîðîãî, â ñâîþ î÷å-
ðåäü, ÿâëÿåòñÿ iterable ñòðîãî ñ äâóìÿ ýëåìåíòàìè  êëþ÷îì è çíà÷åíèåì.
Óçíàâàòü çíà÷åíèå ïî êëþ÷ó ìîæíî òàêæå ñ ïîìîùüþ çàïèñè êëþ÷à ïîñëå èìåíè
ñëîâàðÿ â êâàäðàòíûõ ñêîáêàõ:
phones = { ' p o l i c e ' : 1 0 2 , ' ambulance ' : 1 0 3 , ' f i r e f i g h t e r s ' : 101}
print ( phones [ ' p o l i c e ' ] )

Åñëè òàêîãî êëþ÷à â ñëîâàðå íåò, òî âîçíèêíåò îøèáêà.


Óäàëåíèå ýëåìåíòà èç ñëîâàðÿ äåëàåòñÿ ñïåöèàëüíîé êîìàíäîé del. Ýòî íå ôóíêöèÿ,
ïîñëå ñëîâà del ñòàâèòñÿ ïðîáåë, çàòåì ïèøåòñÿ èìÿ ñëîâàðÿ, à çàòåì, â êâàäðàòíûõ
ñêîáêàõ, óäàëÿåìûé êëþ÷:
phones = { ' p o l i c e ' : 1 0 2 , ' ambulance ' : 1 0 3 , ' f i r e f i g h t e r s ' : 101}
del phones [ ' p o l i c e ' ]
print ( phones )

Ïðîâåðêà ïðèíàäëåæíîñòè êëþ÷à ñëîâàðþ îñóùåñòâëÿåòñÿ ñ ïîìîùüþ îïåðàöèè key


in dictionary (òî÷íî òàêæå, êàê ïðîâåðêà ïðèíàäëåæíîñòè ýëåìåíòà ìíîæåñòâó).
Ñëîâàðü ÿâëÿåòñÿ iterable è âîçâðàùàåò êëþ÷è â ñëó÷àéíîì ïîðÿäêå. Íàïðèìåð,
òàêîé êîä íàïå÷àòàåò ñîäåðæèìîå ñëîâàðÿ:
phones = { ' p o l i c e ' : 1 0 2 , ' ambulance ' : 1 0 3 , ' f i r e f i g h t e r s ' : 101}
f o r s e r v i c e in phones :
print ( s e r v i c e , phones [ s e r v i c e ] )
64 ЛЕКЦИЯ 7. МНОЖЕСТВА, СЛОВАРИ, ПОЛЕЗНЫЕ МЕТОДЫ ДЛЯ СТРОК

Òàêæå ñóùåñòâóåò ìåòîä items, êîòîðûé âîçâðàùàåò iterable, ñîäåðæàùèé â ñåáå


êîðòåæè êëþ÷-çíà÷åíèå äëÿ âñåâîçìîæíûõ êëþ÷åé.
phones = { ' p o l i c e ' : 1 0 2 , ' ambulance ' : 1 0 3 , ' f i r e f i g h t e r s ' : 101}
f o r s e r v i c e , phone in phones . i t e m s ( ) :
print ( s e r v i c e , phone )

7.6 Когда нужно использовать словари

1. Ïî ïðÿìîìó íàçíà÷åíèþ: ñîïîñòàâëåíèå êëþ÷à çíà÷åíèþ (íàçâàíèÿ äíåé íåäåëè,


ïåðåâîäû ñëîâ è ò.ä.).

2. Äëÿ ïîäñ÷åòà ÷èñëà îáúåêòîâ. Ïðè î÷åðåäíîé âñòðå÷å îáúåêòà ñ÷åò÷èê óâåëè÷è-
âàåòñÿ íà åäèíèöó. Ýòî ïîõîæå íà ñîðòèðîâêó ïîäñ÷¼òîì.

3. Äëÿ õðàíåíèÿ ðàçðåæåííûõ ìàññèâîâ. Íàïðèìåð, åñëè ìû õîòèì õðàíèòü öåíó 92,
95 è 98 áåíçèíà, òî ìîãëè áû ñîçäàòü ìàññèâ èç 99 ýëåìåíòîâ è õðàíèòü â í¼ì.
Íî áîëüøàÿ ÷àñòü ýëåìåíòîâ íå íóæíû  ìàññèâ ðàçðåæåííûé. Ñëîâàðü çäåñü
ïîäõîäèò áîëüøå.

Äëÿ ïîäñ÷åòà ÷èñëà ýëåìåíòîâ óäîáíî èñïîëüçîâàòü ìåòîä get. Îí ïðèíèìàåò äâà
ïàðàìåòðà: êëþ÷ äëÿ êîòîðîãî íóæíî âåðíóòü çíà÷åíèÿ è çíà÷åíèå, êîòîðîå áóäåò âîç-
âðàùåíî, åñëè òàêîãî êëþ÷à íåò. Íàïðèìåð, ïîäñ÷èòàòü ñêîëüêî ðàç âõîäèò â ïîñëåäî-
âàòåëüíîñòü êàæäîå èç ÷èñåë ìîæíî ñ ïîìîùüþ òàêîãî êîäà:
s e q = map( int , input ( ) . s p l i t ( ) )
c o u n t D i c t = {}
f o r elem in s e q :
c o u n t D i c t [ elem ] = c o u n t D i c t . g e t ( elem , 0 ) + 1
f o r key in sorted ( c o u n t D i c t ) :
print ( key , c o u n t D i c t [ key ] , s e p = ' : ' )

7.7 Полезные методы строк

It's dangerous to go alone! Take this.


isalpha  ïðîâåðÿåò, ÷òî âñå ñèìâîëû ñòðîêè ÿâëÿþòñÿ áóêâàìè.
isdigit  ïðîâåðÿåò, ÷òî âñå ñèìâîëû ñòðîêè ÿâëÿþòñÿ öèôðàìè.
isalnum  ïðîâåðÿåò, ÷òî âñå ñèìâîëû ñòðîêè ÿâëÿþòñÿ áóêâàìè èëè öèôðàìè.
islower  ïðîâåðÿåò, ÷òî âñå ñèìâîëû ñòðîêè ÿâëÿåþòñÿ ìàëåíüêèìè (ñòðî÷íûìè)
áóêâàìè.
isupper  ïðîâåðÿåò, ÷òî âñå ñèìâîëû ñòðîêè ÿâëÿåþòñÿ áîëüøèìè (çàãëàâíûìè,
ïðîïèñíûìè) áóêâàìè.
lstrip  îáðåçàåò âñå ïðîáåëüíûå ñèìâîëû â íà÷àëå ñòðîêè.
rstrip  îáðåçàåò âñå ïðîáåëüíûå ñèìâîëû â êîíöå ñòðîêè.
strip  îáðåçàåò âñå ïðîáåëüíûå ñèìâîëû â íà÷àëå è êîíöå ñòðîêè.
7.8. ПРИМЕР РЕШЕНИЯ СЛОЖНОЙ ЗАДАЧИ НА СЛОВАРИ 65

7.8 Пример решения сложной задачи на словари

Ðàññìîòðèì òàêóþ çàäà÷ó: ñëîâàðü çàäàí â âèäå íàáîðà ñòðîê, â êàæäîé ñòðîêå
çàïèñàíî ñëîâî íà àíãëèéñêîì ÿçûêå, çàòåì ñëåäóåò ñèìâîë -, çàòåì, ÷åðåç çàïÿòóþ,
ïåðå÷èñëåíû âîçìîæíûå ïåðåâîäû ñëîâà íà ëàòûíü.
Òðåáóåòñÿ ñîñòàâèòü ëàòèíî-àíãëèéñêèé ñëîâàðü è âûâåñòè åãî â òîì æå âèäå. Âñå
ñëîâà äîëæíû áûòü óïîðÿäî÷åíû ïî àëôàâèòó. Âîçìîæíûå ïåðåâîäû îäíîãî ñëîâà
äîëæíû áûòü òàêæå óïîðÿäî÷åíû ïî àëôàâèòó.
Íàïðèìåð, äëÿ ââîäà:

3
apple - malum, pomum, popula
fruit - baca, bacca, popum
punishment - malum, multa

Âûâîä äîëæåí âûãëÿäåòü òàê:

7
baca - fruit
bacca - fruit
malum - apple, punishment
multa - punishment
pomum - apple
popula - apple
popum - fruit

Èäåÿ ðåøåíèÿ çàêëþ÷àåòñÿ â ñëåäóþùåì: ðàçðåæåì êàæäóþ ñòðîêó íà àíãëèéñêîå


è ëàòèíñêèå ñëîâà. Êàæäîå èç ëàòèíñêèõ ñëîâ âîçüìåì â êà÷åñòâå êëþ÷à è äîáàâèì
ê åãî çíà÷åíèÿì àíãëèéñêîå ñëîâî (ïåðåâîäîâ ìîæåò áûòü íåñêîëüêî). Çàòåì ïðîéäåì
ïî ñîðòèðîâàííûì êëþ÷àì è äëÿ êàæäîãî êëþ÷à âûâåäåì îòñîðòèðîâàííûé ñïèñîê
ïåðåâîäîâ:
n = i n t ( input ( ) )
l a t i n E n g l i s h = {}
f o r i in range ( n ) :
l i n e = input ( )
e n g l i s h = l i n e [ : l i n e . f i n d ( '− ' ) ] . s t r i p ( )
l a t i n s S t r = l i n e [ l i n e . f i n d ( '− ' ) + 1 : ] . s t r i p ( )
l a t i n s = map( lambda s : s . s t r i p ( ) , l a t i n s S t r . s p l i t ( ' , ' ) )
f o r l a t i n in l a t i n s :
i f l a t i n not in l a t i n E n g l i s h :
latinEnglish [ latin ] = [ ]
l a t i n E n g l i s h [ l a t i n ] . append ( e n g l i s h )
print ( len ( l a t i n E n g l i s h ) )
f o r l a t i n in sorted ( l a t i n E n g l i s h ) :
print ( l a t i n , '− ' , ' , ' . j o i n ( sorted ( l a t i n E n g l i s h [ l a t i n ] ) ) )
66 ЛЕКЦИЯ 7. МНОЖЕСТВА, СЛОВАРИ, ПОЛЕЗНЫЕ МЕТОДЫ ДЛЯ СТРОК
Лекция 8

Элементы функционального

программирования

8.1 Парадигмы программирования

ßçûêè ïðîãðàììèðîâàíèÿ ïðåäëàãàþò ðàçëè÷íûå ñðåäñòâà äëÿ äåêîìïîçèöèè çàäà-


÷è. Ñóùåñòâóåò íåñêîëüêî ïàðàäèãì ïðîãðàììèðîâàíèÿ:

∙ Èìïåðàòèâíîå (ñòðóêòóðíîå, ïðîöåäóðíîå) ïðîãðàììèðîâàíèå: ïðîãðàììû ÿâëÿ-


þòñÿ ïîñëåäîâàòåëüíîñòüþ èíñòðóêöèé, êîòîðûå ìîãóò ÷èòàòü è çàïèñûâàòü äàí-
íûå èç ïàìÿòè. Ïðè èçó÷åíèè ïðåäûäóùèõ òåì ìû ïîëüçîâàëèñü, â îñíîâíîì,
èìïåðàòèâíîé ïàðàäèãìîé. Ðÿä ÿçûêîâ, òàêèå êàê Ïàñêàëü (íå Object Pascal) èëè
C ÿâëÿþòñÿ ÿðêèìè ïðåäòàâèòåëÿìè èìïåðàòèâíûõ ÿçûêîâ.

∙ Äåêëàðàòèâíîå ïðîãðàììèðîâàíèå: îïèñûâàåòñÿ çàäà÷à è îæèäàåìûé ðåçóëüòàò,


íî íå îïèñûâàþòñÿ ïóòè å¼ ðåøåíèÿ. ßðêèì ïðåäñòàâèòåëåì ÿâëÿåòñÿ ÿçûê çàïðî-
ñîâ ê áàçàì äàííûõ SQL: áîëüøàÿ ÷àñòü âíóòðåííåãî óñòðîéñòâà ñêðûòà â ÑÓÁÄ,
ïðîãðàììèñò îïèñûâàåò òîëüêî ñòðóêòóðó áàçû äàííûõ è îæèäàåìûé ðåçóëüòàò
çàïðîñîâ.

∙ Îáúåêòíî-îðèåíòèðîâàííîå ïðîãðàììèðîâàíèå: ïðîãðàììû ìàíèïóëèðóþò íàáî-


ðàìè îáúåêòîâ, ïðè ýòîì îáúåêòû îáëàäàþò ñîõðàíÿþùèìñÿ âî âðåìåíè ñîñòîÿ-
íèåì è ìåòîäàìè äëÿ èçìåíåíèÿ ýòîãî ñîñòîÿíèÿ (èëè ñîçäàíèÿ íîâûõ îáúåêòîâ).
Ìû ïîçíàêîìèìñÿ ñ ÎÎÏ ïîäðîáíåå íà îäíîé èç ñëåäóþùèõ ëåêöèé. Ïðèìåðîì
ÿçûêà ñ îáúåêòíî-îðèåíòèðîâàííîé ïàðàäèãìîé ÿâëÿåòñÿ Java, ÎÎÏ òàêæå ïîä-
äåðæèâàåòñÿ â Ïèòîíå è C++.

∙ Ôóíêöèîíàëüíîå ïðîãðàììèðîâàíèå: çàäà÷à ðàçáèâàåòñÿ íà íàáîð ôóíêöèé. Â


èäåàëå, ôóíêöèè òîëüêî ïðèíèìàþò ïàðàìåòðû è âîçâðàùàþò çíà÷åíèÿ, íå èçìå-
íÿÿ ñîñòîÿíèÿ îáúåêòîâ èëè ïðîãðàììû. Ïðåäñòàâèòåëåì ôóíêöèîíàëüíûõ ÿçû-
êîâ ÿâëÿåòñÿ Haskell.

Èíîãäà, òàêæå, âûäåëÿþò è äðóãèå ïàðàäèãìû ïðîãðàììèðîâàíèÿ.


Íåêîòîðûå ÿçûêè ïðåäíàçíà÷åíû, â îñíîâíîì, äëÿ íàïèñàíèÿ ïðîãðàìì â ðàìêàõ
îäíîé ïàðàäèãìû, äðóãèå æå ïîääåðæèâàþò íåñêîëüêî ïàðàäèãì. Íàïðèìåð, Ïèòîí
è C++ ïîääåðæèâàþò ðàçëè÷íûå ïàðàäèãìû ïðîãðàììèðîâàíèÿ. Ðàçíûå ÷àñòè ïðî-
ãðàììû ìîæíî ïèñàòü â ðàçíûõ ïàðàäèãìàõ, íàïðèìåð, èñïîëüçîâàòü ôóíêöèîíàëüíûé

67
68 ЛЕКЦИЯ 8. ЭЛЕМЕНТЫ ФУНКЦИОНАЛЬНОГО ПРОГРАММИРОВАНИЯ

ñòèëü äëÿ îáðàáîòêè áîëüøèõ äàííûõ, îáúåêòíî-îðèåíòèðîâàííûé ïîäõîä äëÿ ðåàëè-


çàöèè èíòåðôåéñà è èìïåðàòèâíîå ïðîãðàììèðîâàíèå äëÿ ïðîìåæóòî÷íîé ëîãèêè.

8.2 Функциональное программирование

Íåñìîòðÿ íà òî, ÷òî â ôóíêöèîíàëüíîì ñòèëå ïèñàòü äîñòàòî÷íî ñëîæíî è íåïðè-


âû÷íî, ôóíêöèîíàëüíîå ïðîãðàììèðîâàíèå èìååò ìàññó ïëþñîâ:

∙ Äîñòàòî÷íî ëåãêî äîêàçàòü ôîðìàëüíóþ êîððåêòíîñòü àëãîðèòìîâ. Õîòÿ äîêàçà-


òåëüñòâî, äàæå äëÿ ôóíêöèîíàëüíûõ ïðîãðàìì, ÷àñòî íàìíîãî äëèííåå, ÷åì ñàìà
ïðîãðàììà, íî äëÿ ôóíäàìåíòàëüíûõ àëãîðèòìîâ, êîòîðûå øèðîêî èñïîëüçóþòñÿ,
ëó÷øå èìåòü ôîðìàëüíîå äîêàçàòåëüñòâî, ÷òîáû íå ïîïàäàòü â ãëóïûå ñèòóàöèè.
Ñòðîèòü ôîðìàëüíûå äîêàçàòåëüñòâà èìïåðàòèâíûõ ïðîãðàìì íàìíîãî ñëîæíåå.

∙ Äëÿ ïðîãðàìì, íàïèñàííûõ â ôóíêöèîíàëüíîì ñòèëå, ëåãêî ïðîâîäèòü äåêîìïîçè-


öèþ, îòëàäêó è òåñòèðîâàíèå. Êîãäà âñÿ ïðîãðàììà ðàçáèòà íà ôóíêöèè, âûïîë-
íÿþùèå ýëåìåíòàðíûå äåéñòâèÿ, òî èõ ðàçðàáîòêà è ïðîâåðêà çàíèìàåò íàìíîãî
ìåíüøå âðåìåíè.

∙ Äëÿ ôóíêöèîíàëüíûõ ïðîãðàìì ëåãêî àâòîìàòè÷åñêè ïðîâîäèòü ðàñïàðàëëåëèâà-


íèå, âåêòîðèçàöèþ è êîíâåéåðèçàöèþ.

Çàäà÷à ðàñïàðàëëåëèâàíèÿ âûïîëíåíèÿ ïðîãðàìì êðàéíå àêòóàëüíà ñåé÷àñ, êîãäà


ñêîðîñòè ÿäåð ïðîöåññîðîâ ïðàêòè÷åñêè ïåðåñòàëè ðàñòè. Åäèíñòâåííûì ñïîñîáîì óñêî-
ðèòü âûïîëíåíèå ïðîãðàìì ÿâëÿåòñÿ èõ ïàðàëëåëüíîå âû÷èñëåíèå íà íåñêîëüêèõ óñòðîé-
ñòâàõ.
Ïîñëåäíèå óñïåõè â ðåøåíèè çàäà÷ ìàøèííîãî îáó÷åíèÿ ñâÿçàíû ñ èñïîëüçîâàíè-
åì áîëüøîãî êîëè÷åñòâà ïðîñòûõ âû÷èñëèòåëüíûõ óñòðîéñòâ, íàïðèìåð, ðàññ÷åòîâ íà
âèäåîêàðòå.
 ôóíêöèîíàëüíûõ ïðîãðàììàõ íå ïðèíÿòî âíîñèòü èçìåíåíèÿ â îáúåêòû (è, âîîáùå
ãîâîðÿ, æåëàòåëüíî, ÷òîáû âñå îáúåêòû áûëè íåèçìåíÿìûìè). Ïîýòîìó, åñëè íàì íóæíî
ïîñ÷èòàòü ðåçóëüòàò âû÷èñëåíèÿ äâóõ ôóíêöèé, òî âî ìíîãèõ ñëó÷àÿõ ìîæíî äåëàòü
ýòî ïàðàëëåëüíî íà ðàçíûõ ÿäðàõ ïðîöåññîðà. Òàêîå ðàñïàðàëëåëèâàíèå ëåãêî ñäåëàòü
àâòîìàòè÷åñêè.
Âåêòîðèçàöèÿ  ýòî êîãäà îäíè è òå æå äåéñòâèÿ âûïîëíÿþòñÿ íàä áîëüøèì íàáîðîì
äàííûõ. Òîãäà äàííûå ìîæíî íàðåçàòü íà êóñêè è ðàñêèäàòü ïî ðàçíûì âû÷èñëèòåëü-
íûì óñòðîéñòâàì, à çàòåì ñîáðàòü ðåçóëüòàò âû÷èñëåíèé â îäèí îáúåêò.
Êîíâåéåðèçàöèÿ  ýòî ðàçáèåíèå âû÷èñëåíèé íà íåñêîëüêî ýòàïîâ, ïðè÷¼ì äàííûå
ïîñòóïàþò íà ñëåäóþùèé ýòàï îáðàáîòêè ïî âðåìåíè ãîòîâíîñòè. Íàïðèìåð, åñëè íàì
íóæíî ïîïàðíî ïåðåìíîæèòü çíà÷åíèÿ â âåêòîðàõ A è B, à çàòåì ñëîæèòü ñî çíà÷å-
íèÿìè â âåêòîðå C, òî ìû ìîæåì ïîñ÷èòàòü íåñêîëüêî ïåðâûõ ðåçóëüòàòîâ ïîäñ÷åòà
ïðîèçâåäåíèÿ è óæå âûïîëíÿòü ñ íèìè ñëîæåíèå, íå äîæèäàÿñü ïîäñ÷åòà îñòàëüíûõ
çíà÷åíèé. Ýòî ïîçâîëÿåò áûñòðåå ïîëó÷èòü ïåðâûå ðåçóëüòàòû è çàíÿòü åùå áîëüøîå
êîëè÷åñòâî âû÷èñëèòåëüíûõ óñòðîéñòâ ïàðàëëåëüíî.
8.3. ИТЕРАТОРЫ И ГЕНЕРАТОРЫ 69

8.3 Итераторы и генераторы

 Ïèòîíå èòåðàòîðû  ýòî îáúåêòû, êîòîðûå èìåþò âíóòðåííåå ñîñòîÿíèå è ìåòîä


__next__ äëÿ ïåðåõîäà ê ñëåäóþùåìó ñîñòîÿíèþ. Íàïðèìåð, ìîæíî ñêîíñòðóèðîâàòü
èòåðàòîð îò ñïèñêà è ïåðåáðàòü âñå çíà÷åíèÿ:
myList = [ 1 , 2 , 3 ]
f o r i in i t e r ( myList ) :
print ( i )
f o r i in myList :
print ( i )
 ýòîé ïðîãðàììå äâà öèêëà ýêâèâàëåíòíû.
 Ïèòîíå ìîæíî ñîçäàâàòü è ñâîè èòåðàòîðû. Èõ ðàçóìíî èñïîëüçîâàòü â òîì ñëó÷àå,
åñëè íóæíî ïåðåáðàòü áîëüøîå êîëè÷åñòâî çíà÷åíèé è ñóùåñòâóåò ïðàâèëî, ïî êîòîðîìó
ìîæíî ïîëó÷èòü ñëåäóþùåå çíà÷åíèå, îäíàêî õðàíåíèé âñåõ ýòèõ çíà÷åíèé íå èìååò
ñìûñëà, ò.ê. îíè ïðèãîäÿòñÿ òîëüêî îäèí ðàç.
Äëÿ ñîçäàíèÿ èòåðàòîðîâ â Ïèòîíå èñïîëüçóåòñÿ ñïåöèàëüíûé âèä ôóíêöèé, íà-
çûâàåìûõ ãåíåðàòîðàìè.  îáû÷íîé ôóíêöèè return ïðåêðàùàåò ðàáîòó ôóíêöèè. Â
ãåíåðàòîðå âìåñòî return èñïîëüçóåòñÿ îïåðàòîð yield, êîòîðûé òàêæå âîçâðàùàåò çíà-
÷åíèå, íî íå ïðåêðàùàåò âûïîëíåíèå ôóíêöèè, à ïðèîñòàíàâëèâàåò åãî äî òåõ ïîð, ïîêà
íå ïîòðåáóåòñÿ ñëåäóþùåå çíà÷åíèå èòåðàòîðà. Ïðè ýòîì ðàáîòà ôóíêöèè ïðîäîëæèò-
ñÿ ñ òîãî ìåñòà è â òîì ñîñòîÿíèè, â êîòîðîì îíà íàõîäèëàñü íà ìîìåíò âûçîâà yield.
Ïîñìîòðèì, êàê ìîæåò áûòü ðåàëèçîâàí ãåíåðàòîð, àíàëîãè÷íûé ñòàíäàðòíîìó range ñ
îäíèì ïàðàìåòðîì:
def myRange ( n ) :
i = 0
while i < n :
yield i
i += 1
f o r i in myRange ( 1 0 ) :
print ( i )
Ãåíåðàòîðû ìîãóò èìåòü è ñëîæíóþ ðåêóðñèâíóþ ñòðóêòóðó. Íàïðèìåð, ìû ìîæåì
íàïèñàòü ãåíåðàòîð, êîòîðûé áóäåò âûäàâàòü âñå ÷èñëà çàäàííîé äëèíû, öèôðû â êî-
òîðûõ íå óáûâàþò è ñòàðøàÿ öèôðà íå ïðåâîñõîäèò çàäàííîãî ïàðàìåòðà:
def genDecDigs ( c n t D i g i t s , maxDigit ) :
if cntDigits > 0:
f o r nowDigit in range ( maxDigit + 1 ) :
f o r t a i l in genDecDigs ( c n t D i g i t s − 1 , nowDigit ) :
y i e l d nowDigit * 10 ** ( c n t D i g i t s − 1 ) + t a i l
else :
yield 0

print ( * genDecDigs ( 2 , 3 ) )
Âûâîä ýòîé ïðîãðàììû áóäåò âûãëÿäåòü òàê: 0 10 11 20 21 22 30 31 32 33
 ýòîé ïðîãðàììå ðåêóðñèâíûé ãåíåðàòîð ïåðåáèðàë âñå äîïóñòèìûå öèôðû â êà-
÷åñòâå òîé, êîòîðàÿ äîëæíà ñòîÿòü íà çàäàííîé ïîçèöèè è ãåíåðèðîâàë âñå âîçìîæíûå
70 ЛЕКЦИЯ 8. ЭЛЕМЕНТЫ ФУНКЦИОНАЛЬНОГО ПРОГРАММИРОВАНИЯ

ïîñëåäóþùèå öèôðû.
Òàêæå â ýòîé ïðîãðàììå ìû èñïîëüçîâàëè îäíó îñîáåííîñòü ôóíêöèè print: åñëè
ïåðåäè èìåíåì iterable (à ðåçóëüòàò, âîçâðàùàåìûé ãåíåðàòîðîì ÿâëÿåòñÿ iterable) ïî-
ñòàâèòü *, òî áóäóò íàïå÷àòíû âñå çíà÷åíèÿ ÷åðåç ïðîáåë.
Ðåçóëüòàò ðàáîòû ãåíåðàòîðà ìîæíî ñîõðàíèòü, íàïðèìåð, â ñïèñîê ñ ïîìîùüþ
ôóíêöèè list, êàê ìû óæå äåëàëè ýòî ñ ðåçóëüòàòîì ðàáîòû range.

8.4 Встроенные функции для работы с последователь-


ностями

 ÿçûêå Ïèòîí åñòü ìíîãî ôóíêöèé, êîòîðûå ïðèíèìàþò â êà÷åñòâå ïàðàìåòðà


iterable è ìîãóò ñäåëàòü ÷òî-òî ïîëåçíîå. Ñ íåêîòîðûìè èç íèõ, òàêèìè êàê sorted èëè
map ìû óæå íåìíîãî çíàêîìû. Ðàññìîòðèì åùå íåêîòîðûå èç íèõ:
sum  íàõîäèò ñóììó âñåõ ýëåìåíòîâ iterable.
min, max  íàõîäèò ìèíèìóì è ìàêñèìóì â ïîñëåäîâàòåëüíîñòè iterable.
map  óìååò ïðèíèìàòü áîëåå äâóõ ïàðàìåòðîâ. Íàïðèìåð, òàêàÿ çàïèñü map(f,
iterA, iterB) âåðíåò iterable ñî çíà÷åíèÿìè f(iterA[0], iterB[0]), f(iterA[1], iterB[2]), . . . .
lter(predicate, iterable)  ïðèìåíÿåò ôóíêöèþ predicate êî âñåì ýëåìåíòàì iterable è
âîçâðùàåò iterable, êîòîðûé ñîäåðæèò òîëüêî òå ýëåìåíòû, êîòîðûå óäîâëåòâîðÿëè ïðå-
äèêàòû (ò.å. ôóíêöèÿ predicate âåðíóëà True). Íàïðèìåð, òàê ìîæåò âûãëÿäåòü ðåøåíèå
çàäà÷è î ïîèñêå ìèíèìàëüíîãî ïîëîæèòåëüíîãî ýëåìåíòà â ñïèñêå:
print ( min ( f i l t e r ( lambda x : x > 0 , map( int , input ( ) . s p l i t ( ) ) ) ) )

Çäåñü â êà÷åñòâå ïðåäèêàòà èñïîëüçîâàíà ëÿìáäà-ôóíêöèÿ, êîòîðàÿ âîçâðàùàåò True


ïðè çíà÷åíèè ïàðàìåòðà áîëüøå 0, à â êà÷åñòâå âõîäíîãî iterable  ðåçóëüòàò âûçîâà
map äëÿ ôóíêöèè int è íàðåçàííîãî íà ñëîâà ââîäà. Ôóíêöèÿ max ïðèìåíåíà ê òîìó
iterable, êîòîðûé áûë âîçâðàùåí ôóíêöèåé lter.
enumerate  âîçâðàùàåò êîðòåæè èç íîìåðà ýëåìåíòà (ïðè íóìåðàöèè ñ íóëÿ) è
íîìåðà î÷åðåäíîãî ýëåìåíòà. Ñ ïîìîùüþ enumerate, íàïðèìåð, óäîáíî ïåðåáèðàòü ýëå-
ìåíòû iterable (äîñòóï ïî èíäåêñó â êîòîðûõ íåâîçìîæåí) è âûâîäèòü íîìåðà ýëåìåíòîâ,
êîòîðûå îáëàäàþò íåêîòîðûì ñâîéñòâîì:
f = open ( ' data . t x t ' , ' r ' , e n c o d i n g= ' u t f 8 ' )
f o r i , l i n e in enumerate ( f ) :
i f l i n e . s t r i p ( ) == ' ' :
print ( ' Blank l i n e a t l i n e ' , i )

any, all  âîçâðàùàþò èñòèíó, åñëè õîòÿ áû îäèí èëè âñå ýëåìåíòû iterable èñòèííû
ñîîòâåòñòâííî. Íàïðèìåð, òàê ìîæíî ïðîâåðèòü, íå ïðåâûøàþò ëè âñå ÷ëåíû ïîñëåäî-
âàòåëüíîñòè 100 ïî ìîäóëþ:
print ( a l l (map( lambda x : abs ( i n t ( x ) ) <= 1 0 0 , input ( ) . s p l i t ( ) ) ) )

zip(iterA, iterB, . . . )  êîíñòðóèðóåò êîðòåæè èç ýëåìåíòîâ (iterA[0], iterB[0], . . . ),


(iterA[1], iterB[1], . . . ), . . .
Ñ ïîìîùüþ ýòèõ ôóíêöèÿ ìîæíî ðåøèòü äîñòàòî÷íî ñëîæíûå çàäà÷è, áåç èñïîëü-
çîâàíèÿ öèêëîâ è óñëîâíûõ îïåðàòîðîâ. Íàïðèìåð, çàäà÷ó èç äîìàøíåãî çàäàíèÿ ïî
ñîðòèðîâêàì ïðî òàêñè: â ïåðâîé ñòðîêå çàäàíî êîëè÷åñòâî ëþäåé è àâòîìîáèëåé òàêñè,
8.5. ГЕНЕРАЦИЯ КОМБИНАТОРНЫХ ОБЪЕКТОВ ITERTOOLS 71

â ñëåäóþùèõ äâóõ ñòðîêàõ ðàññòîÿíèå â êèëîìåòðàõ äëÿ êàæäîãî ÷åëîâåêà è öåíà çà


êèëîìåòð äëÿ êàæäîãî òàêñè. Íåîáõîäèìî ñîïîñòàâèòü êàæäîìó ÷åëîâåêó íîìåð òàêñè,
÷òîáû ñóììàðíàÿ öåíà ïîåçäîê áûëà ìèíèìàëüíà. Èäåÿ ðåøåíèÿ çàêëþ÷àåòñÿ â òîì,
÷òîáû ëþäè, êîòîðûì åõàòü äàëüøå åõàëè íà áîëåå äåøåâûõ òàêñè:
n = i n t ( input ( ) )
p e o p l e L i s t = map( int , input ( ) . s p l i t ( ) )
p e o p l e s = sorted ( l i s t ( enumerate ( p e o p l e L i s t ) , key=lambda x : x [ 1 ] ) )
t a x i L i s t = map( int , input ( ) . s p l i t ( ) )
t a x i s = sorted ( l i s t ( enumerate ( t a x i L i s t ) ) , key=lambda x : x [ 1 ] , r e v e r s e=True )
ans = sorted ( zip ( p e o p l e s , t a x i s ) , key=lambda x : x [ 0 ] [ 0 ] )
print ( *map( lambda x : x [ 1 ] [ 0 ] + 1 , ans ) )

8.5 Генерация комбинаторных объектов itertools

 Ïèòîíå åñòü áèáëèîòåêà itertools, êîòîðàÿ ñîäåðæèò ìíîãî ôóíêöèé äëÿ ðàáîòû ñ
èòåðàòîðûìè. Ñ ýòèìè ôóíêöèÿìè ìîæíî îçíàêîìèòüñÿ â îôèöèàëüíîé äîêóìåíòàöèè
ê ÿçûêó.
Íàì íàèáîëåå èíòåðåñíû ôóíêöèè, ãåíåðèðóþùèå êîìáèíàòîðíûå îáúåêòû.
itertools.combinations(iterable, size)  ãåíåðèðóåò âñå ïîäìíîæåñòâà ìíîæåñòâà iterable
ðàçìåðîì size â âèäå êîðòåæåé. Ýòî ìîæåò áûòü èñïîëüçîâàíî âìåñòî âëîæåííûõ öèê-
ëîâ ïðè îðãàíèçàöèè ïåðåáîðà. Íàïðèìåð, ìû ìîæåì íåýôôåêòèâíî ðåøèòü çàäà÷ó î
ïîèñêå òðåõ ÷èñåë â ïîñëåäîâàòåëüíîñòè, äàþùèõ íàèáîëüøåå ïðîèçâåäåíèå:
from i t e r t o o l s import c o m b i n a t i o n s

nums = l i s t (map( int , input ( ) . s p l i t ( ) ) )


combs = c o m b i n a t i o n s ( range ( len ( nums ) ) , 3 )
print (max(map( lambda x : nums [ x [ 0 ] ] * nums [ x [ 1 ] ] * nums [ x [ 2 ] ] , combs ) ) )
itertools.permutations(iterable)  ãåíåðèðóåò âñå ïåðåñòàíîâêè iterable. Ñóùåñòâóåò
âàðèàíò ôóíêöèè ñ äâóìÿ ïàðàìåòðàìè, âòîðîé ïàðàìåòð ÿâëÿåòñÿ ðàçìåðîì ïîäìíî-
æåñòâà. Òîãäà ãåíåðèðóþòñÿ âñå ïåðåñòàíîâêè âñåõ ïîäìíîæåñòâ çàäàííîãî ðàçìåðà.
itertools.combinations_with_replacement(iterable, size)  ãåíåðèðóåò âñå ïîäìíîæå-
ñòâà iterable ðàçìåðîì size ñ ïîâòîðåíèÿìè, ò.å. îäíî è òî æå ÷èñëî ìîæíî âõîäèòü â
ïîäìíîæåñòâî íåñêîëüêî ðàç.

8.6 partial, reduce, accumulate

Ìîäóëü functools ñîäåðæèò íåêîòîðûå ôóíêöèè, êîòîðûå ìîãóò ïîëåçíû äëÿ îáðà-
áîòêè ïîñëåäîâàòåëüíîñòåé è íå òîëüêî.
Ôóíêöèÿ functools.partial ïðåäíàçíà÷åíà äëÿ îáåðà÷èâàíèÿ ñóùåñòâóþùèõ ôóíêöèé
ñ ïîäñòàíîâêîé íåêîòîðûõ ïàðàìåòðîâ. Íàïðèìåð, ìû ìîæåì ñîçäàòü ôóíêöèþ äëÿ
ïå÷àòè â ôàéë, ÷òîáû êàæäûé ðàç íå óêàçûâàòü êàêèå-òî ïàðàìåòðû. Íàïðèìåð, ñóùå-
ñòâóåò âàðèàíò ôóíêöèè int ñ äâóìÿ ïàðàìåòðàìè: ïåðâûé  ýòî ïåðåìåííàÿ, êîòîðóþ
íåîáõîäèìî ïðåîáðàçîâàòü â ÷èñëî, à âòîðîé  ñèñòåìà ñ÷èñëåíèÿ â êîòîðîé çàïèñàíî
÷èñëî. Ñ ïîìîùüþ partial ìû ìîæåì ñîçäàòü ôóíêöèþ-îá¼ðòêó, ïðåîáðàçóþùóþ ñòðîêè
èç 0 è 1 â ÷èñëà:
72 ЛЕКЦИЯ 8. ЭЛЕМЕНТЫ ФУНКЦИОНАЛЬНОГО ПРОГРАММИРОВАНИЯ

from f u n c t o o l s import p a r t i a l

b i n S t r T o I n t = p a r t i a l ( int , b a s e =2)
print ( b i n S t r T o I n t ( ' 10010 ' ) )
 ìîäóëå functools òàêæå ñîäåðæàòñÿ ôóíêöèè äëÿ îáðàáîòêè ïîñëåäîâàòåëüíîñòåé.
functools.reduce(func, iterable) ïîçâîëÿåò ïðèìåíèòü ôóíêöèþ êî âñåì ýëåìåíòàì ïî-
ñëåäîâàòåëüíîñòè, èñïîëüçóÿ â êà÷åñòâå ïåðâîãî àðãóìåíòà íàêîïëåííûé ðåçóëüòàò. Íà-
ïðèìåð, åñëè â ïîñëåäîâàòåëüíîñòè áûëè ýëåìåíòû myList = [A, B, C], òî ðåçóëüòàòîì
ïðèìåíåíèÿ reduce(f, myList) áóäåò f(f(A, B), C). Ñ ïîìîùüþ reduce, íàïðèìåð, ìîæíî
íàéòè ÍÎÄ âñåõ ÷èñåë â iterable:
from f u n c t o o l s import reduce

def gcd ( a , b ) :
while b != 0 :
a, b = b, a % b
return a

print ( reduce ( gcd , map( int , input ( ) . s p l i t ( ) ) ) )


itertools.accumulate(func, iterable), êîòîðàÿ âîçâðàùàåò iterable ñî âñåìè ïðîìåæó-
òî÷íûìè çíà÷åíèÿìè, ò.å. äëÿ ñïèñêà [A, B, C] accumulate âåðíåò çíà÷åíèÿ A, f(A, B),
f(f(A, B), C). Íàïðèìåð, ìîæíî óçíàòü ìàêñèìàëüíûé ýëåìåíò äëÿ êàæäîãî ïðåôèêñà
(íåêîòîðîãî êîëè÷åñòâà ïåðâûõ ýëåìåíòîâ) çàäàííîé ïîñëåäîâàòåëüíîñòè:
from i t e r t o o l s import accumulate

print ( * accumulate (map( int , input ( ) . s p l i t ( ) ) , max ) )


Лекция 9

Объектно-ориентированное

программирование

9.1 Объектно-ориентированное программирование

Îáúåêòíî-îðèåíòèðîâàííîå ïðîãðàììèðîâàíèå (ÎÎÏ) ÿâëÿåòñÿ îäíîé èç ïàðàäèãì


ïðîãðàììèðîâàíèÿ, ñîçäàííîé íà áàçå èìïåðàòèâíîãî ïðîãðàììèðîâàíèÿ äëÿ áîëåå
óäîáíîãî ïîâòîðíîãî èñïîëüçîâàíèÿ êîäà è îáëåã÷åíèÿ ÷èòàåìîñòè ïðîãðàìì.
ÎÎÏ íå ÿâëÿåòñÿ ¾ñåðåáðÿíîé ïóëåé¿, êîòîðàÿ ðåøàåò âñå çàäà÷è íàèáîëåå óäîá-
íûì îáðàçîì. Èìïåðàòèâíîå ïðîãðàììèðîâàíèå óäîáíî äëÿ ðåøåíèÿ ïðîñòûõ çàäà÷,
èñïîëüçóþùèõ ñòàíäàðòíûå îáúåêòû. Ïîâòîðíîå èñïîëüçîâàíèå êîäà â èìïåðàòèâíîé
ïàðàäèãìå îáåñïå÷èâàåòñÿ ñ ïîìîùüþ öèêëîâ è ôóíêöèé, íàïèñàííûõ â èìïåðàòèâíîì
ñòèëå.
Ôóíêöèîíàëüíîå ïðîãðàììèðîâàíèå óäîáíî äëÿ çàäà÷, ãäå ñóùåñòâóåò ÿðêî âûðà-
æåííûé ïîòîê äàííûõ (data ow), êîòîðûé ¾ïåðåòåêàåò¿ èç îäíîé ôóíêöèè â äðóãóþ,
èçìåíÿÿñü ïî ïóòè.
ÎÎÏ æå ïîçâîëÿåò îáåñïå÷èòü ïîâòîðíîå èñïîëüçîâàíèå êîäà çà ñ÷åò òîãî, ÷òî îáðà-
áàòûâàåìûå ïðîãðàììîé îáúåêòû èìåþò ìíîãî îáùåãî è ëèøü íåçíà÷èòåëüíûå îòëè÷èÿ
â ñâîåì ïîâåäåíèè.
ÎÎÏ îñíîâàíî íà òð¼õ êîíöåïöèÿõ: èíêàïñóëÿöèÿ, íàñëåäîâàíèå, ïîëèìîðôèçì.
Èíêàïñóëÿöèÿ  ýòî ïîìåùåíèå â ¾êàïñóëó¿: ëîãè÷åñêîå îáúåäèíåíèå äàííûõ è
ôóíêöèé äëÿ ðàáîòû ñ íèìè, à òàêæå ñîêðûòèå âíóòðåííåãî óñòðîéñòâà îáúåêòà ñ ïðåäî-
ñòàâëåíèåì èíòåðôåéñà âçàèìîäåéñòâèÿ ñ íèì (ïóáëè÷íûå ìåòîäû).
Íàñëåäîâàíèå  ýòî ïîëó÷åíèå íîâîãî òèïà îáúåêòîâ íà îñíîâå óæå ñóùåñòâóþùåãî
ñ ÷àñòè÷íî èëè ïîëíîñòüþ çàèìñòâîâàííûé ó ðîäèòåëüñêîãî òèïà ôóíêöèîíàëüíîñòüþ.
Ïîëèìîðôèçì  ýòî ïðåäîñòàâëåíèå îäèíàêîâûõ ñðåäñòâ âçàèìîäåéñòâèÿ ñ îáúåê-
òàìè ðàçíîé ïðèðîäû. Íàïðèìåð, îïåðàöèÿ + ìîæåò ðàáîòàòü êàê ñ ÷èñëàìè, òàê è ñî
ñòðîêàìè, íåñìîòðÿ íà ðàçíóþ ïðèðîäó ýòèõ îáúåêòîâ.
Êëàññîì â Ïèòîíå íàçûâàåòñÿ îïèñàíèå ñòðóêòóðû îáúåêòà (ïîëåé ñòðóêòóðû) è
ìåòîäîâ (ôóíêöèé) äëÿ ðàáîòû ñ äàííûìè â ýòîé ñòðóêòóðå.
Îáúåêòîì íàçûâàåòñÿ ýêçåìïëÿð êëàññà, ãäå ïîëÿ çàïîëíåíû êîíêðåòíûìè çíà÷å-
íèÿìè. Îáúåêòû íàõîäÿòñÿ â ïàìÿòè ïðîãðàììû è ìîãóò èçìåíÿòü ñâî¼ ñîñòîÿíèå èëè
âûïîëíÿòü êàêèå-òî äåéñòâèÿ ñ ïîìîùüþ âûçîâà ìåòîäîâ êëàññà äëÿ ýòîãî îáúåêòà.

73
74 ЛЕКЦИЯ 9. ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ

9.2 Инкапсуляция и конструкторы

Ìû óæå èñïîëüçîâàëè êëþ÷åâîå ñëîâî class äëÿ ñîçäàíèÿ ñòðóêòóð  íàáîðà èìåíî-
âàííûõ ïîëåé, ñîâîêóïíîñòü êîòîðûõ îïèñûâàåò îáúåêò. Îäíàêî, ìû ïîëüçîâàëèñü äëÿ
èõ îáðàáîòêè îòäåëüíî ëåæàùèìè ôóíêöèÿìè èëè êóñêàìè êîäà.
Áûëî áû íàìíîãî óäîáíåå, åñëè áû îïèñàíèå ñòðóêòóðû îáúåêòà è ìåòîäîâ ðàáîòû
ñ íèì ëåæàëî ðÿäîì, äëÿ óäîáñòâà èçó÷åíèÿ, ìîäèôèêàöèè è èñïîëüçîâàíèÿ.
Ìû áóäåì ðàññìàòðèâàòü ýëåìåíòû ÎÎÏ íà ïðèìåðå êîìïëåêñíûõ (óäàðåíèå íà
¾å¿) ÷èñåë. Ýòî çàáàâíûé ìàòåìàòè÷åñêèé îáúåêò, êîòîðûé ñîñòîèò èç äåéñòâèòåëüíîé
(real)
√ è ìíèìîé (imaginary) ÷àñòè. Çàïèñü ýòî ÷èñëà âûãëÿäèò êàê 𝑟𝑒 + 𝑖𝑚 × 𝑖, ãäå 𝑖
ýòî −1. Ãëóáîêîå ìàòåìàòè÷åñêîå ïîíèìàíèå êîìïëåêñíûõ ÷èñåë íàì íå ïîíàäîáèòñÿ:
äîñòàòî÷íî ïîíèìàòü, ÷òî ýòî ñòðóêòóðà ñ äâóìÿ ïîëÿìè re è im, ãäå îáà ýòè ïîëÿ 
âåùåñòâåííûå ÷èñëà.
Äëÿ ñîçäàíèÿ íîâûõ îáúåêòîâ êëàññà èñïîëüçóåòñÿ ñïåöèàëüíûé ìåòîä, êîòîðûé
íàçûâàåòñÿ ¾êîíñòðóêòîð¿. Ìåòîäû êëàññà çàïèñûâàþòñÿ âíóòðè îïèñàíèÿ êëàññà êàê
ôóíêöèè, êîíñòðóêòîð äîëæåí íàçûâàòüñÿ __init__.  êà÷åñòâå ïåðâîãî ïàðàìåòðà
îíè äîëæíû ïðèíèìàòü ïåðåìåííóþ self  êîíêðåòíûé îáúåêò êëàññà, ñ êîòîðûì îíè
ðàáîòàþò.
Ðàññìîòðèì êëàññ äëÿ âåùåñòâåííîãî ÷èñëà, âûçîâ êîíñòðóêòîðà è ïå÷àòü ïîëåé
îáúåêòà:
c l a s s Complex :
def __init__ ( s e l f , r e =0, im =0):
s e l f . re = re
s e l f . im = im

a = Complex ( 1 , 2 )
b = Complex ( 3 )
c = Complex ( )
print ( a . re , a . im )
print ( b . re , b . im )
print ( c . re , c . im )

Çäåñü êîíñòðóêòîð ñîäåðæèò òðè ïàðàìåòðà: self  ïóñòîé îáúåêò êëàññà Complex, re
è im ïî óìîë÷àíèþ ðàâíûå íóëþ. Âûçîâ êîíñòðóêòîðà îñóùåñòâëÿåòñÿ ñ ïîìîùüþ íà-
ïèñàíèÿ íàçâàíèÿ êëàññà, â ñêîáêàõ óêàçûâàþòñÿ ïàðàìåòðû êîíñòðóêòîðà (âñå, êðîìå
self). Íàçâàíèÿ êëàññîâ ïðèíÿòî çàïèñûâàòü ñ áîëüøîé áóêâû, à îáúåêòû  ñ ìàëåíüêîé.
Âûâîä ýòîé ïðîãðàììû áóäåò:
12
30
00
Îáðàòèòå âíèìàíèå, ÷òî ìû ìåíÿåì ïåðåìåííûå êîíêðåòíîãî îáúåêòà êëàññà, êîòî-
ðûé ïåðåäàí â êà÷åñòâå ïàðàìåòðà self. Åñëè ìû ñîçäàëè êàêèå-òî ïåðåìåííûå â îïè-
ñàíèè êëàññà, òî èõ çíà÷åíèÿ áûëè áû äîñòóïíû âî âñåõ îáúåêòàõ ýòîãî êëàññà è èõ
ìîæíî áûëî áû äàæå èçìåíèòü, ïåðå÷èñëèâ èõ èìåíà â íà÷àëå ìåòîäà ïîñëå âûðàæåíèÿ
nonlocal. Òàêèå ïåðåìåííûå íàçûâàþòñÿ ñòàòè÷åñêèìè, îáû÷íî îíè ïðåäíàçíà÷åíû äëÿ
õðàíåíèÿ êàêèõ-òî êîíñòàíò (÷òî î÷åíü óäîáíî åñëè âû, íàïðèìåð, îïèñûâàåòå êàêîé-òî
êëàññ äëÿ ôèçè÷åñêèõ âû÷èñëåíèé). Èõ èçìåíåíèå ìîæåò ïîíàäîáèòñÿ â ýêçîòè÷åñêèõ
9.3. ОПРЕДЕЛЕНИЕ МЕТОДОВ И СТАНДАРТНЫЕ ФУНКЦИИ 75

ñèòóàöèÿõ, íàïðèìåð, ïðè ïîäñ÷åòå êîëè÷åñòâà îáúåêòîâ êëàññà. Ìû íå áóäåì çàîñòðÿòü


íà íèõ âíèìàíèå.

9.3 Определение методов и стандартные функции

Íåêîòîðûå ñòàíäàðòíûå ôóíêöèè ÿçûêà Ïèòîí ÿâëÿþòñÿ âñåãî-ëèøü îáåðòêàìè íàä


âûçîâîì ìåòîäà äëÿ ïåðåäàâàåìîãî ïàðàìåòðà. Íàïðèìåð, ôóíêöèÿ str âûçûâàåò ìåòîä
__str__ äëÿ ñâîåãî ïàðàìåòðà. Åñëè ìû îïèøåì òàêîé ìåòîä äëÿ íàøåãî êëàññà, òî
ìîæíî áóäåò ïðèìåíÿòü ê íåìó ôóíêöèþ str ÿâíî è íåÿâíî (íàïðèìåð, îíà àâòîìàòè-
÷åñêè âûçîâåòñÿ ïðè âûçîâå print äëÿ îáúåêòà íàøåãî êëàññà).
Ìû áû õîòåëè, ÷òîáû __str__ âîçâðàùàë òåêñòîâîå ïðåäñòàâëåíèå íàøåãî êîìïëåêñ-
íîãî ÷èñëà. Íàïðèìåð, ÷èñëî ñ äåéñòâèòåëüíîé ÷àñòüþ 1 è ìíèìîé 2 äîëæíî áûòü ïðåä-
ñòàâëåíî â âèäå ñòðîêè 1+2i, à ÷èñëî ñ äåéñòâèòåëüíîé ÷àñòüþ 3 è ìíèìîé -4.5  êàê
3-4.5i. Ïîëíîå îïèñàíèå êëàññà ñ äîáàâëåííûì ìåòîäîì áóäåò âûãëÿäåòü òàê:
c l a s s Complex :
def __init__ ( s e l f , r e =0, im =0):
s e l f . re = re
s e l f . im = im
def __str__( s e l f ) :
strRep = s t r ( s e l f . r e )
i f s e l f . im >= 0 :
strRep += '+ '
strRep += s t r ( s e l f . im ) + ' i '
return strRep

a = Complex ( 1 , 2 )
print ( a )
b = Complex ( 3 , − 4.5)
print ( b )

9.4 Переопределение операторов

 ÿçûêå Ïèòîí ìîæíî ïåðåîïðåäåëèòü è ïîâåäåíèå îïåðàòîðîâ. Íàïðèìåð, åñëè


ó íàñ åñòü äâà ÷èñëà x è y, òî çàïèñü x + y ðåàëüíî ïðåîáðàçóåòñÿ â âûçîâ ìåòîäà
x.__add__(y). Çíà÷îê îïåðàöèè + ÿâëÿåòñÿ âñåãî ëèøü óäîáíûì äëÿ ÷åëîâåêà ïåðå-
îïðåäåëåíèåì âûçîâà ìåòîäà add.
Äëÿ âåùåñòâåííûõ ÷èñåë ëîãè÷íî îïðåäåëåíà îïåðàöèÿ ñëîæåíèÿ: ýòî ñëîæåíèå îò-
äåëüíî äåéñòâèòåëüíûõ è îòäåëüíî ìíèìûõ ÷àñòåé.  ðåçóëüòàòå âûçîâà ìåòîäà äëÿ
ñëîæåíèÿ äâóõ ÷èñåë äîëæåí êîíñòðóèðîâàòüñÿ íîâûé îáúåêò êëàññà Complex, à ïåðå-
äàííûå â êà÷åñòâå ïàðàìåòðîâ îáúåêòû íå äîëæíû èçìåíÿòüñÿ. Äåéñòâèòåëüíî, êîãäà
ìû âûïîëíÿåì îïåðàöèÿ z = x + y äëÿ îáû÷íûõ ÷èñåë, òî îæèäàåì, ÷òî ñêîíñòðóèðóåòñÿ
íîâûé îáúåêò, ê êîòîðîìó ïðèâÿæåòñÿ ññûëêà z, à x è y îñòàíóòñÿ áåç èçìåíåíèÿ.
Áóäåì ïðèäåðæèâàòüñÿ ýòîé æå ëîãèêè ïðè ðåàëèçàöèè ìåòîäà äëÿ ñëîæåíèÿ äâóõ
êîìïëåêñíûõ ÷èñåë. Íàø ìåòîä _add äîëæåí ïðèíèìàòü äâà ïàðàìåòðà, êàæäûé èç
êîòîðûõ ÿâëÿåòñÿ êîìïëåêñíûì ÷èñëîì.
76 ЛЕКЦИЯ 9. ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ

c l a s s Complex :
def __init__ ( s e l f , r e =0, im =0):
s e l f . re = re
s e l f . im = im
def __str__( s e l f ) :
strRep = s t r ( s e l f . r e )
i f s e l f . im >= 0 :
strRep += '+ '
strRep += s t r ( s e l f . im ) + ' i '
return strRep
def __add__( s e l f , o t h e r ) :
newRe = s e l f . r e + o t h e r . r e
newIm = s e l f . im + o t h e r . im
return Complex ( newRe , newIm )

a = Complex ( 1 , 2 )
b = Complex ( 3 , − 4.5)
print ( a + b )

Ïåðåîïðåäåëÿòü ìåòîä add èìååò ñìûñë òîëüêî â òåõ ñèòóàöèÿõ, êîãäà ïðîãðàì-
ìèñòó, èñïîëüçóþùåìó âàø êëàññ, áóäåò î÷åâèäåí ñìûñë îïåðàöèè +. Íàïðèìåð, åñëè
áû âû ñîçäàëè êëàññ äëÿ îïèñàíèå íåêîòîðûõ õàðàêòåðèñòèê ÷åëîâåêà, òî îïåðàöèÿ
+ äëÿ äâóõ îáúåêòîâ-ëþäåé âîñïðèíèìàëàñü ðàçíûìè ïîëüçîâàòåëÿìè âàøåãî êëàññà
ñîâåðøåííî ïî-ðàçíîìó, â çàâèñèìîñòè îò ðàçâèòîñòè ôàíòàçèè ÷èòàòåëÿ. Òàêîãî íåîä-
íîçíà÷íîãî ïîíèìàíèÿ ëó÷øå èçáåãàòü è âîâñå íå ïåðåîïðåäåëÿòü îïåðàöèþ +, åñëè
ðåçóëüòàò å¼ ðàáîòû íå î÷åâèäåí.

9.5 Проверка класса объекта

Ïåðåîïðåäåëèì äëÿ êîìïëåêñíûõ ÷èñåë åù¼ îäíó îïåðàöèþ  óìíîæåíèå. Ïðè ýòîì
ìû õîòèì óìåòü óìíîæàòü êîìïëåêñíûå ÷èñëà êàê íà öåëûå èëè äåéñòâèòåëüíûå, òàê
è íà äðóãèå êîìïëåêñíûå ÷èñëà.
Ïðè óìíîæåíèè êîìïëåêñíîãî ÷èñëà âèäà 𝑎 + 𝑏 × 𝑖 íà öåëîå èëè âåùåñòâåííîå ÷èñëî
𝑥 ðåçóëüòàòîì áóäåò êîìïëåêñíîå ÷èñëî 𝑎 × 𝑥 + 𝑏 × 𝑥 × 𝑏.
Ïåðåìåíîæåíèå äâóõ êîìïëåêñíûõ ÷èñåë ïðîèçâîäèòñÿ àíàëîãè÷íî óìíîæåíèþ äâóõ
ìíîãî÷ëåíîâ ïåðâîé ñòåïåíè:

(𝑎 + 𝑏 × 𝑖) × (𝑐 + 𝑑 × 𝑖) = 𝑎 × 𝑐 + (𝑎 × 𝑑 + 𝑏 × 𝑐) × 𝑖 + 𝑏 × 𝑑 × 𝑖2
Ìû çíàåì, ÷òî 𝑖2 = −1. Çíà÷èò îêîí÷àòåëüíî ðåçóëüòàò óìíîæåíèÿ áóäåò âûãëÿäåòü
òàê:

𝑎 × 𝑐 − 𝑏 × 𝑑 + (𝑎 × 𝑑 + 𝑏 × 𝑐) × 𝑖
Íàì îñòàëîñü ïîíÿòü, êàê îïðåäåëèòü, ïåðåäàíî ëè â íàø ìåòîä êîìïëåêñíîå èëè íå
êîìïëåêñíîå ÷èñëî.
 ÿçûêå Ïèòîí ñóùåñòâóåò ôóíêöèÿ isinstance, êîòîðàÿ â êà÷åñòâå ïåðâîãî ïàðàìåò-
ðà ïðèíèìàåò îáúåêò, à â êà÷åñòâå âòîðîãî  íàçâàíèå êëàññà. Îíà âîçâðàùàåò èñòèíó,
9.5. ПРОВЕРКА КЛАССА ОБЪЕКТА 77

åñëè îáúåêò îòíîñèòñÿ ê äàííîìó êëàññó è ëîæü â ïðîòèâíîì ñëó÷àå. Ýòà ôóíêöèÿ
ïîçâîëèò íàì äîáèòüñÿ íóæíîé ôóíêöèîíàëüíîñòè îò ìåòîäà __mul__, óìíîæàþùåãî
÷èñëà.

c l a s s Complex :
def __init__ ( s e l f , r e =0, im =0):
s e l f . re = re
s e l f . im = im
def __str__( s e l f ) :
strRep = s t r ( s e l f . r e )
i f s e l f . im >= 0 :
strRep += '+ '
strRep += s t r ( s e l f . im ) + ' i '
return strRep
def __add__( s e l f , o t h e r ) :
newRe = s e l f . r e + o t h e r . r e
newIm = s e l f . im + o t h e r . im
return Complex ( newRe , newIm )
def __mul__( s e l f , o t h e r ) :
i f i s i n s t a n c e ( o t h e r , Complex ) :
newRe = s e l f . r e * o t h e r . r e − s e l f . im * o t h e r . im
newIm = s e l f . r e * o t h e r . im + s e l f . r e * o t h e r . im
e l i f i s i n s t a n c e ( o t h e r , i n t ) or i s i n s t a n c e ( o t h e r , f l o a t ) :
newRe = s e l f . r e * o t h e r
newIm = s e l f . im * o t h e r
return Complex ( newRe , newIm )
__rmul__ = __mul__

a = Complex ( 1 , 2 )
b = Complex ( 3 , − 4.5)
print ( a * b )
print ( a * 2 )

Êðîìå äîáàâëåííîãî ìåòîäà __mul__ âíèìàíèÿ òàêæå çàñëóæèâàåò ñòðîêà __rmul__ = __mul__.
Ýòî ïðèñâàèâàíèå îäíîãî ìåòîäà (ôóíêöèè) äðóãîìó, ò.å. ïðè âûçîâå ìåòîäà __rmul__
áóäåò âûçûâàòüñÿ òîò æå ñàìûé ìåòîä __mul__.
 ÿçûêå ïèòîí îïåðàöèÿ a * b çàìåíÿåòñÿ íà âûçîâ ìåòîäà a.__mul__(b). Åñëè
a áûëî êîìïëåêñíûì ÷èñëîì, à b  âåùåñòâåííûì, òî âûçîâåòñÿ ìåòîä __mul__ äëÿ
îáúåêòà a íàøåãî êëàññà Complex.
Îäíàêî, åñëè a áûëî âåùåñòâåííûì ÷èñëîì, à b  êîìëåêñíûì, òî ïðîèçîéäåò ïîïûò-
êà âûçâàòü ìåòîä __mul__ äëÿ îáúåêòà êëàññà oat. Åñòåñòâåííî, ðàçðàáîò÷èêè ñòàí-
äàðòíîé áèáëèîòåêè ÿçûêà Ïèòîí íå ìîãëè ïðåäïîëîæèòü, ÷òî âû êîãäà-íèáóäü íàïè-
øèòå êëàññ Complex è áóäåòå ïûòàòüñÿ óìíîæèòü íà íåãî âåùåñòâåííîå ÷èñëî, ïîýòîìó
ìåòîä __mul__, ãäå â êà÷åñòâå ïàðàìåòðà ïåðåäàåòñÿ íå÷òî íåèçâåñòíîå, áóäåò çàêàí-
÷èâàòü ñâîþ ðàáîòó ñ îøèáêîé. ×òîáû èçáåæàòü òàêèõ ñèòóàöèé â ÿçûêå Ïèòîí ïîñëå
íåóäà÷íîé ïîïûòêè ñîâåðøèòü a.__mul__(b) ïðîñõîäèò ïîïûòêà ñîâåðøèòü äåéñòâèå
b.__rmul__(a) è â íàøåì ñëó÷àå îíà çàêàí÷èâàåòñÿ óñïåõîì.
78 ЛЕКЦИЯ 9. ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ

9.6 Обработка ошибок

Âðåìÿ îò âðåìåíè â ïðîãðàììàõ âîçíèêàþò îøèáî÷íûå ñèòóàöèè, êîòîðûå íå ìîãóò


áûòü îáðàáîòàíû â òîì ìåñòå, ãäå âîçíèêëà îøèáêà, à äîëæíû áûòü îáðàáîòàíû òåì
èëè èíûì îáðàçîì â áîëåå âíåøíåé ÷àñòè ïðîãðàììû.
Íàïðèìåð, åñëè íà ýòàïå âûïîëíåíèÿ ïðîìåæóòî÷íîé ëîãèêè îáíàðóæèëîñü, ÷òî âû
ïûòàåòåñü çàïèñàòü ñòðîêó â òî, ÷òî äîëæíî áûòü ÷èñëîì, òî âû íè÷åãî íå ìîæåòå
ñ ýòèì ñäåëàòü.  òàêîì ñëó÷àå íóæíî âûâàëèâàòüñÿ èç ñòåêà âûçîâîâ ôóíêöèé èëè
ìåòîäîâ ïðîìåæóòî÷íîé ëîãèêè äî òåõ ïîð, ïîêà ìû íå äîéäåì äî ôðîíòåíäà, êîòîðûé
ñîîáùèò ïîëüçîâàòåëþ î òîì, ÷òî îí ââåë íåäîïóñòèìîå çíà÷åíèå è ïîïðîñèò, íàïðèìåð,
ââåñòè åãî çàíîâî.
Íàâåðíÿêà âû ñòàëêèâàëèñü ñ ñèòóàöèåé çàïîëíåíèÿ îãðîìíîé ôîðìû, ïîïûòêà îò-
ïðàâèòü êîòîðóþ ïðèâîäèëà ê òîìó, ÷òî ïîÿâëÿëîñü îêîøêî ñî ñëîâîì ¾îøèáêà¿ áåç
êàêèõ-ëèáî óòî÷íåíèé. Ýòî ïëîõîé ñòèëü, ñîîáùåíèå îá îøèáêå äîëæíî áûòü èíôîðìà-
òèâíûì, ÷òîáû ïîçâîëèòü áûñòðî å¼ íàéòè è èñïðàâèòü. Òàêèì îáðàçîì, ïðè ñîçäàíèè
îøèáêè íóæíî ïåðåäàâàòü èñ÷åðïûâàþùóþ èíôîðàìàöèþ î íåé.
 íàøåì ïðèìåðå ñ âåùåñòâåííûìè ÷èñëàìè ìû ìîæåì ðàññìîòðåòü òàêîé ïðèìåð
îøèáêè: óìíîæåíèå êîìïëåêñíîãî ÷èñëà íà ÷òî-òî, îòëè÷íîå îò öåëîãî, âåùåñòâåííîãî
èëè êîìïëåêñíîãî ÷èñëà. Êîãäà ìû äîøëè äî ýòàïà óìíîæåíèÿ  ìû óæå íè÷åãî íå
ìîæåì ïðåäïðèíÿòü äëÿ èñïðàâëåíèÿ ýòîé îøèáêè, êðîìå êàê ïðîñèãíàëèçèðîâàòü î
íåé â òî ìåñòî, îòêóäà áûëà âûçâàíà íàøà îïåðàöèÿ óìíîæåíèÿ.
Ïðè ýòîì íà ýòàïå âûçîâà îïåðàöèè óìíîæåíèÿ ìû óæå ìîæåì ïðåäïðèíÿòü êàêèå-òî
äåéñòâèÿ. Íàïðèìåð, ñîîáùèòü ïîëüçîâàòåëþ î òîì, êàêóþ ôèãíþ îí ââåë è ïîïðîñèòü
ââåñòè âñå-òàêè êîìïëåêñíîå ÷èñëî. Èëè, åñëè ìû îáðàáàòûâàåì ïîñëåäîâàòåëüíîñòü,
èç êîòîðîé íóæíî âû÷ëåíèòü è ïåðåìíîæèòü êîìïëåêñíûå ÷èñëà  ïðîñòî ïåðåéòè
ê ñëåäóþùåìó ýëåìåíòó ïîñëåäîâàòåëüíîñòè. Íà ýòàïå êîãäà ìû äîøëè äî íåóäà÷íîãî
âûïîëíåíèÿ îïåðàöèÿ óìíîæåíèÿ ìû íå çíàåì è íå ìîæåì çíàòü êàê äîëæíà ñåáÿ âåñòè
êîíêðåòíàÿ ïðîãðàììà ïðè âîçíèêíîâåíèè òàêîé îøèáêè.
Êîãäà ìû äîéäåì äî îøèáî÷íîé îïåðàöèè ìû ìîæåì ñêîíñòðóèðîâàòü ñïåöèàëüíûé
êëàññ, ñîäåðæàùèé ïîäðîáíîå îïèñàíèå îøèáêè è âûáðîñèòü åãî â òî ìåñòî, êîòîðîå
ñïîñîáíî åãî îáðàáîòàòü.
Âûáðàñûâàåòñÿ îøèáêà ñ ïîìîùüþ êîìàíäû raise, à ëîâèòñÿ áëîêîì try-except. Äëÿ
ñëó÷àÿ óìíîæåíèÿ êîìïëåêñíîãî ÷èñëà íà ìóñîð ìû ìîæåì ñêîíñòðóèðîâàòü êëàññ
îøèáêè, ñîäåðæàùèé â ñåáå ññûëêó êàê íà êîìïëåêñíîå ÷èñëî, òàê è íà âòîðîé àð-
ãóìåíò ìåòîäà óìíîæåíèÿ.
Êëàññ äëÿ îøèáêè äîëæåí áûòü íàñëåäíèêîì ñòàíäàðòíîãî êëàññà BaseError. Ïîêà
äëÿ íàñ ýòî çíà÷èò òîëüêî òî, ÷òî ïðè ñîçäàíèè îïèñàíèÿ êëàññà îøèáêè ìû äîëæíû
íàïèñàòü â ñêîáêàõ ïîñëå åãî íàçâàíèÿ BaseError. Ïîòåíöèàëüíî îøèáî÷íûå äåéñòâèÿ
äîëæíû âûïîëíÿòüñÿ â áëîêå try, à êîìàíäû äëÿ îáðàáîòêè îøèáêè äîëæíû áûòü â
áëîêå except. Ïðèìåð ñ îáðàáîòêîé îøèáêè áóäåò âûãëÿäåòü òàê:
c l a s s ComplexError ( BaseException ) :
def __init__ ( s e l f , Complex , o t h e r ) :
s e l f . a r g 1 = Complex
s e l f . arg2 = other

c l a s s Complex :
def __init__ ( s e l f , r e =0, im =0):
9.7. НАСЛЕДОВАНИЕ И ПОЛИМОРФИЗМ 79

s e l f . re = re
s e l f . im = im
def __str__( s e l f ) :
strRep = s t r ( s e l f . r e )
i f s e l f . im >= 0 :
strRep += '+ '
strRep += s t r ( s e l f . im ) + ' i '
return strRep
def __add__( s e l f , o t h e r ) :
newRe = s e l f . r e + o t h e r . r e
newIm = s e l f . im + o t h e r . im
return Complex ( newRe , newIm )
def __mul__( s e l f , o t h e r ) :
i f i s i n s t a n c e ( o t h e r , Complex ) :
newRe = s e l f . r e * o t h e r . r e − s e l f . im * o t h e r . im
newIm = s e l f . r e * o t h e r . im + s e l f . r e * o t h e r . im
e l i f i s i n s t a n c e ( o t h e r , i n t ) or i s i n s t a n c e ( o t h e r , f l o a t ) :
newRe = s e l f . r e * o t h e r
newIm = s e l f . im * o t h e r
else :
r a i s e ComplexError ( s e l f , o t h e r )
return Complex ( newRe , newIm )
__rmul__ = __mul__

a = Complex ( 1 , 2 )
try :
r e s = a * ' abcd '
except ComplexError a s c e :
print ( ' E r r o r i n mul with a r g s : ' , c e . arg1 , c e . a r g 2 )

Âûâîä ýòîé ïðîãðàììû áóäåò:


Error in mul with args: 1+2i abcd
Ïî íåìó ëåãêî ïîíÿòü, ÷òî îøèáêà âîçíèêàåò ïðè îïåðàöèè óìíîæåíèÿ è óâèäåòü,
÷òî áûëî ïåðåäàíî â íå¼ â êà÷åñòâå àðãóìåíòîâ.
Ïîñëå êîìàíäû except ìû ìîæåì óêàçàòü èìÿ êëàññà îøèáêè, êîòîðûé îí äîëæåí
îáðàáàòûâàòü, çàòåì íàïèñàòü as è óêàçàòü èìÿ ïåðåìåííîé â êîòîðóþ ïîïàäåò îáúåêò
ñ îïèñàíèåì êîíêðåòíîé îøèáêè.
Áëîêîâ except ìîæåò áûòü íåñêîëüêî äëÿ îáðàáîòêè îøèáîê ðàçíûõ òèïîâ. Ïðâîåð-
êè âûïîëíÿþòñÿ ïîñëåäîâàòåëüíî, áóäåò âûïîëíåí òîò áëîê êîìàíä, ó êîòîðîãî èìÿ
êëàññà ñîâïàäàåò ñ èìåíåì êëàññà îøèáêè èëè ÿâëÿåòñÿ åãî ïðåäêîì â äåðåâå èåðàðõèè
íàñëåäîâàíèÿ.

9.7 Наследование и полиморфизм

Îïåðàöèè ñëîæåíèÿ è óìíîæåíèÿ íà âåùåñòâåííîå èëè öåëîå ÷èñëî äëÿ êîìïëåêñ-


íûõ ÷èñåë î÷åíü ïîõîæè íà ïîâåäåíèå ñâîáîäíûõ âåêòîðîâ íà ïëîñêîñòè. Îíè ñîîòâåò-
ñòâóþò ñëîæåíèþ âåêòîðîâ èëè óìíîæåíèå âåêòîðà íà ÷èñëî, ãäå äåéñòâèòåëüíàÿ ÷àñòü
80 ЛЕКЦИЯ 9. ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ

êîìïëåêñíîãî ÷èñëà ÿâëÿåòñÿ x-êîîðäèíàòîé âåêòîðà, à ìíèìàÿ  y-êîîðäèíàòîé.


Êðîìå òîãî, ñâîáîäíûé âåêòîð îáëàäàåò íåêîòîðûìè îïåðàöèÿìè, êîòîðûå õàðàêòåð-
íû òîëüêî äëÿ íåãî, íî íå äëÿ âåùåñòâåííîãî ÷èñëà. Íàïðèìåð, ýòî ìîæåò áûòü ìåòîä
length, âû÷èñëÿþùèé äëèíó âåêòîðà. Íàì íå õîòåëîñü áû çàñîðÿòü êîä äëÿ îïèñàíèÿ
êîìïëåêñíîãî ÷èñëà ìåòîäàìè äëÿ ðàáîòû ñî ñâîáîäíûì âåêòîðîì, íî ñ äðóãîé ñòîðî-
íû íå õîòåëîñü áû çàíîâî ïåðåïèñûâàòü ìåòîäû ñëîæåíèÿ è óìíîæåíèÿ äëÿ ñâîáîäíûõ
âåêòîðîâ.
 òàêîé ñèòóàöèè ðàçóìíî ñîçäàòü íîâûé êëàññ äëÿ îïèñàíèÿ ñâîáîäíîãî âåêòîðà
(èëè òî÷êè íà ïëîñêîñòè, ÷òî òî æå ñàìîå), êîòîðûé óíàñëåäîâàë áû âñå ìåòîäû êîì-
ïëåêñíûõ ÷èñåë è äîáàâèë áû íîâûé ìåòîä length.
Ìû óæå çíàåì, ÷òî äëÿ òîãî, ÷òîáû ïðîíàñëåäîâàòü êëàññ îò äðóãîãî äîñòàòî÷íî â
îïèñàíèè êëàññà óêàçàòü â êðóãëûõ ñêîáêàõ, îò êîãî îí íàñëåäóåòñÿ. Òàêèì îáðàçîì,
ìû ìîæåì çàïèñàòü íàøå îïèñàíèå êëàññà Point ñ îïðåäåëåííûì ìåòîäîì length òàê:

c l a s s ComplexError ( BaseException ) :
def __init__ ( s e l f , Complex , o t h e r ) :
s e l f . a r g 1 = Complex
s e l f . arg2 = other

c l a s s Complex :
def __init__ ( s e l f , r e =0, im =0):
s e l f . re = re
s e l f . im = im
def __str__( s e l f ) :
strRep = s t r ( s e l f . r e )
i f s e l f . im >= 0 :
strRep += '+ '
strRep += s t r ( s e l f . im ) + ' i '
return strRep
def __add__( s e l f , o t h e r ) :
newRe = s e l f . r e + o t h e r . r e
newIm = s e l f . im + o t h e r . im
return Complex ( newRe , newIm )
def __mul__( s e l f , o t h e r ) :
i f i s i n s t a n c e ( o t h e r , Complex ) :
newRe = s e l f . r e * o t h e r . r e − s e l f . im * o t h e r . im
newIm = s e l f . r e * o t h e r . im + s e l f . r e * o t h e r . im
e l i f i s i n s t a n c e ( o t h e r , i n t ) or i s i n s t a n c e ( o t h e r , f l o a t ) :
newRe = s e l f . r e * o t h e r
newIm = s e l f . im * o t h e r
else :
r a i s e ComplexError ( s e l f , o t h e r )
return Complex ( newRe , newIm )
__rmul__ = __mul__

c l a s s Po in t ( Complex ) :
def l e n g t h ( s e l f ) :
9.8. ПЕРЕОПРЕДЕЛЕНИЕ МЕТОДОВ 81

return ( s e l f . r e ** 2 + s e l f . im * * 2 ) * * ( 1 / 2 )

a = P oi nt ( 3 , 4 )
b = Complex ( 1 , 2 )
print ( a . l e n g t h ( ) )
c = a + b
print ( c )
Âûâîä ýòîé ïðîãðàììû áóäåò
5.0
4+6i
Çäåñü ìû íå òîëüêî óáåäèëèñü â òîì, ÷òî ñâåæåñîçäàííûé ìåòîä ðàáîòàåò, íî è ñäå-
ëàëè äîâîëüíî ñòðàííóþ âåùü: ñëîæèëè òî÷êó íà ïëîñêîñòè ñ êîìïëåêñíûì ÷èñëîì.
Äåëî â òîì, ÷òî îáúåêòà êëàññà Point òàêæå îäíîâðåìåííî ÿâëÿåòñÿ è îáúåêòîì òè-
ïà Complex, ò.ê. Point ïðîíàñëåäîâàí îò Complex. Point ëèøü ðàñøèðÿåò è äîïîëíÿåò
Complex, à çíà÷èò Point ìîæåò ñìåëî áûòü èíòåðïðåòèðîâàí êàê Complex, íî íå íàîá-
ðîò.
 ýòîì ïðèìåðå áóäóò èñòèííû âûðàæåíèÿ isinstance(a, Point) è isinstance(a, Complex),
íî áóäåò ëîæíî âûðàæåíèå isinstance(b, Point).

9.8 Переопределение методов

Åñëè ìû ïîïûòàåìñÿ íàïå÷àòàòü îáúåêò òèïà Point, òî îí íàïå÷àòàåòñÿ êàê êîì-


ïëåêñíîå ÷èñëî. Íàì õîòåëîñü áû, ÷òîáû òî÷êè íà ïëîñêîñòè ïå÷àòàëèñü â âèäå (x, y),
à íå x+yi.
 ÿçûêå Ïèòîí ëþáîé ìåòîä ìîæíî ïåðåîïðåäåëèòü â íàñëåäíèêå, ÷òî ìû è ñäåëàåì
äëÿ ìåòîäà __str__ äëÿ êëàññà Point:
c l a s s ComplexError ( BaseException ) :
def __init__ ( s e l f , Complex , o t h e r ) :
s e l f . a r g 1 = Complex
s e l f . arg2 = other

c l a s s Complex :
def __init__ ( s e l f , r e =0, im =0):
s e l f . re = re
s e l f . im = im
def __str__( s e l f ) :
strRep = s t r ( s e l f . r e )
i f s e l f . im >= 0 :
strRep += '+ '
strRep += s t r ( s e l f . im ) + ' i '
return strRep
def __add__( s e l f , o t h e r ) :
newRe = s e l f . r e + o t h e r . r e
newIm = s e l f . im + o t h e r . im
return Complex ( newRe , newIm )
def __mul__( s e l f , o t h e r ) :
82 ЛЕКЦИЯ 9. ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ

i f i s i n s t a n c e ( o t h e r , Complex ) :
newRe = s e l f . r e * o t h e r . r e − s e l f . im * o t h e r . im
newIm = s e l f . r e * o t h e r . im + s e l f . r e * o t h e r . im
e l i f i s i n s t a n c e ( o t h e r , i n t ) or i s i n s t a n c e ( o t h e r , f l o a t ) :
newRe = s e l f . r e * o t h e r
newIm = s e l f . im * o t h e r
else :
r a i s e ComplexError ( s e l f , o t h e r )
return Complex ( newRe , newIm )
__rmul__ = __mul__

c l a s s Po in t ( Complex ) :
def l e n g t h ( s e l f ) :
return ( s e l f . r e ** 2 + s e l f . im * * 2 ) * * ( 1 / 2 )
def __str__( s e l f ) :
return s t r ( ( s e l f . re , s e l f . im ) )

a = P oi nt ( 3 , 4 )
print ( a )
Íàø ìåòîä îáÿçàí âîçâðàùàòü ñòðîêó, íî ìû ìîæåì âîñïîëüçîâàòüñÿ ôóíêöèåé str
îò êîðòåæà, êîòîðàÿ âûäàñò íàì íóæíûé ðåçóëüòàò.

9.9 Проектирование структуры классов

Ñòðóêòóðà îïèñàíèÿ êëàññîâ ïðåäñòàâëÿåò ñîáîé äåðåâî (íà ñàìîì äåëå â Ïèòîíå 
àöèêëè÷åñêèé ãðàô), ïðîíàñëåäîâàííûé îò åäèíîãî êîðíÿ  áàçîâîãî ïóñòîãî êëàññà.
Ñ ïîìîùüþ ãðàìîòíî ñïðîåêòèðîâàííîé ñòðóêòóðû êëàññîâ ìîæíî äîáèòüñÿ ëåã-
êîé ÷èòàåìîñòè è ìàêñèìàëüíîãî ïîâòîðíîãî èñïîëüçîâàíèÿ êîäà, îáåñïå÷åíèÿ åäèíîãî
èíòåðôåéñà è ìíîæåñòâî äðóãèõ ðàäîñòåé.
Îäíàêî, âíåñåíèå ôè÷è èëè èçìåíåíèå íà âûñîêîì óðîâíå èåðàðõèè êëàññîâ ìîæåò
ïðèâåñòè ê íåîáõîäèìîñòè âûïîëíèòü îãðîìíîå êîëè÷åñòâî ðàáîòû ïî ìîäèôèêàöèè
âñåõ ïîòîìêîâ ýòîãî êëàññà, à òàêæå ê ïîëíîé íåñîâìåñòèìîñòè ñ ïðåäûäóùåé âåðñèåé.
Ìíîãî÷èñëåííûå èçìåíåíèÿ òàêîãî ðîäà ïðèâîäÿò ê óðîäëèâûì êîíñòðóêöèÿì, êîòîðûå
íåâîçìîæíî ïîíèìàòü è îòëàæèâàòü.
 òî æå âðåìÿ, çàêëàäûâàíèå ïåðñïåêòèâíûõ ôè÷åé â ñòðóêòóðó êëàññîâ âåäåò ê
ïåðåóñëîæíåíèþ è ñâîäèò íà íåò âñå ïîâòîðíîå èñïîëüçîâàíèå êîäà çà ñ÷åò ãðîìîçäêî-
ñòè êîíñòðóêöèé. Êðîìå òîãî, ïåðñïåêòèâíûå ôè÷è ìîãóò áûòü íåäîñòàòî÷íî îáäóìàíû
è ïðèâåäóò ê åùå áîëüøåìó óðîäñòâó, êîãäà äåëî äîéäåò äî èõ ðåàëüíîé ðåàëèçàöèè
(åñëè äîéäåò).
Òàêèì îáðàçîì, ãðàìîòíîå ïðîåêòèðîâàíèå ñèñòåìû êëàññîâ òðåáóåò íå òîëüêî õî-
ðîøåãî çíàíèÿ ïàòòåðíîâ ïðîåêòèðîâàíèÿ, íî è áîëüøîãî ïðàêòè÷åñêîãî îïûòà. Íà
íà÷àëüíîì ýòàïå ñòîèò îáó÷àòüñÿ ïðîåêòèðîâàíèþ ñèñòåì, â êîòîðûå íå ïëàíèðóåòñÿ
âíåñåíèå èçìåíåíèé.