Начнем Python. Просто о сложном [С. С. Иванов] (pdf) читать онлайн

Иванов С. С.

НАЧНЕМ

PYTHON
ПРОСТО о сложном

’’Издательство Наука и Техника
Санкт-Петербург

УДК 004.42
ББК 32.973

Иванов С. С.

Hahhem.Python. Просто
и

О СЛОЖНОМ —

СПб.: Издательство Наука

Техника, 2023. — 368 с., ил.

ISBN 978-5-907592-23-0
Данная книга поможет вам в изучении языка программирования Python.

Многоцелевая направленность Python позволяет решать самые разные задачи: ма­
тематические, физические, лингвистические, бухгалтерские, экономические, зани­
маться созданием игр(!), работой в Интернете и многое другое.

Отличием книги является легкий, понятный и даже где-то юмористический подход
автора к программированию на Python, благодаря чему вы будете учиться писать
программы, ошибаться вместе с автором, исправлять ошибки и любоваться на гото­
вые работоспособные программы...
В книге рассмотрены все ключевые аспекты Python: переменные, операторы, логи­
ческие выражения, циклы, комментарии, функции, рекурсия, строки, кортежи, сло­
вари и множества. В каждой главе теоретическую часть дополняют многочисленные
практические примеры и задания для самостоятельного решения (впрочем, для са­
мых нетерпеливых в конце книги приводятся правильные ответы).
Книга предназначена для широкого круга читателей, не требует навыков в програм­
мировании и будет полезна всем, кто хочет познакомиться с Python.

Все права защищены Никакая часть данной книги не может быть воспроизведена в какой бы то ни было форме без письменно! о разрешения
владельцев авторских прав

Издательство не несет озвегственности за возможный ущерб, причиненный в ходе использования ма1сриалон данной книги, а закже »а
доступность мазериалов, ссылки на которые вы можете найти в этой книге На момент подготовки книги к изданию вес ссылки на интернс!ресурсы были действующими Информация, содержащаяся в данной книге, получена из источников, рассма!ривасмых издательством как
надежные Тем нс менее, имея в виду возможные человеческие или технические ошибки, издательство не может i арантировать абсолютную
точность и полнозу приводимых сведений и не несет ответственности за возможные ошибки, связанные с использованием киш и

Контактные телефоны издательства:

(812)412 70 26

Официальный сайт: www.nit.eom.ru
©

Иванов С. С.

©

Издательство Наука и Техника (оригинал-макет)

Содержание

Введение......................................................................................................... 11

Глава 1. ПЕРЕМЕННЫЕ............................................................................ 19

Глава 2. АРИФМЕТИЧЕСКИЕ ОПЕРАТОРЫ .................................... 25

Глава 3. Первая программа.....................................................................33

Глава 4. Ещё операторы.......................................................................... 43

Глава 5. УСЛОВНЫЕ ОПЕРАТОРЫ ..................................................... 63

Глава 6. ЛОГИЧЕСКИЕ ВЫРАЖЕНИЯ............................................ 71

Глава 7. ЦИКЛЫ.......................................................................................... 79

Глава 8. КОММЕНТАРИИ......................................................................... 95

3

Глава 9. ОБОЛОЧКА IDLE.......................................................................99

Глава 10. ФУНКЦИИ.................................................................................105

Глава 11. МАТЕМАТИЧЕСКИЕ ФУНКЦИИ...................................... 121

Глава 12. РЕКУРСИЯ.............................................................................. 133

Глава 13. СТРОКИ.................................................................................... 139

Глава 14. СПИСКИ.................................................................................... 155

Глава 15. КОРТЕЖИ.................................................................................169

Глава 16. СЛОВАРИ.................................................................................177

Глава 17. МНОЖЕСТВО......................................................................... 185

Глава 18. Что-то пошло не так..........................................................197

Глава 19. Извне.......................................................................................... 207

Глава 20. Ну-ка все вместе................................................................... 219

Глава 21. Время поиграть............................................................... 235

ОТВЕТЫ НА УПРАЖНЕНИЯ....................................................... 241
УПРАЖНЕНИЕ 0.1...................................................................................................... 242

УПРАЖНЕНИЕ 1.1...................................................................................................... 242
УПРАЖНЕНИЕ 2.1....................................................................................................... 242
УПРАЖНЕНИЕ 2.2....................................................................................................... 243
УПРАЖНЕНИЕ 3.0...................................................................................................... 244

УПРАЖНЕНИЕ 3.1...................................................................................................... 244
УПРАЖНЕНИЕ 3.2...................................................................................................... 246
УПРАЖНЕНИЕ 3.3...................................................................................................... 247

УПРАЖНЕНИЕ 3.4...................................................................................................... 248
УПРАЖНЕНИЕ 4.1...................................................................................................... 250
УПРАЖНЕНИЕ 4.2...................................................................................................... 250
УПРАЖНЕНИЕ 4.3....................................................................................................... 252

УПРАЖНЕНИЕ 4.4....................................................................................................... 253

УПРАЖНЕНИЕ 4.5....................................................................................................... 253
УПРАЖНЕНИЕ 4.6....................................................................................................... 254

УПРАЖНЕНИЕ 4.7....................................................................................................... 254
УПРАЖНЕНИЕ 5.1...................................................................................................... 255
УПРАЖНЕНИЕ 5.2...................................................................................................... 256

УПРАЖНЕНИЕ 5.3...................................................................................................... 257
УПРАЖНЕНИЕ 5.4...................................................................................................... 257

УПРАЖНЕНИЕ 5.5...................................................................................................... 258
УПРАЖНЕНИЕ 6.1...................................................................................................... 260
УПРАЖНЕНИЕ 6.2...................................................................................................... 261

УПРАЖНЕНИЕ 6.3.......................................................................................................262
УПРАЖНЕНИЕ 6.4...................................................................................................... 262
УПРАЖНЕНИЕ 6.5...................................................................................................... 263
УПРАЖНЕНИЕ 6.6...................................................................................................... 263

УПРАЖНЕНИЕ 6.7..................................................................................................... 263
УПРАЖНЕНИЕ 7.1...................................................................................................... 264
УПРАЖНЕНИЕ 7.2...................................................................................................... 264
УПРАЖНЕНИЕ 7.3...................................................................................................... 265

УПРАЖНЕНИЕ 7.4...................................................................................................... 265
УПРАЖНЕНИЕ 7.5...................................................................................................... 265
УПРАЖНЕНИЕ 7.6...................................................................................................... 266

УПРАЖНЕНИЕ 7.7...................................................................................................... 267

УПРАЖНЕНИЕ 7.8...................................................................................................... 269
УПРАЖНЕНИЕ 7.9...................................................................................................... 271
УПРАЖНЕНИЕ 10.1.................................................................................................... 273
УПРАЖНЕНИЕ 10.2.................................................................................................... 273
УПРАЖНЕНИЕ 10.3.................................................................................................... 274
УПРАЖНЕНИЕ 10.3.1................................................................................................. 275

УПРАЖНЕНИЕ 10.4.................................................................................................... 275

УПРАЖНЕНИЕ 10.5.................................................................................................... 276
УПРАЖНЕНИЕ 10.6.................................................................................................... 277

УПРАЖНЕНИЕ 11.1.................................................................................................... 278
УПРАЖНЕНИЕ 11.2.................................................................................................... 279

УПРАЖНЕНИЕ 11.3.................................................................................................... 285
УПРАЖНЕНИЕ 11.4.................................................................................................... 285

УПРАЖНЕНИЕ 12.1.................................................................................................... 286
УПРАЖНЕНИЕ 12.2.................................................................................................... 287
УПРАЖНЕНИЕ 12.3.................................................................................................... 287
УПРАЖНЕНИЕ 13.1.................................................................................................... 288
УПРАЖНЕНИЕ 13.2.................................................................................................... 288

УПРАЖНЕНИЕ 13.3.................................................................................................... 291
УПРАЖНЕНИЕ 13.3.1................................................................................................. 291
УПРАЖНЕНИЕ 13.4.................................................................................................... 292

УПРАЖНЕНИЕ 13.5.................................................................................................... 292
УПРАЖНЕНИЕ 13.6.................................................................................................... 293

УПРАЖНЕНИЕ 14.1.................................................................................................... 294
УПРАЖНЕНИЕ 14.2.................................................................................................... 294
УПРАЖНЕНИЕ 14.3.................................................................................................... 294
УПРАЖНЕНИЕ 14.4.................................................................................................... 295
УПРАЖНЕНИЕ 14.5.................................................................................................... 296

УПРАЖНЕНИЕ 14.6.................................................................................................... 296
УПРАЖНЕНИЕ 14.7.................................................................................................... 298

УПРАЖНЕНИЕ 14.8.................................................................................................... 300
УПРАЖНЕНИЕ 15.1 ................................................................................................... 302

УПРАЖНЕНИЕ 15.2.................................................................................................... 303

УПРАЖНЕНИЕ 15.3.................................................................................................... 305
УПРАЖНЕНИЕ 15.4.................................................................................................... 308
УПРАЖНЕНИЕ 16.1.................................................................................................... 309

УПРАЖНЕНИЕ 16.2.................................................................................................... 310
УПРАЖНЕНИЕ 16.3.................................................................................................... 311
УПРАЖНЕНИЕ 17.1.................................................................................................... 312

УПРАЖНЕНИЕ 17.2.................................................................................................... 313
УПРАЖНЕНИЕ 17.3.................................................................................................... 317

УПРАЖНЕНИЕ 17.4.................................................................................................... 318
УПРАЖНЕНИЕ 18.1.................................................................................................... 320
УПРАЖНЕНИЕ 18.2.................................................................................................... 321
УПРАЖНЕНИЕ 19.1.................................................................................................... 322
УПРАЖНЕНИЕ 19.2.1................................................................................................. 323
УПРАЖНЕНИЕ 19.2.2................................................................................................. 324

УПРАЖНЕНИЕ 19.2.3................................................................................................. 325
УПРАЖНЕНИЕ 19.3.................................................................................................... 326

УПРАЖНЕНИЕ 20.1.................................................................................................... 330
УПРАЖНЕНИЕ 20.2.................................................................................................... 331

УПРАЖНЕНИЕ 20.3.................................................................................................... 332
УПРАЖНЕНИЕ 20.4.1................................................................................................. 333
УПРАЖНЕНИЕ 20.4.2................................................................................................. 334

УПРАЖНЕНИЕ 21.1.................................................................................................... 335
УПРАЖНЕНИЕ 21.2.................................................................................................... 336
УПРАЖНЕНИЕ 21.3.................................................................................................... 336

■И

Приложение 1. Основные методы обработки строк................... 345

Приложение 2. Основные методы обработки списков.............. 355

Приложение 3. Основные методы обработки словарей.......... 361

ВВЕДЕНИЕ

Автор в шутку называет эту книгу полуучебником. Что такое? Почему полу­
учебник? Как это прикажете понимать? Это только половина учебника? А
где вторая?
Да нет, конечно... Книга, которую вы держите в руках - как и всякий учеб­
ник, содержит в себе массу упражнений, в которых вы будете учиться писать
программы на чудесном языке Питон, ошибаться вместе с автором, исправ­
лять ошибки и любоваться на готовые работоспособные программы... А вот
в отличие от учебника книга написана нормальным, а не скучным академи­
ческим языком, весело и даже занимательно. Поэтому и получился у нас
полуучебник - не совсем учебник, но и вовсе даже не роман.
Итак, что за зверь такой - питон?

Ну, начнём с того, что питон - это не зверь, а пресмыкающееся (автор, как и
всякий учитель, немного зануда).
А вот Python (далее просто Питон) — многоцелевой высокоуровне­
вый язык программирования. Его название и правда переводится
как «питон» - змея, а произносится как [ pai0an] (в связи с тем, что
русскоязычным людям очень плохо даются звуки 0 и э, мы не будем
умничать и будем называть этот язык просто Питон, но уважительно - с
большой буквы). Но! Назван он не в честь змеи (обидно, да?), а в честь
британской комик-группы, а точнее, популярного телешоу (!) «Летающий
цирк Монти Пайтона».
12

Что значит многоцелевой? Хороший вопрос, как сейчас модно выражать­
ся! Это значит, что с помощью Питона можно решать самые разные задачи:
математические, физические, лингвистические, бухгалтерские, экономиче­
ские, заниматься созданием игр(!), работой в Интернете...

А что такое высокоуровневый? О!... Это долгая история...
Начнём с того, что компьютер - это набор огромного количества транзисто­
ров, тиристоров, резисторов, процессоров... какие ещё слова с окончанием
на «-ор» вы знаете? Там, внутри, почти всё это есть... Так вот, вся эта груда
компонентов совершенно не знает, чего вы от неё хотите! Для объяснения
этим железякам что надо делать, и служит Программное Обеспечение.
Одни программы зажигают экран и выводят на него иконки, другие - опре­
деляют, что я нажал на клавиатуре, третьи - выводят данные на принтер и
музыкальные колонки. А вам в это время надо срочно решить квадратное
(а то и совсем не квадратное) уравнение. Или сосчитать количество букв в
поэме «Полтава». Или сосчитать, сколько дней вы уже прожили на свете и
когда отмечать свой МИЛЛИОННЫЙ день рождения. Все эти задачи мы с
вами скоро решим с помощью Питона.

Компьютер, как вы, надеюсь, знаете, понимает только свой внутренний язык,
состоящий из последовательностей нулей и единиц. Поэтому первоначально
программы выглядели примерно так: а

11101000100011101000110111000010001110101111010100110111011000
0100011110111010111100

(и на самом деле в процессоре компьютера они и сейчас так выглядят).
Однако очень быстро первые программисты, измученные головной болью,
придумали, как избавиться от этого кошмара. Дело в том, что этот поток
нулей и единиц на самом деле компьютер воспринимает кусками опреде­
лённого размера, а каждый кусок означает для компьютера определённую
команду, например: возьми данные из ячейки 1010100010101101 внешней
(довольно медлительной) памяти и загрузи их во второй регистр оператив­
ной (то есть очень быстро исполняемой) памяти, а теперь к первому реги­
стру добавь содержимое второго регистра, а результат помести назад, в пер­
вый регистр.
Такого рода команды уже можно записать более-менее понятным хорошо
подготовленному человеку языком, именуемым Ассемблер (от английского
Assemble - собирать).
ф
13

Получается примерно вот так:
LDA, R2
RST 16
LDA, R1
SUMR1, R2

Дальше компьютер сам, с помощью несложной программы, переводил эти
символы в свой язык единиц и нолей. Писать такие программы уже немного
легче, хотя тоже пока очень тяжело: не очень понятно, надо следить за каж­
дым регистром памяти, помнить в какой ячейке что лежит... Кроме того, у
каждого процессора свой набор команд, а значит, и свой Ассемблер. Ассем­
блер считается языком низкого уровня, но, тем не менее, его изобретение
сильно облегчило жизнь программистов. Теперь вместо ужасающих и длин­
нющих последовательностей нулей и единичек они могли писать просто ко­
манды из символов, отдалённо напоминающих обычный язык.
А вот языки высокого уровня уже созданы на, так сказать, сильно упрощён­
ном человеческом языке (как правило, английском). Теперь компьютер сам
решает, в какой регистр памяти загружать ваши данные, и как их обраба­
тывать, оставляя человеку более интересное занятие - быстро объяснить
компьютеру, что он (человек, конечно) хочет от него (от компьютера, есте­
ственно), получить. И изучить эти языки значительно проще, чем, напри­
мер, английский. Благо в любом языке программирования слов не очень-то
и много - максимум пара сотен. И работают эти языки на большинстве
современных компьютеров. Языков высокого уровня создано несколько со­
тен, и вот в конце XX века, появился, наконец, Питон.
Программы, созданные на Питоне, просты и даже, не побоюсь этого слова элегантны, и, на удивление, кратки - то есть не надо набивать слишком мно­
го «букав» (как сегодня модно писать); а так как исследования показали, что
программисты пишут примерно одинаковое количество строк кода каждый
день независимо от языка, то программы на Питоне создаются несколько
быстрее, чем на других языках программирования.

И вот вам пример: А
>С>ОООХ>^^

Дан текстовый файл «24.txt» из 10е символов X, Y и Z. Надо
определить длину самой длинной последовательности, состо­
ящей из символов X.

14

ф

Решение на Паскале (это тоже язык высокого уровня):
var maxLen, curLen, i: integer;

s: string;
f: text;
begin

assign(f, 24.txt');
reset (f);
readln(f, s);

maxLen := 1;
curLen := 1;
for i:=2 to Length(s) do
if (s[i] = s[i-1 ]) and (s[i] = X’) then
begin

curLen := curLen + 1;
if curLen > maxLen then
maxLen := curLen;
end
else

curLen := 1;
writeln(maxLen);
end.

Решение на Питоне: л
print(max(map(len, open('24.txt').readline().replace('Z', ' ').replace('Y', '

split())))

Ну как? Довольно лаконично, не так ли?
А поскольку Питон поддерживает функциональный, императивный,
объектно-ориентированный и процедурный стили программирования...
Как, вы не понимаете, о чём я? Да я и сам не понял, что написал... Вот после
прочтения моего опуса залезете в Интернет и изучите все эти заумные сти­
ли, а пока - давайте научимся писать несложные (шутка! и довольно слож­
ные тоже) программы на Питоне.

Язык программирования Питон существует примерно с 1991 года и с тех
пор он вошёл в тройку самых популярных языков программирования. На
Питоне написаны сотни тысяч программ, в том числе — Google, YouTube,
Dropbox...
А теперь поговорим об этом.,. Поговорим о том, о чём в современном при­
личном обществе не говорят. Нет, не о том, о чём вы подумали! .. .О зарпла­
тах, конечно! Зарплаты у программистов на Питоне весьма велики, а больше
я вам ничего не скажу - тема очень интимная.
15

Сейчас Питон - самый модный язык программирования, так что изучите
его - и будете модниками. Но - «и на Солнце есть пятна»1...

Дело в том, что Питон - язык-интерпретатор, то есть каждая строчка

I

(

) программы превращается в машинные команды последовательно и тут )
>
же исполняется.
;

А вот, например, в компиляторах (Паскаль, C++) вся программа превраща­
ется в цепочку машинных команд и исполняется вся сразу. Отсюда недоста­
ток Питона - программы на нём не могут выполняться так же быстро, как
программы на полностью компилируемых языках, но программа («код», как
сейчас модно говорить) пишется (и отлаживается) быстрее!
И тем не менее - нахождение всех простых чисел из массива чисел до
1 000 000 - а это 191 813 чисел! - занимает у меня на компе примерно 13
секунд!
^Illllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllt:

| Упражнение 0.1
| Не удивлены? А как быстро вы досчитаете до 1 000 000?
| Ответьте навскидку!
Я11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111П1111ГТ

Возведение 2 в 100 000-ную степень проходит за 0,2 секунды! А результат
- это 30103 цифры! Невообразимо огромное число! Так что производитель­
ность у Питона вполне достаточная для бытовых целей ©. Современные
компьютеры считают так быстро, а новые задачи появляются так часто, что
сейчас скорость разработки программы важнее её скорости выполнения, а
программы на Питоне пишутся быстрее, чем на других популярных языках.
Кроме того, в Питоне существует огромное количество функций и методов,
резко облегчающих и ускоряющих программирование, о которых я немного
попытаюсь вам рассказать в последних главах для того, чтобы окончательно
вдохновить/запугать вас.

И тем не менее, Питон - достаточно простой язык, конечно, не такой про­
стой, как Фортран2... Извините, что-то меня на воспоминания потянуло...
1

2

Вы думали, что это сказал Галилей? А вот и нет! Выражение пришло из поэмы русского
поэта, писателя и политического деятеляХУШвека М. М. Хераскова «Россияда»: «И в
солнце, и в луне есть темные места!»
Фортран - один из самых первых языков программирования высокого уровня. Первый язык
программирования автора
g

I

Но и не такой запутанный, как многие другие языки и вместе с тем доста­
точно мощный, чтобы быстро и эффективно решать достаточно сложные за­
дачи. Ладно, хватить хвалить Питон, давайте на нём работать! Скачивать
установщик Питона надо с официального сайта. Программа бесплатная (!).
Алгоритм следующий:^
Заходим на https://python.org/downloads/windows/, скачиваем установщик
(он называется Windows installer. В зависимости от установленной у вас
на компьютере ОС скачиваем разные установщики! Что такое ОС, наде­
юсь, все знают?). Запускаем установщик с установками по умолчанию.
Всё, Питон готов к работе.

Да, а на чём мы будем писать программы? Кто сказал «на бумажке»? А,
это вы, многоуважаемый дедушка Алгол Фортраныч... Времена, когда
программы писались на бумажке, потом оператор забивал(а) их на перфо­
картах, потом перфокарты загружались в компьютер - прошли безвозврат­
но... Последний завод по выпуску перфокарт был закрыт в ещё прошлом
веке; так что будем писать программы в специальной программе... (М-да,
программа в программе под управлением программы Windows - эдакая
матрёшка на современный лад). Программа (она же среда, она же редак­
тор, она же оболочка!) называется IDLE (да, переводится как «Ленивый»,
но на самом деле названа в честь одного из создателей Питона). IDLE
поставляется вместе с дистрибутивом Питона. Откройте стартовое меню
Windows, выберите All Programs, в папке Python кликните по IDLE, и в
результате видим что-то вроде вот такого (рис. I):

Рисунок 1

Это окно приглашает к интерактивному режиму работы, когда каждая вве­
дённая команда сразу выполняется и выводится на экран. В таком режиме
можно писать и выполнять отдельные команды или выполнять очень
простые программы.

Видите, после »> мигает указатель |.

Это приглашение к работе. Проверим, как это работает.

Набираем: л

»>2+2
и жмём Enter.

Видим:
4
»>

Уррра! Работает! Ну всё, приступаем к работе. Как, я надеюсь, вы догадыва­
етесь, главное действующее лицо в программировании - это Переменные.

Глава 1.

ПЕРЕМЕННЫЕ

Переменная в программировании - это набор букв и цифр, значение
которых может изменяться.

Например, напишите в среде IDLE:
»>Х=1

Это означает, что переменной с именем X присвоено значение 1.
А теперь:

»>Х8=23

Другой переменной, с именем Х8 присвоено значение 23.
А теперь:^

»>Х=3

Значение X стало равно 3. А теперь главная фишка программирования:

»>Х=Х+1

Это не уравнение W. Это значит, что к предыдущему значению X, равному 3,
добавили 1 и теперь X равен 4. Убедимся в этом:

»>Х
(это приказ Питону показать значение X).
Ниже видим
4
Это означает, что переменная X сейчас равна 4.

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

Например:

»>Х= (Х*1.3127-Х) /0.2
»>Х
6.254

Питон аккуратно и очень быстро считает: «сейчас X равен 4, значит, 4 ум­
ножаем на 1.3127, из результата вычитаем X, равный 4 и делим результат на
0.2, получаем 6.254, и поэтому теперь X равен 6,254» ! (символ * на програм­
мистском языке означает умножение).

Имена переменных в Питоне могут содержать только латинские
буквы, цифры и почему-то символ подчёркивания.

Имя не может начинаться с цифры.
Питон чувствителен к регистру: digl, Digl и diGl для него - разные
переменные.
21

Русские буквы в имени переменной применять можно, но настоятельно не
рекомендуется. Символ подчёркивания не следует ставить первым в имени.
Кроме того, в качестве имени переменной нельзя использовать вот эти 33
ключевые слова’.

False

class

finally

is

return

none

continue

for

lambda

try

True

def

from

nonlocal

while

and

del

global

not

with

as

elif

if

or

yield

assert

else

import

pass

break

except

in

raise

Ничего себе списочек! И как их всех запомнить? А и не надо... В любом слу­
чае, если есть сомнения, что это имя совпадёт с ключевым словом (а кроме
того, нельзя использовать и встроенные идентификаторы, список которых
я здесь не привожу, дабы сохранить психическое здоровье моих читателей),
так вот, в таких случаях пишите имя с заглавной буквой, например Class или
eLSe - и Питон спокойно и безошибочно воспримет это как переменную.
Кроме того, эти ключевые слова, набранные в IDLE, загораются цветом, от­
личным от чёрного (это я немного вперёд забежал).
djiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiHiik

1 Упражнение 1.1
| Какие переменные названы правильно:
! Out!, 3R, _3m, 3_m, Cat2y, DooUJ, Almazl996, TU-154, R
| import?

|

T, 0600,

I
I

ГТ“|,
Мы познакомились с понятием переменной в Питоне. Имена
ИЮ1Л переменных в Питоне могут содержать только латинские
* ' п буквы, цифры и символ подчёркивания. Имя не может начи­

наться с цифры. Питон прекрасно различает большие и малень­
кие буквы.

Как-то совершенно незаметно и естественно в моём изложении промелькну­
ли «Арифметические операторы».

Глава 2.

АРИФМЕТИЧЕСКИЕ
ОПЕРАТОРЫ

Арифметические операторы в Питон такие же, как и в математике,
вот только умножению не повезло. Это не крестик и не точка, а звёздочка.

Давайте посмотрим, как они работают.

Пусть X равен 3. Запускаем оболочку IDLE и в ней пишем:

»>Х=3

А переменная Y равна 8:

»>Y=8
Теперь складываем X с Y и результат помещаем... э... ну, назад в пере­
менную X (привыкайте, для программистов это совершенно обычное дело):

»>X=X+Y

Ну и как узнать, чему равен X?!
Надо просто его напечатать:-^

»>х

Ура, получилось - на экране:

11
»>

Если вы желаете сохранить результат своих с Питоном действий - его
(результат) надо обязательно присвоить какой-либо переменной. Давайте
просто напишем: п

»>X+Y
На экране:

19
»>
Не забываем, что сейчас X равен 11, a Y равен 8, так что результат правиль­
ный, вот только послушный Питон его никуда не поместил, приговаривая
про себя: «Хозяин, я сложил X и Y... А куда поместить результат? Не указана
переменная? Ну тогда помещу результат на экран, а дальше сам разбирай­
ся...»

Проверим:

»>Х
11

»>
Естественно, X не изменился!

Ну тогда займёмся вычитанием:

»>Y=X-Y

И чему теперь равен Y?

»>Y
3
»>
Всё правильно: 11-8 будет 3!

Умножение:

>»Z=X*Y

Результат находится в новой переменной Z:

33

А теперь деление (сейчас X равен 11, a Y равен 3):
»>Z=X/Y
»>Z
3.6666666666666665

Да, переменные у нас получились двух типов: целые и ...? Правильно, с
плавающей запятой.

Обратите внимание, что в качестве разделителя, по американской тра
диции, используется точка, а не запятая.

Поставите запятую - компьютер выдаст ошибку (в лучшем случае, в худшем
- выдаст неправильный результат).
Обычные арифметические операции у нас закончились, так что переходим
к необычным:

»>Y=X//Y

28

Что это было - деление 2 раза подряд?! Да нет же - это просто целочислен-

>»Y
3
»>
У нас X равен 11, a Y было равно 3, так что всё правильно. При выполнении
этой операции просто-напросто отбрасывается вся дробная часть, как бы ве­
лика она не была, например, обычное деление:

>>>99999/10000
9.9999
А целочисленное деление даст:

>»99999//10000
9

Ну и ещё один оригинальный оператор:

>»33%10
3

Оператор % даёт нам ОСТАТОК от деления (X сейчас 11, a Y равен 3):

»>Y=X%Y
>»Y
2
>»

Фууу... Ну вот теперь почти всё. Осталось только возведение в степень. Ну
это просто:

>»X**Y
121
»>

X равен 11 , Y (не забыли?) равен 2, а 11 в степени 2 будет 121.

Приоритет выполнения арифметических операторов в Питон такой же
как в математике - сначала умножение и деление, потом сложение и
вычитание.

Поэтому результат следующего выражения...?

»>А=2+2*2
Правильно, 6, а не 8! Мы получим 8, это если на калькуляторе посчитаем © .

Но операторов в Питоне в несколько раз больше, чем я пока перечислил,
поэтому для ясности лучше пользоваться скобками (выражения в скобках
выполняются в первую очередь).

Давайте закрепим и заодно проверим полученные знания:

£111111111 Illi IIIIIIII Illi Illi IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII Illi llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllfe

Упражнение 2.1
Пусть х=2.5, а у=4.Сначала сосчитайте в уме, а потом в
оболочке IDLE:
х=х*у
у=х-у

у=х//2

у=у%3
х=х/3

. .......
х=х//1

30

^liiiiliilliiillIllIllIllllllllllllllllIllIlllillllllllllllIlllIllllllllllltlllllllllllllllllllllllllllllllllllilllllllllllllllllllllllllllllllllillllllllllliillllilllliillllllllllllliilllllllllillliilllilllililliilllllilllllliilillliilllilE

! Упражнение 2.2
| Ну а теперьзадачка похитрее (пусть а=4, Ь=3):
| а=(а+Ь)/2
| a=a**2-2*b
| b=b-a//(a-b)

|
I
|

j а=а**0.5

[

TiiiiiiiiiiiiiiiiiiiiiiiliiiiiiiilliiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiliiiiiiiiiliiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiliiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiiF

Что за странный последний оператор? А, это просто квадратный корень из
числа а. Да, в Питоне можно смело возводить число в самые необыкновен­
ные степени; в этом смысле Питон очень толерантный язык...

А арифметика в Питоне, такая же, как и в математике, вот только
ктПг надо запомнить несколько новых символов: * - это умножение,

** - возведение в степень, II - деление нацело (без остатка),
% - это как раз и есть остаток. Пока всё просто.

Я вижу, вам уже не терпится создать свою первую, настоящую программу.
Хорошо! «И заметьте, не я это предложил!1».

1

Цитата из бессмертного фильма «Покровские ворота»

31

Глава 3.

ПЕРВАЯ ПРОГРАММА

В оболочке IDLE (я надеюсь, она у вас запущена?) в меню File выберите
пункт New File или, ещё проще, нажмите Ctrl+N.

Откроется новое окно (рис.2):'-ч

Рисунок 2

в котором мы и будем создавать программу. Какую? Кто сказал “Hello,
world”? «Нет, мы пойдём другим путём1!»
Начнём с чего-нибудь простенького и математического (всё-таки компьютер
в первую очередь нужен для сложных математических расчётов, а уже потом
для игры в Мортал Комбат).

Напечатаем в открытом окне IDLE следующую программу (рис. 3):

Авторство этого бессмертного выражения приписывается В.И. Ленину

1

34

Рисунок 3

Для запуска программы нажимаем F5. Оп-па! Питон услужливо предлагает
вам сохранить программу:
Source must be saved
OK to saved?

Что он сказал? Как не знаете английский?... Французский в школе учили?
М-да, придётся вам немного подучить английский - Питон понимает только
его. А Питон предупреждает: «Источник (имеется в виду наша программулинка) должен быть сохранён. ОК чтобы сохранить».

Между прочим, это Питон мудро предлагает... Почему? Узнаете через
несколько строчек. Нажимаем ОК. Пока не сохраним, программа не запу­
стится! Придумайте имя своей программе на латинице, например “Super”,
“Great”, “Colossal”, и, главное, запомните папку, куда сохраняете. Сохраня­
ем, и что мы видим на экране:

=5Y=121
Понятно, что Y сейчас равен 121:

»>Y=-10.12
А теперь -10,12. А теперь так:

»>Y=' Грабаул!

Караулят! ’1

Как вы догадались, в кавычках записана строка (обыкновенный текст).
Питон выполняет такое присваивание, не поморщившись! (кстати, кавычки
могут быть как одинарные ’ - называются апостроф, как в примере, так и
двойные ” - Питону всё равно; главное, чтобы строчка начиналась и конча­
лась кавычками одного типа).
Кавычки и апостроф набираются обязательно в английской раскладке
клавиатуры - русские кавычки Питон не понимает (бормочет про себя
при виде таких кавычек "Фу-фу, русским духом пахнет!").
1

А это цитата из рассказа В. Драгунского "Двадцать лет под кроватью"

Шучу, шучу - ничего он не бормочет. Пишет:
SyntaxErron invalid character(U+2019)

Что в переводе с питонного на русский и означает: "Фу-фу, русский кавичка!
Не понимаем!". А апострофа в русской раскладке и вовсе нет...

В Питоне используется динамическая типизация, то есть тип данных
переменной изменяется в зависимости от присваиваемого ей значения.

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

»>Y=' Грабаул ! Караулят ! '
»>D=2
»>Ura=' Ура?'
»>Y=Y+Ura
»>Y
'Грабаул! Караулят'Ура?'

Как видите, переменные, содержащие текст, можно успешно складывать.
И даже умножать:
»> Y=Y*2
»>Y
'Грабаул! Караулят! Ура? Грабаул! Караулят! Ура? '
Текст удвоился!

А вот делить и вычитать почему-то нельзя...

45

А вот если мы попытаемся сложить несложимое (D сейчас равно числу 2):
»>D=D+Y
Traceback (most recent call last):

File "", line 1, in
D=D+Y
TypeErron unsupported operand type(s) for +: 'int' and 'str'
то Питон обижается! Говорит, что числа с буквами нельзя складывать!
"Тщательней надо, ребята!" - как говаривал М. Жванецкий.
^iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiHiik

| Упражнение 4.1
| Надо напечатать на экране вот такую красотищу:

I *********************

1

*

Ё

*

=

*

1

| *
= *

| *

^

= ★*★****★★★****★***★**

=

| используя только строковые переменные, содержащие + и * и 1
| оператор умножения.
|
TiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiliiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiF

Кроме обычных, уже почти привычных нам операторов присваивания типа

Это означает А=А+1, всего лишь... Почему ещё нужен оператор А+=1?!
Такая запись заставляет Питон создавать более компактный, быстровыпол­
нимый код, чем обычная запись. Поэтому привыкайте; общая форма записи
таких операторов (называется это составной оператор присваивания)
выглядит так:

А©=ВА = А©В

где © - любой(!) арифметический оператор.

Например:
»>q=10
>»q+=2

теперь к q добавлено 2 и q стало равно 12.
»>q-=4

а теперь q равно 8.
»>q*=2 э

q равно 16. ж

»>q//=3^
А теперь q равно 5 (делили нацело!),

»>q/=3 ч
ну а теперь q равно 1.6666666666666667!

Точность Питона по умолчанию - 16 знаков после запятой!

С арифметикой разобрались. Теперь займёмся вводом - надо же как-то
общаться с компьютером!

Для ввода данных с экрана имеется оператор input - в переводе
означает "ввод".

Ф

Давайте его используем (результат ввода попадёт в переменную Хх1:
»>Xxl=input () -л—

”

Ну и что мы видим на экране? Ни-че-го! Компьютер ждёт ввода данных и
ничего при этом не показывает! Это нехорошо! И вообще, зачем в input
скобки?! А затем, что в скобки можно вставить любой текст (как на англий­
ском, так и на русском, а при должной сноровке - даже на китайском) и комп
его послушно выведет!
Нажмите 2 и Enter - чтобы вернуть приглашение в IDLE (при этом перемен­
ная Хх1 получила значение 2).

»>
Печатаем в IDLE (текст, который желаете вывести на экран, надо заключать
в двойные " или одинарные кавычки ’ - причём эти кавычки печатаем только
в английской раскладке клавиатуры):
»>Xxl=input("Я жду число:”)

Видим на экране:

Я жду число:
Печатаем 2 и нажимаем ’’ввод”.
А теперь ещё:

»>xX2=input ("И ещё число:")
Вводим 3. Сложим наши переменные:

»>Х=Хх1+хХ2

И напечатаем их на экране посредством оператора print (да, в print, как
и в input, можно вставлять любой текст):
48

»>print

(’’сумма введённых чисел:", X)

Что мы увидим? Сюрприиииииз!

сумма введённых чисел: 23
Почему? Что за белиберда? 2+3=23?!
Как я и предупреждал выше, надо контролировать тип переменной... Дело в
том, что input воспринимает введённое значение, как строку. Питон впол­
не обоснованно считает, что всё, что вводится с клавиатуры - это тексты! И
тут он совершенно прав! Поэт же не обращается к нам с вот такими числен­
ными стихами:
14 126
132 17
16 42...
704 83.

14
43.
511
2

Он пишет:
Не жалею, не зову, не плачу,
Все пройдёт, как с белых яблонь дым.
Увяданья золотом охваченный,
Я не буду больше молодым.3

Но мы отвлеклись. Питон воспринял введённые числа 2 и 3 именно как
текстовые знаки! А нам надо число!

То есть надо введённое значение как-то превратить в число, причём
целое. Для этого существуют функции преобразования типов.

Берём функцию int (от английского integer)'.
»>X=int (X)
2
Прочтите не спеша, с грустным выражением лица, и вы поймёте, что это - пародия на
С. Есенина. Взято из Интернета, по предварительным данным автор - П. Грайворонский
Ну а это уже точно С. Есенин

4

49

Помним, что X у нас 23 - как результат предыдущих вычислений. Узнаем,
что получили:

»>print (X)
23
Ой!... Ничего не изменилось... Это потому, что оператор print странным
образом одинаково выводит и число, и строку...
Убедимся, что 23 - это число:-.
»>х=х+х
»>print (X)
46

Ура! Заработало!!!! А теперь проделаем всё заново, только в виде програм­
мы - введём 2 и 3 и сложим их. Вновь набираем в IDLE заклинание Ctrl+N
и пишем программу. Операторы можно навешивать друг на друга (только не
надо этим увлекаться - 2-3 оператора, не больше, иначе текст превращается
в ребус):
Xxl=int
xX2=int

(input("Я жду число:”))
(input ("И ещё число:”))

И ещё приятный момент: в print можно вставить арифметические (и не
только арифметические!) операторы любой сложности:
print

(Хх1+хХ2)

Нажимаем F5, сохраняем программу под каким-нибудь именем на ваш вкус,
вводим числа 2 и 3 и видим наконец-то искомый ответ:
5
А почему, собственно, вывод на экран выполняется с помощью оператора
print (’’печатать” в переводе)? О, это привет нам из 60-ых годов прошлого
века... Дело в том, что раньше общались с компьютером посредством пер50

фокарт, а результаты выводились на бумагу электрической пишущей (то есть
печатающей) машинкой...

Ещё раз повторю, что оператор print может выводить много переменных
сразу, надо только переменные разделять запятой:
»>pr int (' число Х1=' , Хх1, ' , число Х2=' , хХ2)
И на экране читаем: —\

число Х1= 2, число Х2= 3
Стоп, а у нас ведь были переменные Хх1 и хХ2? А что вы написали в тексте
в операторе print, то компьютер и вывел! Компьютер и Питон выполняют
только то, что им приказано и не умеют думать за вас (но это временно.
Компьютеры умнеют буквально на глазах, и в этом есть вклад языка Питон).

Чаще, конечно же, надо вводить число не целое, а с плавающей запятой.

Ну это просто - по-английски плавающий - float:
»>Х1= float

(input("Я жду число:"))

И введённое число 2 будет представлено как 2.0, а сумма XI и Х2 (а Х2, если
забыли, равно 3):
»>print
Х1+Х2=5.0
»>

('Xl+X2=', Х1+Х2)

Кстати, обращаю ваше внимание: все операторы (я выделяю их жирным
шрифтом) следует записывать так, как у меня и никак иначе! Никаких
Print, flout и Input - всё это будет воспринято в лучшем случае как ошиб­
ки, а в худшем - как переменные с непредсказуемым результатом.

Давайте немного отдохнем и создадим простую программу:

illllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllliv

Упражнение 4.2
Давайте поиграем в шпио... Нет, что вы! В разведчиков! Пусть
у нас есть коробка, а в ней 15 рядов по 22 ячейки. И мы в неё
фасуем по порядку обыкновенные фильтры для воды - 1-ый
фильтр займёт 1 ряд, место 1, 23-ий - 2 ряд, место 1, 25-ый - 2
ряд, место 3. А в 174-ый фильтр мы спрятали сверхважное
донесение, написанное невидимыми чернилами, задом
наперёд да ещё и зашифрованное шифром Цеза... Ой, что это
я вам все секреты выбалтываю? Про шифр Цезаря ещё будет
задача!
Короче, надо сообщить в Центр, Апексу4, в каком ряду и месте
находится шифровка.
'nilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Наша самая первая программа получилась какой-то неказистой. Что-то там
внутри себя проделала и выдала результат: 20.22555539213307! 20 чего?
Килограмм? Парсек? Так сейчас программы не пишут! Программа должна
разговаривать с клиентом и объяснять, что она получила.
Давайте для примера напишем красивую программку для вычисления пло­
щади круга по введённому диаметру. Примерно такую:л
DiaKr = float(input ("Введите диаметр крута в см:"))
SqrKr=3.14*(DiaKr**2)/4
print (SqrKr)
Сначала оператором input вручную, с клавиатуры, вводим диаметр круга
и помещаем значение в переменную, которую я назвал DiaKr. Желательно,
чтобы название переменной намекало, что оно означает. Ладно, у нас первая
программка из 3 строк. А если из 700? Допустим, назвали мы эту перемен­
ную D. А через 200 строк у вас обнаружились переменные D, d2, D7 и D кг.
Которая из них диаметр круга, вы за неделю работы над программой уже
забыли... Так что лучше DiaKr.

Цитата из культового фильма "Семнадцать мгновений весны". Юстас - это секретный
4
позывной советского разведчика Штирлица (он же полковник Исаев), а Алекс - это позывной
советского руководства, которое давало Штирлицу новые задания

Теперь можно сосчитать площадь круга. Помните, чему она равна? Правиль­

Так как я (как будто) не уверен, что возведение в квадрат выпол4
няется раньше умножения, я поставил для верности скобки. Нажимаем F5,
вводим 1 и любуемся на результат:^

но,

0.785

---------

Единственное замечание - всё-таки желательно указать, что за значение мы
вывели:

DiaM = float (input ("Введите диаметр круга в см: "))
print (’Плош^дь круга диаметром' ,DiaM, 'см составляет' ,
3.14 * (DiaM**2) /4,'квадратных сантиметров')

На экране:

Введите диаметр круга в см: 7.5
Площадь круга диаметром 7.5 см составляет 44.15625
квадратных сантиметров
Вот так-то оно понятней... Заметьте, в оператор print я вставил всё вы­
числение площади круга, тем самым сократив наш крошечный код ещё на 1
строку - программы на Питоне очень компактны.

illlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllliu.

Упражнение 4.3
Ну а теперь простенькое упражнение: надо написать
программу (я бы даже сказал - программулечку), которая
спрашивает "Как вас зовут", ждёт ваше имя и затем печатает
"Привет, !".
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Исразу ещё пару заданий в догонку к предыдущему:
ф...............................................................................................................................
53

lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllliu

| Упражнение 4.4
| Усложним предыдущее упражнение. Пусть теперь программа
| запрашивает вашу фамилию, имя и год рождения, после чего
I выводит:

|

| Здравствуйте,
| Вам лет

|
|

| Где х - ваш возраст.

|

Ч|||111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111ПГГ

jjlilillllllllliiiiiiliiillillllilililiiilliliiilliillliliiiliilliliiiiiiiiliiliiiiiiiiliiliilliiilililiiilillliillillillllillliiliiiliillilliiiiiilllllllllllillllllillllillliillillliillllllliliilllllllllililllilillilliiiliiiiiliilliinillilb

| Упражнение 4.5
1
I
|
|

У Тургенева в рассказе "Му*му" указан рост Герасима "мужчина 12 вершков роста, сложенный богатырём...".
Открываем справочник: 1 вершок - 4,44 см, итого 12 вершков
- 53,28 см... Богатырь?! 53 сантиметров роста?!

| Дело в том, что в старые времена, говоря о росте человека,
| указывали его рост свыше 2 аршинов (1 аршин = 71,12 см).
| Так что вот вам задача: программа запрашивает рост
I человека в вершках и выдаёт его рост в сантиметрах.
Иногда возникает необходимость записывать очень большие числа, ну,
например, посчитаем, сколько километров отделяет нас от туманности
Андромеды5, находящейся, как известно, на расстоянии 2,52 миллионов све­
товых лет от нас. А световой год - это расстояние, которое свет пролетает за
1 год. А скорость света - 300 000 километров в секунду. А в году 365 суток, в
сутках 24 часа, в 1 часе 60 минут, в 1 минуте 60 секунд. У вас ещё не рябит в
глазах от обилия цифр, которые надо перемножить? Тем не менее программа
для расчётов получается довольно простой:

Vsveta=3 0 0_00 0
sutki=60*60*24*Vsveta
god=365*sutki
Tuman=2_52 0__0 0 0 * god
print (Tuman)
5
Туманность Андромеды - самая известная Галактика, хорошо видимая невооружённым
глазом в созвездии Андромеды, за что и получила своё название

Что за странная величина 300 000 присвоена переменной Vsveta?

При записи больших чисел очень хочется разделять разряды, а пробел
в Питоне почти священный символ - им выделяются блоки; так что эту
обязанность возложили на нижнее подчёркивание.

Например, 136 250 120 следует записывать или так:

136 250 120

или, если вы брезгуете использовать нижнее подчёркивание, как обычно:
136250120
Других вариантов нет!

Наберите программу у себя на компьютере, нажмите F5 !.. И на экране:
23841216000000000000
Вот это число! До галактики Андромеды 2,384 квинтиллиона километров...
Воспринимать большие числа, записанные в таком виде, очень неудобно.

Но выход есть! Как известно, для записи очень больших или очень малень­
ких чисел используется специальная форма записи - "научная”.

В этом случае число представляется в виде некоторой десятичной дро­
би, называемой мантиссой, умноженной на целочисленную степень
десяти (порядок).

В Питоне это записывается так: сначала пишется мантисса, затем пишется
буква е (можно Е, но обязательно в английской раскладке), затем пишется
порядок. Пробелы внутри этой записи не ставятся. Так что расстояние до
туманности Андромеды записывается как 2.384122е19.
ф

Причём если мы в нашей программе скорость света запишем в "научной"
форме:

Vsveta=3e5
то и результат Питон выдаст в такой же, более удобной, форме:

2.3841216е+19
А если мне, наоборот, надо записать очень маленькое число, к примеру мас­
су молекулы NH3 (аммиак), равную 2,82-10-26 кг?

Нет проблем:
2.82е-26

А если я хочу обычное число, ну например, удельный вес золота, записан­
ный в обычной форме - 19320 кг/м3 (представляете, литровая банка с золо­
том будет весить 19 кг!!! При том, что ведро воды весит 10 кг!) вывести в
научной форме оператором print? Вот здесь создатели Питона дали маху,
не придумав ничего лучше странного метода6 . format () - методы в
Питоне записываются вот так - через точку.
Его работу проще показать на примере^

»>Аи=19320
»>AuOut=' {: е} ' . format (Au)
»>AuOut
■1.932000e+04'
А почему число выведено в апострофах?

Вот в этом и состоит странность метода .format() - он преобразует
число в строку!
6
Термин "метод" ещё не раз встретится в этой книге и в дальнейшей жизни. Метод - это
способ, которым обрабатываются либо вырабатываются какие-либо данные

С другой стороны - ничего странного - все числа в Питоне содержатся в
удобном ему (Питону) виде, а уж в какой форме вы хотите видеть число
- объясните доступным Питону способом (извините, методом) и получите
результат в удобной нам, людям, строке. Применять этот метод как-то не
очень удобно, так как формат метода . format () в нашем случае довольно
затейливый:
• {: .Ne)' . format (X)

где N задаёт количество знаков после запятой, апострофы намекают, что ре­
зультат - это строка, фигурные скобки подсказывают Питону, где начало и
конец формата, а X - преобразуемое число:
>»Akk=0.000235698
»>S=' {: .2е) ' .format(Akk)
»>S
■2.36e-04’

Здесь я вывел число на печать с 2-мя знаками после запятой; по умолчанию
выводится 6 знаков после запятой (ой, извините, точки): 7

>»print (' {: е}' . format (Akk))
2.356980е-04
Удобнее метод . format () применять внутри функции print () - тогда
выводимую на печать переменную можно использовать в дальнейшем; либо
присваивать результат работы функции какой-нибудь другой переменной.
Помните Упражнение 3.2 про электронные часы? Там у нас показания
электронных часов печатались довольно странно:

5:0

Метод . format () позволит сделать вывод правильным, как и положено в
электронных часах.

Т=300

Min=T%60
Т1=Т//60
Hour=Tl%24
print (' {: 02d)'. format (Hour),

02d)'. format (Min))

и на экране мы видим, как^положено^,

05 : 00
Обозначения ' (:02d) ' говорят Питону следующее:

•

2 - что надо вывести на экран не меньше 2 значащих цифр,

•

О - недостающие разряды заполняем нулями,

•

d - выводим число в целом виде.

Примеры работы этого формата:

>»'{ :02d} ' .format (3365)
■3365'
>»'( :07d) ' .format (3365)
■0003365’
Число занимает 7 позиций, пустые места заполняем нулями:

>»'{: 17d) '.format (3365)
’
3365'
Число занимает 17 позиций, пустые места заполняются пробелами:
>»'( :17f) ' .format (3365)
’
3365.000000’
А вот здесь буква f означает формат с плавающей запятой, число занимает
17 позиций, по умолчанию выводится 6 знаков после запятой.

58 ]

>»'{:.2f)'.format (3365)
■3365.00'
Формат с плавающей запятой, 2 знака после зап."™”-

»>'{ :10.3f)' .format (3365)
' 3365.000'
Формат с плавающей запятой, 3 знака после запятой, число занимает 10 по­
зиций.

Далее маленькое упражнение:
^lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllt

Упражнение 4.6
Требуется с помощью метода .format() вывести на экран
число 2023 с 3 знаками после запятой, так, чтобы оно
занимало 13 позиций, а недостающие места заполнить
нулями.
'nilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

На самом деле метод . format () имеет огромное количество разнообраз­
ных регулировок, которые я здесь приводить не стану, чтобы не разбудить
моих уснувших читателей... Что? Ещё не заснули?
Тогда - кому любопытно, загляните в Интернет, а остальных приглашаю
сделать упражнение: а

^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIL

Упражнение 4.7
Представьте, что Солнце мы уменьшили до размера
футбольного мяча. Рассчитайте, до какого размера тогда
уменьшится наша Земля и на каком расстоянии от Солнца она
будет располагаться в таком масштабе. А где расположится
Нептун - после разжалования Плутона он теперь самая
далёкая от Солнца планета? И какой диаметр тогда будет у
Юпитера?
'nilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

^IIIIIllIllllllllllllllllllllllllllllllllllllllIllIllllllllllllllllllllllllllillIlllllllllllllIllililllillllllllllllIlIlIlliIllllIllIlilllIllilillIlIliillllliIllllIlliiiiliiilliiliiiiiililIlllIlliiiiiiiiiiiiiillillliliiiiiiiiiiiiiiiiiiiiiHE

| Что? Каков диаметр футбольного мяча? Яндекс нам и вам в
| помощь... Сообщаю:
| •

Диаметр футбольного мяча - 22 см.

| •

Диаметр Солнца - 1,39 миллиона километров.

| •

Диаметр Земли - 12742 километра7.

| •

Диаметр Юпитера -142984 километра (как учёные
измерили Юпитер с такой точностью?!)

| •
|

Расстояние от Земли до Солнца 149,6 миллиона
километров.

| •
|

Расстояние от Нептуна до Солнца - 4,55 миллиарда
километров.

|
|
|
|
|

Масштаб преобразования надо вывести в "научной" форме
с точностью 1 знак после запятой, а остальные результаты
(диаметры и расстояния) - в сантиметрах. Как вы думаете,
уместится ли Солнечная система в таком масштабе в
комнате? Квартире?

Какие интересные переменные в Питоне: ди-на-ми-чес-кие! МотггТр гут принимать какие угодно значения: и числа, и тексты... А ещё

есть замечательный оператор input, чтобы компьютер мог объяс­
нить, что он от меня хочет. А ещё переменные надо называть так, чтобы
самому понятно было, что это за переменная. А ещё метод .format
позволяет выводить число на печать в каком вам удобнее виде: можно
в научном, можно с нулями впереди, можно сколько душе угодно цифр
после запятой поставить.

7
Кстати, если диаметр Земли уменьшить до 1,5 метров, то в таком масштабе толщина
атмосферы (10 км) составит ... 1 миллиметр! Шар, чуть ниже вашего роста и на нем юнюсенькая
пленочка, в которой все человечество живет да еще и самолеты летают...

60

В нашей жизни мы очень часто вынуждены принимать решения в зависимо­
сти от обстоятельств: ’’сделать домашнюю работу или погонять в футбол?”
или ’’если завтра понедельник, то начну новую жизнь”.
Разумеется, процедуры принятия решений в зависимости от каких-то усло­
вий есть и в программировании.

61

Глава 5.

УСЛОВНЫЕ ОПЕРАТОРЫ

Ну вот, теперь можно перейти и к программированию. Что? А что это все
было до этого? Воспоминания об арифметике и орфографии.

Программирование начинается с оператора if! (для не очень знающих
английский: if переводится как "если").

Формат этого оператора такой:

if - логическое выражение>:
print
True
»>print
False

(2==2)

(2>3)

А вот оператор ”не равно” выглядит изумительно (это как бы
догадался):

»>print
True

если кто не

(2?=3)

Приведу весь список простейших логических операторов:
• = - больше или равно

• >

- больше

• <

- меньше

• == - равно

•

! = - не равно

•

in - проверяет, входит ли элемент в последовательность (в переводе с
английского означает ”в”)

Это простейшие операторы? А что, бывают и сложнейшие?

Да, бывают... И образуют они аж целый раздел математики - алгебру логи­
ки, или Булеву1 алгебру. Но этим я вас попугаю немного позже.

Блок - это любое количество любых операторов, выделяемых
одинаковым (обычно 4) числом пробелов.
1

Джордж Буль — английский математик и логик. Один из основателей математической логики

Это важнейший элемент Питона! В Питоне именно пробелы (одинаковое
число!) выделяют блоки, что позволяет, между прочим, сделать программу
удобочитаемой и красивой. Конец блока - инструкция, перед который стоит
меньшее число пробелов.

Ну а теперь составим первую программу с ветвлением (я даже не буду вам
подсказывать: в среде IDLE нажмите Ctrl+N и набейте буквы, что написаны
внизу):
A0=int (input(" введите число:
if АО > 5:
print(' больше')
else:
print (' меньше')

"))

Напоминаю, что else означает "иначе" - извините, всё время забываю, что.
может быть, не все знают английский.

Введём число больше 5 - компьютер выведет "больше", меньше 5 - получим
"меньше". Обратите внимание, что оба оператора print сдвинуты на равное(!) число пробелов. Это - важнейший момент в Питоне: п

Сдвиг сообщает Питону о начале блока команд, идущих после двоето­
чия. Исчезает сдвиг - значит блок закончен.

А теперь усложним программу. Будем проверять, попало ли вводимое число
между числами 5 и 10; так как Питон, в силу своей мягкости и терпимости к
причудам программистов, разрешает указывать несколько условий сразу, то
программу можно записать так:
A0=int (input('введите число: '))
if 5 in «последовательность >:
«тело цикла>

Ну, с переменной всё ясно - это обычная переменная, которая по одному
принимает значения из последовательности.

Последовательность - это набор букв и/или чисел с определённым
порядком следования.

То есть (1,2,3) - это одна последовательность, а (2,3,1) - другая.

Тело цикла - это любое количество операторов, которые выполня­
ются при каждом шаге цикла и выделяются равным числом пробелов
(рекомендуется 4 пробела).

Кстати, IDLE автоматически вставит 4 пробела после того, как вы наберёте
двоеточие - главнейший, хотя и незаметный элемент цикла!
Запишите и запустите простенькую программку (помним про двоеточие! А
пробелы после двоеточия IDLE вставит сам):

for dgtlO in (1,3,7.2,'Fa',13):
print (dgtlO)

На экране увидим:

1
3
7.2
Fa
13
Как видите, последовательность не обязательно должна состоять из чисел.

Тем не менее, в большинстве случаев переменная цикла принимает число­
вые значения с равным шагом, то есть пробегает последовательность типа
такой (0, 1, 2, ..., 99, 100).
Как записать такую последовательность? Вот так прямо, в скобках перечис­
лить все числа? А если их миллион? 2 месяца записывать будем? Вот уж нет
- лень - двигатель прогресса!1

Для этой цели есть простенькая функция range ("ряд" по-английски).
С её помощью последовательность (0, 1,2, ... , 99, 100) записывается
очень просто - range (101)! Перебор чисел в функции range закан­
чивается перед числом, указанным в скобках.

Ф

Вот уж никогда бы не подумал, что автор этой сентенции - поэт Андрей Вознесенский!
"Лень - двигатель прогресса" - это строчка из его стихотворения "Лень"

А если такая же последовательность начинается с 1?

Пожалуйста - range (1, 101).

А для последовательности (3, 5, 7, ... , 30, 33)?
Например, вот так: range (3 ,
такой:

range

([ начало,

34 ,

]

2). Значит, формат функции range

конец [

,шаг ])

В квадратных скобках указаны необязательные параметры.

Обязательно указывать только параметр конец, в этом случае пара­
метр начало равен 0.

Почему 0, а не 1, как у всех нормальных людей?

Дело в том, что на Питоне работают в основном математики и програм­
мисты, а это не совсем нормальные люди. У них счёт начинается с нуля вспомните вывод в конце упражнения 4.2.

И нумерация значений в последовательностях в Питоне начинается с
0, и функция range "заточена" именно под это, и, чтобы пробежать все
элементы в последовательности (0, 1,2, 3, 4) надо записать range (5).

Опять-таки, почему не range (4) ? Потому, что значение конец не включа­
ется в создаваемую последовательность, что опять-таки связано с нумераци­
ей последовательностей - так удобнее.
Например, если в последовательности 5 элементов, то, чтобы перебрать все
- пишем просто range (5):

for i in range(5):
print (2*i)
А на экране видим фрагмент таблицы умножения на 2 - первые 5 строчек:
_
•

fi

о
2
4
6
8

Вот ещё пример:
for Т_Т in range (-3,2) :
print (Т_Т, end=', ')
На экране мы увидим:

-3, -2, -1, 0,1,

Тут всё просто, кроме странного параметра end=. Что за зверь такой?

Параметр end= задаёт символ конца строки (по умолчанию это символ
”\п", который в Windows автоматически превращается в "\г\п” (переход в
начало следующей строки)).

И не спрашивайте меня, почему для этой простой операции используются 2
символа - для этого мне надо начать объяснение с прошлого века... Нет, не
с XIX века, что вы!.. С конца двадцатого века. В эти незапамятные времена
вывод данных, как вы помните, происходил с помощью электрических пи­
шущих машинок, а в них для перехода в начало следующей строки выпол­
нялись 2 команды: сначала каретка с бумагой просто сдвигалась вправо до
упора, а затем бумага сдвигалась на строку ниже.
В данном примере удобнее вывести результаты одной строкой, поэтому я
попросил Питон в конце вывода ставить запятую (и пробел).
А теперь добавим в эту программку ещё строку:

for t_T in range (-3,2) :
print (t_T, end=’, ')
print ('*’ * 50)

L83

Добавленным оператором я хочу подчеркнуть вывод 50-ю звёздочками. На
экране: /л

1 ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
ч

Не совсем то, что я ожидал! В таких случаях следует вставлять ’’пустой"
оператор print (), который переведёт указатель начала печати в начало
следующей строки:

for t_T in range (-3,2):
print (t_T, end=', ’)
print ()
print ('*'*50)
Да что ты будешь делать! Теперь на экране:

-3,
-2,
-1,
О,
1,

Вот вам пример того, как Питон определяет конец цикла - у нас print ()
попал в тело цикла, так как перед ним стоит 4 пробела, и Питон послушно
перескочил на новую строчку 5 раз.
Удалим пробелы перед print ():

for t_T in range (-3,4):
print (t_T, end=', ')
print ()
print ('*' * 50)

84

Ну наконец-то:

-з, -2, -1, 0,1,
*************************************************

И ещё пример:

for i in range (40,10,-5):
print (i, end=’+’)

Да, шаг может быть и отрицательным!
На экране мы увидим:

40+35+30+25+20+15+
^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIX.

Упражнение 7.1
На основе предыдущего задания напишите программку,
которая выводит на экран запись:

13+20+27+34+41+48+55 =

а после знака равенства поставьте, чему равна эта сумма...
Ч||11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111||11111111111111111||11111111111111111111111111111111111111111111111111111111111111111Н111ГГ

Последовательности в Питоне могут иметь совершенно изумительный вид,
типа такого:

Word='Катя'
for j in Word:
print (j*2, end='')

Результат:

ККааттяя
85

То есть Питон переменную Word, содержащую слово Катя, воспринял
тоже как последовательность (!), совершенно спокойно умножил каждую
букву на 2 (то есть просто удвоил) и вывел результат на печать. Напишите
print (j*3) - произойдёт утроение букв.

Давайте немного передохнём, выполнив простые упражнения: q

Упражнение 7.2
Даны 2 последовательности (0, 4, 7, 2,1,19, 6) и (18,1, 9, 3, 4).
Надо найти совпадающие элементы и вывести их на экран,
разделив пробелом.
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Упражнение 7.3
Напишите программу, которая из заданного массива (-2, 5, 8,-4,
-6, -11) выводит модули значений элементов.
lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllin'

Перейдём к более хитрому виду цикла - циклу с условием, или циклу
while (while по-английски "пока" (не в смысле "до свидания", а в смыс­
ле "до тех пор, пока")).

Определяется этот цикл так:

while < логическое выражение >:
< тело цикла >

Тело цикла выполняется до тех пор, пока логическое выражение истинно, то
есть равно логическому True. Проще показать на примере:

N=1
while Nround
1.235
»>round
1.234568

(1.23456789,3)
(1.23456789,6)

I
I
I
|

| И даже
| »>round
| 800

(832,-2)

|
j

| Всё, тишина! Пишем программу!
. ................................................................................................................................................. I... г

1

Аксиома Кана из законов Мерфи. Что такое законы Мерфи? Систематизированное
. „изложение законов людлостл.....................
- . _

Ну а теперь допустим, что в 3 (ещё хорошо, что в трёх! А если в 133?) частях
программы нам надо выполнить совершенно одинаковые действия с разны­
ми числами. Скопировать один и тот же код 3 раза?! Ну это же не эстетично,
и трудозатратно, особенно если код содержит в себе 100 операторов. Кроме
того, это не дёшево и не практично...
В таких случаях помогают пользовательские функции, то есть создаваемые
самим программистом.

Это просто:
def Fun(xl, х2,
< блок >
return А

...,xN):

Сначала мы оператором def (от английского definition - определение)
создаём название функции (это может быть любая переменная), в скоб­
ках ставим параметры функции (в любом количестве), а после двоето­
чия, на следующих строках с отступом в 4 пробела! (это обязательно!)
идёт тело функции - всё, что функция должна сделать.

Оператор return («возврат») присваивает результат имени функции
и тут же «уходит» из неё. Функции следует определять перед началом
текста основной программы.

Ну вот допустим, нам надо вычислить... Э... Давайте вычислим объём вы­
тянутого кубика, «сокращённо» именуемого прямоугольным параллелепипе­
дом. Перемножаем три стороны и получаем объём.
def Vol (х, у, z) :# фунгадея Ешислемя объёма помацвсмя в куб.м
return x*y*z
Homel = Vol (5, 4, 3)
ExtraHome = Vol (11, 15, 2.8)
print (Homel)
print (ExtraHome)
Г 109 1

Результат:

60
453.75
Я надеюсь, здесь всё понятно? В вышеприведённой программе мы дважды
вызывали функцию Vol () с разными аргументами.
А что делать, если кроме объёма нам ещё и вычислить площади квартир
Homel и Extra? Вы догадались, что третий аргумент в функции Vol () - это
высота потолка?

Можно сделать вот так:

def Vol (х, у, z):
return x*y*z, х*у # объём и площадь квартиры
Extra = Vol (11, 15, 2.75)
print (Extra)

Получаем

(453.75,165)
В Питоне можно вернуть из функции сколько угодно переменных - да хоть
100!, перечислив их через запятую после команды return; полученная
последовательность называется «кортеж» и записывается в круглых скобках.
Подробнее о кортежах я расскажу немного позже, в главе 16.
^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIb

Упражнение 10.3
Напишите программу, рассчитывающую вес шайбы толщиной
1 мм. Вводим наружный диаметр, затем внутренний и
программа выводит её вес. В программе надо применить
функцию вычисления площади круга. Что? Из чего сделана
шайба? Ну, допустим, из латуни. Удельный вес латуни марки
ЛО62-1 равен 8,5 г/см3.
TiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiiiiF

ио]

^Illllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll£

! Упражнение 10.3.1
I Как убедиться, что программа работает верно? Придумайте
| некое тестовое задание для проверки.
Hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiif

Использованная в этом упражнении функция получилась очень простой - из
одной строчки. Создавать отдельную функцию для такой мелочи неудобно,
не так ли? Как обычно, всё уже предусмотрено заранее!

Для таких случаев в Питоне имеются так называемые лямбдафункции.

Вот, допустим, вам позарез потребовалось узнать, сколько литров воды в
вашей дачной стандартной металлической 200-литровой бочке с размерами
по ГОСТу 13950-91 - то есть диаметром 56,4 см и высотой 85 см; вот только
воды в ней осталось только 55 см.

Формулу расчёта объёма цилиндра помните?
V = ^h
4

Вместо D берём 56,4 см, h - это высота воды в бочке в сантиметрах. Ну а
если мы всё меряем в сантиметрах, то и результат получим в куб. см. А мне
нужен результат в литрах (в куб. см задаётся объём иной жидкости,
употребляемой отнюдь не для полива), значит, надо результат разделить на
1000 (I литр это 1000 куб. см.).

А вот теперь определим лямбда-функцию, это делается очень просто:

X=lambda :
Сначала пишем lambda, потом, через запятую, перечисляем аргументы
.{хоть сколько!), а после двоеточия пишем выражение, которое надо вычис­
лить; полученный результат присваивается переменной X, например, воз­
ведём число в квадрат:

»> square = lambda a: a*a
»> square (5)
25

Так что для вычисления объёма воды в бочке имеем:
barr=lambda h: 3.14*(56,4**2)/4*h/1000
print ('в бочке'fround(barr(55))r ’литров’)
Запускаем программу, смотрим результат: в бочке 137 литров - вполне
разумно!
«А если у моей бочки другой диаметр?», - спросите вы - «например, 72 см.
И воды в ней на 80 см». «Это где ж вы такую бочку достали?», - отвечу я.
«Сварили на заказ, на оборонном заводе, ещё во времена СССР. Из титана,
между прочим!» - услышу я в ответ. Всё с вами ясно, сейчас такая бочка
стоит миллион, наверное... Немного улучшим программу - недаром ведь в
определении лямбда-функции указываются аргументы (во множественном
числе).

Перепишем программу:^

barr=lambda h,D: 3.14*(D**2)/4*h/1000
print (’в бочке’, round(barr(80,72)),’литров’)
и пожалуйста - в бочке 326 литров - объёмистая у вас бочка, однако.
А зачем вообще потребовалось изобретать велосипед в виде этой лямбдафункции? Отвечаю: часто встречается ситуация, когда в программе надо
несколько раз вычислять одно и тоже простое выражение из одной строки.
Вот тут-то лямбда-функция и пригодится: её писать немного проще, а значит
- быстрее! И второе - определить лямбда-функцию можно в любом месте
программы, в отличие от просто функции, которую определяют строго в на­
чале программы.

Упражнение 10.4
Жила-была пирамида, с размерами основания примерно
150x150 метров и высотой 49 метров. А потом пришли злые
люди и снесли ей верхушку, оставив площадку размером

22x22 метра на высоте 42 метра. Надо, используя лямбда
функцию, определить объём пирамиды.
^Illllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Вот теперь, как мне кажется, вы кинулись в другую крайность: «А зачем
нужны обычные функции? Всё ведь прекрасно считается через лямбда-функ­
ции?» Как вы, надеюсь, заметили, результат работы лямбда-функции должен
рассчитываться одной строкой, одним выражением, возможно и очень длин­
ным. А вот если надо для получения результата применять оператор if, а то
и вовсе цикл? Вот тут от пользовательской функции никуда не деться.
Например, придумайте функцию, которая при получении чётного числа пе­
чатает «ЧЁТ», нечётного - «НЕЧЁТ». А если вдруг ни то, ни сё? Ну, не целое
число? Тогда печатает «Свят, свят! Таких чисел не бывает!». Да ладно, шучу
- печатает «Не целое число».

Программа очень простая:^

def TwoOrNot(N):

Сначала проверим, является ли аргумент чётным числом:
if N%2==0:
print(’ЧЁТ’)

А вот теперь тонкий момент. Если мы сейчас проверим число на нечётность
оператором N%2!=0, то у нас все числа, включая не целые, попадут в не­
чётные.
Значит, сначала убедимся, что число целое, тогда оно, конечно, нечётное:

else:
if int(N)==N:
print(’НЕЧЁТ')

А сюда мы придём с не целыми числами:
else:
print ('Это не целое число')

Итак, функцию написали, теперь сама программа:

№2020
Опаньки, а как вызывать функцию? Мы ведь TwoOrNot ничего не присва­
иваем? Ничего страшного, можно вызвать функцию просто так, без присва­
ивания: л

TwoOrNot(N)
М-2021.000001
TwoOrNot(М)
Наге=2023
TwoOrNot(Hare)
и убедиться, что всё прекрасно работает, прочитав на экране:
ЧЁТ
Это не целое число
НЕЧЁТ

В функцию не обязательно передавать все параметры, она запросто может
использовать какие-то значения из основной программы, например:

def F(a) :
B=Const - а
А=(а**2)/2+Const
return А
Const=39.5
print(F(3))
Const=-1
print(F(1.0))
и на экране: q

44.0
-0.5

То есть внутри функции преспокойно используется значение Const на мо­
мент вызова функции - так можно!

А теперь пример обычной пользовательской функции для подсчёта у числа
количества его делителей, не считая 1 и самого числа:
# функция рассчитывает число делителей числа
def DEL (х):
cnt=0 #счётчик делителей сбрасываем в О
for i in range (2, х//2+1) : #пзребор возмомошх делителей
if x%i*=0: #i является делителем
cnt+=l #счётчик +1
return ent #по окончании доела - возвращаемся из функции
for j in range(35,41): #найдём кол-во делителей у чисел от
35 до 40
print (j, 'имеет
DEL(j),'делителей') #выводам результат

А вот и результат:
35
36
37
38
39
40

имеет
имеет
имеет
имеет
имеет
имеет

2 делителей
7 делителей
0 делителей
2 делителей
2 делителей
6 делителей

А теперь решите аналогичную задачу: а

▼
Упражнение 10.5
Назовём максимальным делителем числа А максимальное
число, на которое делится А, за исключением самого числа.
Рассчитайте разность между максимальными делителями
чисел 124 и 303.
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiiiiF

«А не замахнуться ли нам на Вильяма, понимаете ли, нашего Шекспира?2».
Ну, на Шекспира в книге по программированию мы, пожалуй, замахиваться
не будем. А вот на решение сложного уравнения методом деления пополам
- будем!

Допустим, нам надо быстренько решить уравнение: а

1.24х5+0.12689х2-100.45х-36.235=0
Задачу сильно облегчает то обстоятельство, что надо найти хоть какойнибудь корень с невысокой точностью ±0.02, и сильно утяжеляет то, что это
надо было сделать, как обычно, вчера.
Вот тут-то нам и пригодится метод деления пополам. Для начала найдём от­
резок, на котором заданная функция принимает разные значения, а значит,
принимает значение 0 где-то внутри этого отрезка. Как это сделать? Ну не
вручную же! Для этого напишем небольшую программу.

Для начала оформим заданную функцию в виде пользовательской функции:

def Fun(х):
return 1.24*х**5+0.12б89*х**2-100 .45*х-36.235

Левый конец отрезка пусть будет 0:
х0=0

Вычислим и запомним значение функции в заданной точке 0:
f0=Fun(x0)
Теперь будем искать с помощью цикла с шагом 1 значение xl, при котором
функция fl изменит знак на противоположный к f0: у

for xl in range(1,100):
fl=Fun(xl)
Цитата из нашего, понимаете ли, бессмертного кинофильма «Берегись автомобиля» (1966 г.).
Означает поставить перед собой более высокую, сложную задачу

2

116

А как узнать, что в точке xl функция изменила знак? Да очень просто: надо
перемножить fl и f2:

if f0*flVizbor=' Давайте восклицать,

друг другом восхищаться'1

Оп-па! В переменную имени Визбора попали слова Окуджавы! А в строке,
как и в числе, содержимое в дальнейшем изменить нельзя! Вы ведь не може­
те в команде pi= 3,1416927 ошибочно набранную цифру 6 вот так, запросто,
как на бумаге, зачеркнуть на цифру 5? Придётся менять всё число:
pi=3.1415927

Так и со строчными переменными - изменить можно только если присвоить
другое значение заново:^

»>Vizbor='Милая моя, Солнышко лесное. ’2
Помните, что нумерация последовательностей в Питоне начинается с О?
1
2

Г 140 1

Автор - один из первых исполнителей бардовской песни - Булат Окуджава
Ю. Визбор. "Милая моя"

Набираем:

»>Vizbor [0]
И видим:
■М'

То есть первая буква значения переменной Vizbor - ”М”! А пятая?

»>Vizbor [4]

Нумерация символов в последовательностях начинается с 0, поэтому пятый
символ имеет 4-ый номер! Так, а теперь попробуем:\
»>Vizbor [-2]
'е'

Питон вернул нам предпоследний символ! Прелесть этой операции в том,
что мне не надо знать длину строки, чтобы получать символы с конца.
А дальше начинается самое интересное.

Есть такая операция - срез строки (мы ей, честно говоря, сейчас и вос­
пользовались).

Её формат:

[::]
Самое смешное, что все три параметра в ней - необязательные. Понятно,
что срез с одним параметром возвращает один символ с соответствующим
номером, что мы и проделывали выше.

ф

Г 141

Срез с двумя параметрами: Vizbor [i: j] вернёт подстроку из j
i символов, начиная с символа с индексом i и до символа с индексом j, не
включая его.
Например, хочу символы с 11 по 18:-,

»>Vizbor [11:19]
'Солнышко'
А теперь все символы, начиная с 6-го:

»>Vizbor [б:]
'моя, Солнышко лесное.'
А вот если указать все 3 параметра, то:

»>Vizbor [ 0 : : 2 ]
'Млямя оншолсо.'
- можно вывести каждый второй символ,

»>Vizbor [: : -1]
’.еонсел окшынлоС ,яом яалиМ'

И даже перевернуть строку!
Но! Сама строка Vizbor при этом ни чуточку не меняется, то есть если
вам надо выделить 1, 3 и 5 символ из строки и дальше с ним работать, надо
присвоить это значение другой переменной:-.
»>Vizl=Vizbor [0:6:2]
»>Vizl
'Мля'

А как узнать, сколько символов в строке? Очень просто - функцией len
(от английского length - "длина"):

»>len (Vizbor)
27
Пробелы тоже считаются! Не правда ли, очень полезная функция? Теперь
понятно, почему функция range (100) даёт последовательность от 0 до
99 включительно? Это удобно при работе с последовательностями. Вот для
примера распечатаем строку ... Строку? Да это же проще некуда:

»>print (Vizbor)
Милая моя, Солнышко лесное.
А если с каждым элементом строки я хочу что-нибудь сделать? Придётся
запускать цикл:
Lerm='Белеет парус одинокий'
for i in range(len(Lerm)):
print(Lerm[i],' ',end='')
На экране
Белеет

парус

одинокий3

Правда, как вы помните из главы 8, строку можно распечатать более элегант­
ным способом:
Lerm='Белеет парус одинокий'
for i in Lerm:
print(i,'.',end='')

Б .e .л .e .e .т . .п .a .p .у .с . .о .д .и .н .о .к .и .й .

Между прочим, строковые переменные можно складывать. И
присваивать новое значение старой переменной. И таким образом, немного
обманывать Питон, всё же меняя значение строковой переменной, так же,
как и числовой:
3
А знаете ли вы, что фамилия Лермонтов - шотландского происхождения? И ведет своё
начало от Джорджа Лермонта, шотландского наемного воина, осевшего в России в XVII веке

»>Vizbor='Милая моя,

Солнышко лесное,'

»>Vizbor2='где, в каких краях встретишься со мною?'
»>Vizbor2= Vizbor + Vizbor2
»>Vizbor2
'Иотая моя, Солныпко лесное, где, в каких краях встретишься со мною?'

С помощью этой хитрости и цикла по всей строке давайте уберём из перемен­
ной Vizbor все пробелы:
Vizbor='Милая моя,

L=len(Vizbor)
W=''

Солнышко лесное.'

# длина строки

# создаём новую переменную

for i in range(L):

# цикл по всей строке

if Vizbor[i]!='

':

W=W+Vizbor[i]

print

(W)

# если символ не пробел

# то добавляем его в W

# печатаем результат

Программа напечатает:

Милаямоя.Солнышколесное.

4)111111111 IIIIIIIIIIIIIIIIIIII III НН пн Illi IIIIIIIIIIIIIIIIIIIIIIIIIIIIlliIIIIIIIIIIIIIII 1111 IlliIliiiilliiliilliiiliiiiiiiiiiiiiliiilliiiiiiiiiiiiiiilililillllliliiiiilililillilllilililillliiliiilillllliliiilillllliliiliiilillllliillliliiiiiib

Упражнение 13.1
С помощью очень полезной функции len() найдите пятое
слово в текстовой переменной Txt, присвойте его переменной
Txt2 и напечатайте её. Чему равна переменная Txt? Ну экие
вы беспомощные... пусть это будет стихотворение самого
популярного в России поэта. Ну что вы, это не Пушкин...
Этот стих легко процитирует практически любой россиянин в
возрасте 3+, а вот со стихами Пушкина мы знакомимся только
лет с 7...

Ну? Догадались?
"Наша Таня громко плачет: уронила в речку мячик4"

Подсказка: слова отделяются друг от друга пробелами.
4IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

4

А. Барто "Мячик"

ф

Строки можно складывать в любом количестве и порядке, а операция
сложения носит гордое название конкатенация:

»>S1=' абра'
»>S2=' кад'
»>SS=S1+S2+S1
»>ss
'абракадабра*

Оператор in позволяет узнать наличие подстроки в строке

>»';
False
В переменной SS все слова идут с маленькой буквы, поэтому Питон спра­
ведливо считает, что подстроки 'Абр' в слове "абракадабра" нет, а вот 'даб'
- есть:

»> 'даб'
True

in SS

Все догадались, что in в переводе с английского "в"?

Ну и напоминаю, что оператор * позволяет повторить строку заданное число
раз:
»>print ("ку-ку "*10)
ку-ку ку-ку ку-ку ку-ку ку-ку ку-ку ку-ку ку-ку ку-ку ку-ку

А теперь немного отвлечёмся.

Как, я надеюсь, вы понимаете, буквы в компьютере представляются
длиннющей чередой нулей и единиц, причём у каждой буквы - свой
набор единичек и нулей.

♦

А вот какой букве какой код соответствует - определяется таблицей Юникод,
в которой содержатся коды для почти 1,1 миллиона (!) символов. Куда так
много? А там содержатся символы для почти всех алфавитов мира и китай­
ских иероглифов в придачу. Так что каждому символу соответствует свой
номер в этой таблице, например "" (пробел) идёт под номером 40, буква 'щ'
- под номером 1097...

1065
»>ord ( ' 4' )
52

Да, символ цифры 4 отличается от цифры 4 (которая имеет код 00000010).

Вот вам и код китайского иероглифа '

- дерево.

А теперь используем полученные знания в не совсем мирных целях:
4IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIU.

| Упражнение 13.2
| А не поиграть ли нам в разведчиков? Что? Надоело
| в разведчиков? Тогда в шпионов! Давайте взломаем
I сообщение, зашифрованное простейшим способом 146

4

| так называемым "шифром Цезаря"5.. В этом шифре
I каждый символ в открытом тексте заменяется символом,

|
|
|
|

находящимся на некотором постоянном числе позиций левее
или правее него в алфавите. Например, в шифре со сдвигом
вправо на 2, буква А была бы заменена на В, Б станет Г, В - Д
и так далее. Число "2" в этом случае называется ключом.

|
|
I
|
|
I
|
|

Допустим, перехвачено сообщение от вражеского шпиона:
"Утейимцйпг$сй$хчигц", созданное шифром Цезаря.
Пользователь вводит предполагаемый ключ, программа
производит обратный сдвиг в сообщении и выводит
полученную абракадабру на экран. Если полученный
результат нас удовлетворяет - печатаем "да" и прекращаем
работу; если нет - печатаем что угодно и продолжаем игру в
угадайку.

| Разумеется, при решении задачи надо использовать функции
! ord() и chr().
AllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllIllllllllllllIlF

Очень полезна функция str (), которая тупейшим образом превращает то,
что стоит в скобках в строку:
>»str (123)
■123'
»>str (3.14)
'3.14'

И даже
»>str (True)
'True'

5
Гай Юлий Цезарь (100 год до н. э. — 44 год до н. э.) — древнеримский государственный и
политический деятель, писатель, полководец. От его фамилии, между прочим, происходит и русское слово
"царь" (на древнерусском оно писалось как цьсарь (ь в древнерусском произносилась как краткий звук е)

ГП4Г1

|

|

lilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllk

Упражнение 13.3
Напишите программу, которая вводит целое число, а выводит
последнюю цифру квадрата введённого числа; используем
функцию str(). Кто сказал: "Ну это же просто!"? Хорошо,
уточняю: программа должна занимать ОДНУ (да-да, одну)
строку.

^iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiih

Упражнение 13.3.1
А теперь хочу напечатать первую цифру квадрата введённого
числа.
. ................................................................................................................................................. IIIIIIIT

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

»>Vizl=' Мля ’
Чтобы применить к объекту какой-нибудь метод, надо приписать его (метод)
через точку. Применим метод . swapcase ():-?

»>viZl=Vizl. swapcase ()
»>print (viZl, Vizi)
мЛЯ Мля
To есть метод . swapcase () заменил верхний регистр на нижний и наобо­
рот, при этом переменная Vizi не изменилась, и нам пришлось результат
загрузить в переменную viZl!

Это и есть главный недостаток и главное преимущество строк: никакие
методы не меняют содержимое обрабатываемой строки, а чтобы полу­
чить результат преобразования строки, его надо присвоить другой пере­
менной (а можно и той же самой!).
Работу основных методов обработки строки будем познавать на примерах.
Для примера возьмём переменную
>»Aref = "я не русалка - меня сом недоглотил!"6

и будем применять к ней разные методы.

Метод . capitalize () делает прописной первую букву строки:-^

»>Aref. capitalize ()
'Я не русалка - меня сом недоглотил!'

Метод . title () делает прописной первую букву каждого слова:-.

»>Aref. title ()
'Я Не Русалка - Меня Сом Недоглотил!'

Ну теперь, как говорится, /л

"Читатель ждёт уж рифмы "розы "
На вот, возьми её скорей!"7

- сделаем все буквы прописными:
»>Aref. upper ()
'Я НЕ РУСАЛКА - МЕНЯ СОМ НЕДОГЛОТИЛ!'
6
О. Арефьева "Одностишийа". Это не опечатка! Сборник интереснейших одностиший Ольги
Арефьевой действительно так и называется
А.С. Пушкин "Евгений Онегин".

Г 149 1

Побаловались - и хватит. Вернём всё как было:

»>Aref. lower ()
'я не русалка - меня сом недоглотил!'
Сделаем что-то вроде заголовка:

»>Aref .center (50, ' + ')
■+++++++Я не русалка - меня сом недоглотил!++++++++'
Данный метод, понятное дело, центрирует строку, заполняя излишки справа
и слева знаками + (это у меня. А по умолчанию пробелами). Первый па­
раметр определяет длину новой строки, а второй - каким символом будем
заполнять.

Два аналогичных метода .1 just( width, char)n .rjust( width,
char) тоже делают строку длиной width (ширина с английского) по
необходимости заполняя последние/первые места символом char:-

»>Aref. 1 just (38 ,
'я не русалка - меня сом
»>Aref.rjust (40,
'@@@@@я не русалка -

' *')
недоглотил!—1
'@')
меня сом недоглотил!'

Ну а метод .strip() удалит указанные знаки в начале и в конце строки:-.

»>Aref. strip (' я')
' не русалка - меня сом недоглотил!'
»>Aref. strip (' • ')
'я не русалка - меня сом недоглотил'

Для последующих опытов оставим в покое русалок и перейдём к поросятам:

»>Pig='''О храбрый, храбрый пятачок!
Дрожал ли он? О нет! О нет!''' •

Строки, которые обрабатывает Питон, могут быть очень длинные или даже
поэтические, как в нашем случае.

Для записи таких строк с сохранением форматирования и переноса
строк используется тройной апостроф в начале и в конце строки.

Сколько раз в тексте встречается слово нет!
»>Pig. count (' нет')
2

А буква р!
»>Pig. count (1 р')
5
А в какой позиции впервые встречается слово нет!

»>Pig. find (' нет')
44

А вот номер последнего вхождения находится так:
»>Pig. rfind (' нет')
51

То есть ищем вхождение в обратном (reverse) порядке - с конца
строки, поэтому метод называется rfind.

4

А. Милн "Винни-Пух и все-все-все". Пересказ с английского Б. Заходера

А. если подстрока не найдена?
»>Pig. find (’ да ’)
-1

Ага! Если строка не найдена, то мы получим -1 (такой же ответ даёт метод
. rfind () ). Ну и зачем всё это, спросите вы? Я и так могу сказать,входит
слово в строку или нет... Ну, во-первых, программы обычно имеют дело
со строками, состоящими из миллионов(!) символов. А во-вторых, вот вам
простое
........................ .................................................................. . ...........................................................................................................................................................................................................................................

Упражнение 13.4
Составьте программу, которая считает, сколько раз во фразе
"Подумав немного, он положил на блины самый жирный
кусок сёмги, кильку и сардинку, потом уж, млея и задыхаясь,
свернул оба блина в трубку, с чувством выпил рюмку водки,
крякнул, раскрыл рот...

Но тут его хватил апоплексический удар."9

встречается тот или иной набор букв, введённый
пользователем. А вот здесь пусть выход из программы
происходит, когда пользователь нажал любую цифру.

Подсказка: метод .isdiqitO выдаёт True, если строка
состоит из цифр.
lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIU

Упражнение 13.5
А теперь хочу увидеть программу, которая определяет,
является ли введённая строка палиндромом, то есть читается
одинаково слева направо и справа налево.

Подсказка: а вот здесь надо применить метод
.replace(old, new),который заменяет все вхождения
подстроки old на подстроку леи/.
lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

9

А. Чехов "О бренности"

Почему я не рассказал об этом сразу, в методах обработки
строк? "Никто не обнимет необъятного10", а Питон
совершенно необъятен ...
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Что? Пример палиндрома?! Вы не читали в детстве про Буратино?! "А роза
упала на лапу Азора" - это оттуда классический палиндром; но А. Толстой
позаимствовал его у Афанасия Фета - знаменитого русского поэта.

Но давайте лучше используем мой собственный, авторский палиндром:

''И Вере наша Саша не реви... "
который я написал про своих детей :)

Остались ещё силы на упражнения?

Тогда надо написать полезную программу:
^iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiiiih

Упражнение 13.6
Обычное явление - когда
по неизвестной причине
тексте почему-то
появляются лишние пробелы, вот
у меня. Задача - написать простую
как сейчас
программу, которая удаляет лишние пробелы в тексте.

в

А в качестве подопытной фразы используем начало весёлой
повести Джерома К. Джерома :
"Нас
было четверо — Джордж,
я и Монморенси11".

Уильям Сэмюэль Гаррис,

Удалите лишние пробелы и сосчитайте улов (то есть сколько
пробелов удалили)
'nilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

10
11

ф

Козьма Прутков
Да, повесть "Трое в лодки, не считая собаки" начинается именно так: "Нас было четверо'

|l||«4* Строка - это просто обычный текст, присвоенный любой переК* менной. Помимо очень эффективной операции среза строки
существует ещё множество методов обработки строки.

Однако здесь надо помнить, что строки в Питоне неизменны, так что
если надо запомнить результаты работы над строкой - присвойте его
какой-нибудь переменной.

Методов обработки строки аж 47 штук, самые нужные я перечислил в
Приложении 1.

В общем, вы уже поняли, что список методов обработки строки поистине
огромен, проще ознакомится с ним в Интернете, когда приспичит...
Займёмся другим видом последовательности, который в Питоне называется
списки (хотя мне лично больше нравится привычное название массив, но
тут, как говорится, "поздняк метаться" - слово "список" стало привычным
термином в Питоне).

Глава 14.

СПИСКИ

Список - это тип данных, предназначенный для хранения набора или
последовательности разных элементов.

Как обычно, ясно, что ничего не ясно. Ладно, создадим список:

»>Sps=[l,

2.05,

'абвг',

[6.6,

120] , "eight"]

Здесь Sps имя списка, а в квадратных скобках через запятую перечислено
всё, что в него входит:

1. На позиции № 0 число 1
2. На позиции № 1 - число с плавающей запятой 2,05
3. Строка абвг
4. Список [6.6, 120]
5. Строка eight на позиции № 4.

То есть в качестве элементов списка может быть всё, что угодно - числа,
строки и даже ... другие списки, как видите.

Обращаются к элементам списка точно так же, как к строке:
»>Sps [0]
1
»>Sps[3]
[6.6,120]
»>Sps [-4]
2

.................................................................................................................. •

Функция len (), как всегда, даёт длину списка (а именно - количество
элементов):

»>len (Sps)
5

А теперь давайте распечатаем список. Какой? Другой

Digit=[1,'one',2,' deux',3, 'drei']
for i in range(len(Digit)):
D=Digit[i]
print (D, end=' ')
На экране, как и ожидалось:

1 one 2 deux 3 drei
Здесь в цикле меняется индекс элемента i,
списка с индексом i.

затем выводится элемент

Однако в Питоне есть более эффектный (и эффективный) способ распеча­
тать весь список: л

Digit=[1,'one',2,' deux',3,
for j in Digit:
print (j, end=' ')

'drei']

Здесь элементы списка выводятся в одну строку, разделённые про­
белом, при этом в цикле переменная j принимает сами значения
из списка - точно так же, как в предыдущей главе мы распечатывали
строку Лермонтова.

Данный способ удобен, когда нам надо пробежать последовательно все эле­
менты списка. Если же надо как-то дополнительно обработать элементы
списка, то придётся применить первый способ:

Digit=[l,'one',2,' deux', 3, 'drei']
for i in range(0,len(Digit) ,2):
D=Digit[i]
E=Digit[i+1]
print (D, E)

на экране видим:
1 one
/
2 deux
3 drei
Это более удобный способ показать число и его перевод на языки мира английский, французский и немецкий, если вы ещё не догадались.

Списки относятся к изменяемым типам данных, в отличие от строк.

Например, заменим 4-ый элемент в Sps на о:

>»Sps[3] = 'co'
»>Sps
[1, 2, ’абвг1, V, ’eight']
Мы благополучно заменили 4-ый элемент списка!

А вот добавить элемент в список вот так запросто не получится:
»>Sps [5] =2.12
Traceback (most recent call last):
File "Dict = {

’’one”

:

’’один",

’’two”

:

’’два”,

’’three”

:”три”

}

:’’три"

}

Доступ к значениям словаря осуществляется по ключу:
»>Dict ["one"]
1 один '

И напишем программу, аналогичную вышеприведённой:^
Diet = {

"one”

:

"один”,

’’two”

:

wrd=input("переведи на русский:

print

"два”,

’’three”

")

(Diet[wrd])

Коротко и понятно! На экране мы получим небольшой диалог:
переведи на русский: one
один

♦

179 1

В словарь легко добавить запись:

»>Dict [ "four" ] ="четыре"
»>Dict
{'one': 'один', 'two': 'два', 'three': 'три', 'four': 'четыре'}

Но если ключ уже есть в словаре, ему будет присвоено новое значение:
»>Dict [ "four" ] ="пять"
»>Dict
{'one': 'один', 'two': 'два', 'three': 'три', 'four': 'пять'}

А вот удалять ключ из словаря надо специальным оператором del
("delete" - "удалять"): х
>»del Diet ["four"]
»>Dict
{'one': 'один', 'two': 'два', 'three': 'три'}

При обращении по несуществующему ключу Питон вас вежливо отругает:
»>Dict [' five' ]
Traceback (most recent call last):
File "", line 1, in
Dict['five']
KeyError 'five'
(Приговаривая, наверное, про себя: "Трудно ловить чёрную кошку в тёмной
комнате. Особенно, если там её нет "2)

Так что желательно сначала убедиться в наличии ключа с помощью опера­
тора in:
»> "five" in Diet
False
Изречение приписывают китайскому философу Конфуцию, вот только в его трудах этой
фразы почему-то не нашлось

2

180

lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllliu

| Упражнение 16.1
|
|
|
|
I
|
|

Пусть у нас есть список сотрудников фирмы "Художники". У
каждого художника свой табельный номер. Эти номера, мало
того, что идут не подряд, так ещё и некоторые отсутствуют
(ну вдруг человек уволился - тогда его табельный номер
вычёркивается и другому не присваивается). Задача: найти
в этом списке какого-нибудь Айвазо... И правда - пора найти
Айвазовского и вывести на печать его табельный номер.

|
|
|
|

Осложнение: бестолковый пользователь может ввести
фамилию с маленькой буквы - тем не менее, сотрудника в
любом случае надо найти (в списке, а не в комнате, где он
сидит).

|

| Усложнение: если человека нет в списке, надо его туда ввести |
| и присвоить новый табельный номер.
|
1
|
|

Дополнение: вводить нового человека надо с разрешения
пользователя - вдруг человек (тот, который пользователь)
ошибся в написании его (нового человека) фамилии.
Подсказка: надо использовать методы .isdigitf) и .strip().

|

i Замечание: разумеется, надо создать словарь, в котором
| каждому табельному номеру отвечает фамилия художника.
|
I
I
|
|

Окончание: программа работает постоянно (то есть
организуем бесконечный цикл), пока у неё (программы?! Да
нет же, у сотрудницы отдела кадров!) не закончится рабочий
день, следовательно, программа завершает работу при вводе |
любой цифры (выходим из цикла оператором break).

^Iillillllllllillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirf

Самый простой способ создать словарь - просто перечислить пары "ключ” :
’’значение” - но не самый удобный.
Но можно сделать это более элегантным способом - через функцию
zip () ("застежка").

1

Например:
keys= ("apple", "cucumber", "melon", "raspberry", "pear")
Val=("яблоко", "огурец", "дыня", "малина", "груша")
fruits=zip(keys, Vai) # объединяем 2 стиска в список ксртеиоей (17.1)
dicF=dict(fruits) # создаём из списка кортежей словарь
print (dicF)

Разберём, что у нас получилось.

Результат работы функции zip (), к сожалению, это вещь в себе, назы­
вается объект, и делиться содержимым так просто не желает, попробуйте
fruits распечатать^

»>fruits

Что там написано? По-моему, "сам дурак!", хотя я могу и ошибаться. А вот
функция diet () может с этим объектом-субъектом договориться - после за­
пуска программы (17.1) видим на экране:

{'apple*: 'яблоко', 'cucumber': 'огурец', 'melon': 'дыня',
'raspberry': 'малина*, 'pear': 'груша'}
Я надеюсь, вы догадываетесь, что словари в Питоне используются не только
как словари (прошу прощения за тавтологию)?
Ну например, давайте сосчитаем, сколько раз встречается каждая буква в клас­
сической фразе

"...Бойцовый кот есть самостоятельная боевая единица сама
в себе, способная справиться с любой мыслимой и немыслимой
неожиданностью... "3

3

Великолепная железобетонная фраза-девиз из пророческого произведения Стругацких
"Парень из преисподней"

С помощью словаря задача решается элегантно и просто:^
TomCat = ”Бойцовый кот есть самостоятельная боевая
единица сама в себе,

способная справиться с любой мыслимой и

немыслимой неожиданностью"
АВС = {} # создаём пустой словарь
for i in range (1, len (TomCat) - 1) : # проход по заданной фразе
if TomCat[i]

not in ABC:# если символа нет в словаре

ABC [TomCat [i] ] = 1 # добавляем символ в словарь как ключ
и задаём его значение как 1
else: # символ есть уже в словаре

ABC[TomCat[i] ] += 1 # увеличиваем его значение на 1

print

(АВС)

# печатаем распределение частот

Запускаем и любуемся на результат:

1

illllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll^

| Упражнение 16.2
| Пока любуетесь на результат, добавьте в программу пару
| строк, чтобы узнать, какие 2 символа встречаются чаще всего. |
^llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

В своё время (вторая половина XX века) был очень популярен ’’Эрудит”
- игра, где нужно составлять слова (русские, осмысленные) из букв, как
в кроссворде, на специальной игровой доске, причём каждая буква имела
свою стоимость (в баллах). Стоимость слова рассчитывалась как сумма сто­
имости букв, из которых оно состоит. Например, буква М давала 2 балла,
буква А - только I, поэтому слово МАМА давало игроку 6 баллов.
^iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiiiiih

| Упражнение 16.3
| Напишите программу, которая посчитает для "Эрудита"
| стоимость слова, введённого с клавиатуры. Вот здесь-то
| словарь пригодится во всей красе!

|

Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

183

^lillIllIlllllillIilIlillliillilllilllillllllilllillIilIlllIlilllllIllIilllllilliilliillIlllilililllllililllilliilililIlillillilillilllilllillllllllllllllllllIlllIllIIIIIlllllllllIlilllllIllilllllIlillllllllllIlllIlllllllllllllIlllIlilllillL

Кроме того, нужна наша любимая "защита от дурака" - если
введено слово из нерусских букв - проявляем патриотизм
и пишем: "Слово должно состоять только из русских букв”.
Выход из программы пусть будет при нажатии любой цифры.

|
|
|
|

4lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllff

h|Je Словарь в Питоне - это вам помощнее обычного словаря будет!
yTjT В нём вы можете содержать любые пары слов и чисел. И обра­

щаться к значениям надо не по номеру, а по кличкам... извините,
по ключам. И добавлять в него пары ’’ключ-значение" легко и просто. И
методов в словаре всего-то 11. Основные, как обычно, в Приложении 3.

Ну вот, теперь вы знаете про Питон почти всё, что надо для начала. ”И всё бы
хорошо, да вот что-то нехорошо”.4

Ну конечно же! Мы забыли о множестве - интереснейшем виде последова­
тельности.

4

А это уже А. Гайдар, "Сказка о военной тайне, Мальчише-Кибальчише и его твёрдом слове"
.............................................................................................................................................................................f

184 J

Глава 17.

МНОЖЕСТВО

Множество - это набор уникальных элементов, да ещё и сложен­
ных в беспорядке.

”Да это же свалка!” - скажете вы. Нет! Это называется ’’рабочий беспорядок”
- вы же у себя на столе довольно быстро находите, что надо. А в Питоне в
свал... - в множестве нужный элемент находится мгновенно!
Как обычно, начнём с примера. Возьмём великолепное (и заметьте, очень
верное!) двустишие:

"Сомнений нет у идиота,

сомненья гложут мудреца"1

и поместим его в переменную SOFO:^
»>SOFO='Сомнении нет у идиота,

сомненья гложут мудреца'

И сделаем из него множество посредством функции set() (это мно­
жество" по-англииски - на тот случаи, если вы еще не выучили
англиискии):

»>Sofo=set (SOFO)

1

■И

Владимир Поляков - автор огромного количества остроумных (и просто умных) двустиший^

И посмотрим, что у нас получилось:

»>Sofo

То есть получился просто список букв, использованных в подопытном афориз­
ме! Да ещё и без всякого порядка! Ну и зачем городить новое понятие, которое
даже хуже старого? А затем, что в множестве нужный элемент находится
необыкновенно быстро!

Кто сказал "Не верю!2”? Ах это вы, уважаемый Константин Сергеевич... Тут
вам не МХАТ - сейчас докажу на примере!

Набираем на компьютере программу:/^
import random # грузим генератор случайных чисел

import time # грузим модуль времени
Rand=[]

#Список,

куда сложим случайные числа

for i in range (100000) :#Создаём список из 100000 случайных чисел
X=randon.randint (1,20000) #случайное целое число из диапазона
1-20000

Rand.append(X)

# Добавляем это число в список Rand

SetRan=set (Rand) # Сделаем из списка множество и запомним его в
SetRan

Tl=time.time()
for j

#засекаем время

in range(1,10000):

j

in Rand Нищем последовательные числа в списке

T2=time.time()-Т1 #поиск в списке занял Т2 секунд
print

(Т2)

#печатаем время поиска в списке

2
Слова знаменитого режиссёра Станиславского К.С., создателя МХАТа, которые он произносил на
репетиции, если игра актёров ему не нравилась. По системе Станиславского актер должен максимально вживагься в
роль. Если в игре актёра Станиславский чувствовал ненатуральность, фальшь, то он восклицал "Не верю!"

T3=time.time()
for j

Ненова засекаем время

in range(1,10000):

j in SetRan

#ищем последовательные числа в множестве

T4=time.time()-ТЗ #поиск в множестве занял Т4 секунд

print

print

(Т4)

#печатаем время поиска в множестве

('множество обработано в',int(Т2/Т4), ' раз быстрее')

Запускаем и читаем на экране
время поиска в списке 1.6862566471099854
время поиска в множестве 0.0009968280792236328

и самое приятное (барабанная дробь!!!)

множество обработано в 1691 раз быстрее

Бурные аплодисменты! Занавес. Потрясённый Станиславский покидает нас,
бормоча: ’’Какие страсти кипят в информатике! Куда там моему театру!...
Никогда бы не поверил!...”

При запуске у вас на компьютере результаты будут несколько иные, время
расчёта зависит от множества таинственных процессов, постоянно проис­
ходящих у нас в компьютерах.

Что мы делали в этой программе? Сначала записываем в список Rand
100 000 случайных чисел из интервала от 1 до 20 000, на его основе создаём
множество SetRan; затем запускаем цикл проверки наличия чисел из
интервала от 1 до 9999 сначала из списка, а затем из множества и смотрим,
за какое время наш любимый Питончик проделает эти операции.
Я думаю (безнадёжный я оптимист!), что все поняли - модуль time как-то
занимается измерением времени - и тут вы совершенно правы!

Метод time. time () сообщает, сколько секунд прошло с начала эпохи

Да нет, не с Рождества Христова - тогда в качестве компьютера использова­
лась счётная доска - абак. И самые лучшие компью... э... абаки стояли во
дворцах царей и выглядели как доска из слоновой кости с сапфировыми и

рубиновыми камнями. Производительность этих первых счётных устройств,
конечно, была маловата...
Так вот, у программистов эпоха начинается с 1 января 1970 года (я вас пред­
упреждал, что мышление у программистов немножко сильно отличается от
мышления нормальных людей).

Метод time. time () возвращает нам, сколько секунд прошло с начала
эпохи в момент обращения к нему, причём с невероятной точностью.

Итак, поиск в множестве происходит очень быстро-, а чем ещё они
хороши?
Давайте для примера возьмём теперь одностишье :

Тебя сейчас послать или по факсу?3
Поместим его в переменную VISH:

>»VISH="Te6n сейчас послать или по факсу?"

И сделаем из неё множество:
»>Vish=set (VISH)

Вы не забыли, что у нас есть ещё множество Sofo? Давайте узнаем, какие
буквы есть как в одностишии, так и в двустишии:

»>Vish&Sofo
Пожалуйста: л

4

Автор - Владимир Вишневский. Он и создал этот оригинальный жанр - одностишья

Г 1X4 1

То есть оператор & (амперсанд) - это пересечение множеств. А вот
объединению множеств достался довольно странный знак | (вертикалы
ная черта)\
»>Vish | Sof о

{'С, 'й', 'п', Ч У,

ф', -Д’, W, 7, ч Т, ч Ч, Ч ч 'т', Ч1', ч ч ч Ч Ч С, W, Ч 4}

Почему создатели Питона постеснялись использовать для данной операции
обычный знак "+" (плюс) - непонятно. "Есть многое на свете, друг Гора­
цио, что и не снилось нашим мудрецам"4. А вот знак
(минус) - пожа­
луйста, работает:
»>VS=Vish-Sofo
{■п\ 'б', •?•,
Ч, 'ф1, 'к')

Эта операция удалила из множества Vish все элементы, которые есть и во
множестве Sof о, и загрузила их в множество VS.

Ну и наконец оператор А (стрелочка вверх) выдаст нам элементы обо­
их множеств, исключая одинаковь/е.ч

»>VishASofo

■*
■б1}

У множества всего-то 5 методов:

»>VS.add(100)
{'л', ’б*, •?•, 100,Т, -ч', 'ф', ‘к’}

Добавили число 100 в множество, причём Питон помещает новый элемент
куда ему заблагорассудится. А вот для удаления элементов придумано аж 3
(!) метода (а ещё говорят "ломать - не строить!". Создатели Питона, видимо,
придумали метод для удаления, потом забыли про это, и создали ещё пару
методов).
4

Шекспир, «Гамлет». Перевод Н. Полевого. Почему-то в качестве фразеологизма используется
именно этот вариант перевода, несмотря на то, что существует более 20 других переводов I

Методы .remove (x) и .discard(x) удаляют элемент x из множества;
а отличие между ними почти незаметное: если удаляемого элемента
нет в множестве, то в первом случае произойдёт ошибка и программа
остановится, а во втором случае ничего не произойдёт и программа
преспокойно продолжит работу’

»>VS . remove (' к')
»>VS
{'п1, 'б', ■?', 100,Т, 'ч', 'ф'}
»>VS. discard (' ? ')
{•п\ 'б', 100,Т, Ч 'ф'}
»>VS. discard (' к')

»>vs
{■п\ 'б', 100,Т, 'ч', 'ф'}

А вот метод .pop () удаляет произвольный элемент (то есть какой
Питону захотелось) и возвращает его:

»>vs
{'гТ, 'б', 100,Т, 'ч'}

Ну и последний метод просто очищает множество:

»>VS. clear ()
»>VS
set()

Так как множество - неупорядоченный набор элементов, то обращаться к
его элементам по номерам не получится:

»>Vish[5]
Traceback (most recent call last):

File ",\ line 1, in
Vish[2]
TypeErron 'set' object is not subscriptable
Перевожу смысл последней строки: ’’Ошибка типа: объект ’’множество” не
нумеруется”.

Но, тем не менее, содержимое множества можно последовательно перебрать
(пишем простенькую программку):^
Gogol="H какой же русский не любит быстрой езды?"5

GGL=set(Gogol)
for i in GGL:

print

(i,

end='

’)

запускаем и Питон послушно выдаёт всё содержимое множества GGL, при­
чём в своём тайном порядке:

едюбо

йтикзысИн?ажрлу

Между прочим, в множествах прекрасно работают функции max,
разумеется, 1еп:/\

min и,

»>len (GGL)
21
»>max (GGL)
'ю'
»>min (GGL)

■I

Понятно, что с буквами операторы шах и min работают как-то туманно. А
вот с числами дело пойдёт веселей:
»>Numb={2,2.21567,7.11,-0.213}

Да, множество можно создать напрямую, записав его элементы в фигур­
ных скобках.
5

Ну это, конечно же, Н. В. Гоголь, и конечно же, "Мёртвые души"

А вот со строками этот фокус не проходит:

»>RURU= { ' Буквы' }
»>RURU
{'Буквы'}

То есть для разбиения слова на буквы надо применить оператор set
непосредственно к строке:^

»>set (' Буквы')
{'у', 'в', 'ы', 'к'. 'Б'}
Вернёмся к переменной Numb, а то она заскучала:

»>max (Numb)
7.11
»>min (Numb)
-0.213

»>Sum (Numb)
11.112670000000001

Как я писал в упражнении 15.2, Питон порой ошибается в 16-ом знаке
после запятой.

Я вижу, вы уже перегружены знаниями о множествах - значит, надо от­
дохнуть, сделать упражнение.

193 1

^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIX.

Упражнение 17.1
Определить, являются ли слова:

отсечка
сеточка
тесачок
чесотка
анаграммами, то есть состоят из одних и тех же букв.
tiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiF

Вообще-то говоря, применение множеств для определения, является ли одно
слово анаграммой другого, не совсем правильно. В анаграммах иные буквы
могут повторяться, например:
лепесток - телескоп
А вот для панграммы (это короткий текст, использующий все буквы алфави­
та, по возможности не повторяя их) понятие множества как нельзя подходит.
Самый известный пример панграммы: л

Съешь же ещё этих мягких французских булок да выпей чаю.
illllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll|llllll|lll|l|l|l||l|||lll|l|||l||l|l|l|||l||||||||l|||||l||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||£

Упражнение 17.2
Напишите программу, которая проверяет, является ли
заданный текст панграммой. На экран следует вывести текст:
"Это панграмма" и количество букв в ней, либо просто "это не
панграмма"
tiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii|||Г

Упражнение 17.3
Вооружённые новыми знаниями, создайте программу
"Морской бой". Нет, не настоящий "морской бой" на 2

бумажках, а будете искать, куда Питон расставил свои
корабли. Значит, так: программа сначала случайным
образом выдаёт координаты (буква + цифра) и запоминает
их в множестве, а затем предлагает вам пострелять. Если
выданные вами координаты есть в множестве - значит попал. |
Нету - промазал. При нажатии какой-нибудь редкой буквы
игра заканчивается и Питон печатает результаты: число
попаданий и промахов. Да-да, вы правы: получается, что все
корабли у Питона - однопалубные.
TIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIT

iliiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiib

I Упражнение 17.4

|
|
|
|
!
|
|
|
|
|
|

Для игры в "Морской бой", конечно, использование
множества некритично - слишком небольшой размер
поля. А вот теперь представьте ситуацию: у вас есть
автоматизированный склад на 10 000 000 ячеек, и вам надо
как можно быстрее найти пустую ячейку поближе к выходу
(это чтобы снизить пробег погрузчика - склад-то огромный, а
электроэнергия для зарядки погрузчика не бесплатна), чтобы
отправить туда робот-погрузчик-штабелёр с поступившим
грузом. Вот тут понятие множества и пригодится - работает
быстро и содержит только уникальные (номер ячейки
уникален) элементы. Поэтому напишите эту очень нужную в

| экономике программу.

Входные данные таковы: на складе 10 000 000 ячеек;
| нумерация ячеек вида x-y-z, где х и у меняются от 1 до 1000, а
I z от 1 до 10. Если ячейка занята, то её номер есть в множестве
I SKLAD, свободна - номера нет. Сначала датчиком случайных

| чисел заполните склад на 99%, а затем сообщите №
| свободной ячейки поближе к выходу (чем меньше координата
| х или у - тем ближе к выходу находится ячейка).
TiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiiiF

195 I

А вот множества мне очень нравятся - за феноменальную
быстроту работы и уникальность значений. А методов всего-то
5, я лучше их просто напомню:

add - добавляет;
remove, discard, pop - удаляют;

clear - очищает.

При написании программ вы заметили, что иногда Питон спотыкается об
ваши же ошибки, ругается и прекращает работу, так что порой хочется руг­
нуться в ответ и сказать: "Что же ты, Питон, такой бестолковый? Ошибка
несущественная, пропусти её и считай дальше!!!".

Итак, что делать, если случилась авария? (раньше такие явления называ­
лись "авост ЭВМ" - аварийная остановка ЭВМ. Сейчас этот термин вышел
из употребления. Вместо него употребляется термин "А, опять подвисла,
зараза...").

"----------- 1

Глава 18.

ЧТО-ТО ПОШЛО НЕ
ТАК

Допустим, вам жизненно необходимо поделить 16,202 на разность между
17,4 и числом, вводимым с клавиатуры. Вы быстренько (ведь недаром же вы
почти всю эту книжку прочитали?) написали вот такую милую программу:
Ntt=16.202
U_u=17.4
t=float (input (' Жду число ’) )
K2K=Ntt/(U_u-t)
print(round(K2K, 2))

Программа хорошо, устойчиво работает. Вводим 11 - получаем 2.53, вводим
17 - на экране 40.51, вводим 17.4... - ба-бах! п

Traceback (most recent call last):
*
File "С:\Как бы диск 0\Питоновы программыМгу.ру", line 23, in
K2K=Ntt/(U_u-t)
ZeroDivisionError. float division by zero
По-моему, Питон чем-то недоволен...

Ну точно - в последней строке написано: ’’НольДелениеОшибка: текущее
деление на ноль”. Всё правильно - на 0 делить ни один компьютер не умеет.
А так всё было хорошо! Что делать? Проще всего не допускать, чтобы t
принимало значение 17,4 - это легко сделать, благо знаменатель у нас

.................................. *

простой. А теперь представьте, что знаменатель имеет вид, к примеру, вот
такой:

((U_u*i2i2+qR2*pek4a)-t)
и все переменные - переменные (прошу прощения за тавтологию). Таким
образом, деление на ноль здесь вполне может случиться, а в какой момент неизвестно, кроме того, что в самый неподходящий.

Вот для таких случаев, когда мы догадываемся, что неприятность может
случится, но не знаем - когда, и предназначен двойной оператор try /
except (в переводе с английского: "пытаться"/"исключение"). Опера­
ция, которая может вызвать исключение, помещается внутрь блока try.
А блок, который должен быть выполнен при возникновении ошибки, на­
ходится внутри except.

Перепишем нашу программу:

Ntt=16.202
U_u=17.4
t=float (input (' Жду число '))
try:
K2K=Ntt/(U_u-t)
print(round(K2K,2))
except ZeroDivisionError:
print ('случилось деление на ноль')
print ('продолжим работу')

С помощью оператора try я "пытаюсь" выполнить деление. Если деление
прошло нормально, то я вывожу результат на экран и продолжаю работу. А
вот если случилось деление на 0, то программа перепрыгивает на оператор
except ("исключение"), где и происходит обработка ошибки (просто пе­
чатаем ' случилось деление на ноль' и продолжаем работу). Пре­
рывания работы программы не произошло - и это главное!

Ф

Например, вводим 12, на экране:^
3.0
продолжим работу

А теперь 17.4:

случилось деление на ноль
продолжим работу
Всё прекрасно, деление на 0 мы обошли!

Небольшой нюанс: вы обратили внимание, что после except стоит
странное выражение ZeroDivisionError?

Когда программа при выполнении наталкивается на ошибку, то всегда ука­
зывает, в какой строке, какой программы и какого рода ошибка произошла:

Traceback (most recent call last):
File "С:\Как бы диск 0\Питоновы программы^гу.р/', line 23, in
K2K=Ntt/(U_u-t)
ZeroDivisionError float division by zero
Я выделил название ошибки. Дело в том, что ошибки могут быть самые раз­
ные (примерно 40 видов), и обрабатывать их порой надо тоже по-разному.
Вот, например, простая программа - вводим 2 целых числа, и делим одно на
другое.
Здесь возможны два вида ошибок:

1. Вместо числа введена буква, а то и какой-нибудь знак.

2. Деление на ноль.
и обрабатывать их надо по-разному.

200

................................................................f

Как называется ошибка деления на ноль, мы знаем:
ZeroDivisionError.

А как узнать название ошибки преобразования типа - это когда введено не
число, а буква?
Проще пареной репы! Даже программу писать не надо:

»>D=input ()
два
»>int (D)
В переменную D введено строковое значение ’ два ’, при попытке преобразо­
вать его в число мы получим ошибку:^

Traceback (mostrecentcalllast):
File "", line 1, in
int(D)
ValueError invalid literal for int() with base 10: 'два'

Вот вам и название ошибки: ValueError!

Тогда вот вам и программа с обработкой 2 видов ошибок:
while True:
try:

b = int(input('b =

’))

c = int(input('c =

'))

print

(’результат деления:

round

(b/c,

3))
break

except ZeroDivisionError:
print (’Далек» на 0. Федоте чюэ, отличное ст нуля')
except ValueError:

print('Введите,

пожалуйста,

число')

Г 201

Между прочим, возможна инструкция except без аргументов, которая
перехватывает вообще все возможные ошибки.

)
>

)
)

По-моему, нам пора размяться и применить полученные знания. Сделаем-ка
простое^
Illi Illi IIIIIIII Illi II11 Illi I III Illi IIII III IIIIIIIIIIIIII11II11II11II11II11111IIIIIIIIII11IIIIII111II III 1111111II11IIIIIII111 III IIIII III II11II11II11II11IIIIII11IIIIIIIIIIII Illi 1111 ПИП III Illi IIIII11IIIIIIIIIIIIIIIIII III II III Illi ПИП I НС

| Упражнение 18.1
| Допустим, у нас есть огромное множество, состоящее из
| самых разных элементов: чисел, строк... Нам позарез вдруг
| приспичило удалить из этого множества какой-нибудь
элемент (его вводим с клавиатуры). О выполнении задания
следует доложить кому следует (вывести сообщение на
экран). А если элемента нет? Об этом безобразии тоже
следует сообщить на экран.

|
|
|
|

| Подсказка: для удаления следует применить метод .remove(x).
miiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiiiiiir

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

N=float (input
print(N)

(' введите число: '))

и всё работает прекрасно - преобразуем полученную строку в число с пла­
вающей запятой и дальше его преспокойно обрабатываем. Но! А где защита
от дурака? Малейшая ошибка пользователя (по ошибке нажал клавишу с
буквой. Скажете, так не бывает? Ещё как бывает!1), и на экране появится
страшная надпись:

1

Г 202 1

Если какая-нибудь неприятность может произойти, она случается (основополагающий
закон Мерфи)

.................................................................................................. ф

Traceback (mostrecentcalllast):
File "С:/Как бы диск D/Питоновы программы/try.py", line 2, in
N=float(input ('введите число:’))
ValueError. could not convert string to float: 'д'

и пользователь ищет программиста, написавшего эту программу, с целью
поблагодарите убить его страшной смертью (тысяча чертей! завтра сдавать
годовой отчёт!!!!!). Питон тихонько хихикает в сторонке - он расписался в
своём неумении: «Не могу преобразовать строку в число: 'д'», а нам с вами
надо как-то разрулить эту ситуацию.
Конечно, самое простое, написать примерно такую программу:^

while True: #бесконечный цикл в ожидании ввода ЧИСЛА
try:
N=float(input ('введите число: '))
print(N) #печатаем введённое число
break #и завершаем программу
except ValueError :
print ('Введено не число')
Но это нас не спасает, от другой, совершенно дурацкой ситуации! А что если
пользователь вместо разделителя "точка" ввёл "запятую":

введите число: 5,5
и потрясённая новенькая бухгалтерша, ещё не знакомая с причудами нашей
программы, изумлённо читает на экране:-.

Введено не число
Она ведь ввела число! Что этому тупому компьютеру не нравится? Как вся­
кий нормальный человек, она повторяет ввод:

введите число: 5,5
Введено не число
Г

[L 203_ j

Дальше крики ’’Идиотская программа!”, ’’Уволюсь!”... А кто виноват?
Программист? Нет! Мне сказали: ’’напиши фрагмент программы, которая
отсекает ввод пользователем некорректных данных, а корректные данные это числа, целые или с плавающей запятой.”
Для пишущего программы на Питоне - 5.5 - это число, а 5,5... Э... Тоже
число, но некорректное^ Программист наивно полагает, что всё челове­
чество прекрасно знает, что то, что на русском языке называется ’’числом с
плавающей запятой” на самом деле выглядит ... как число с точкой! У нас
всё так делается - через ... точку.
Придётся продолжить поиск виноватого... так вот же он! Постановщик за­
дач! Именно этот человек обсуждает с заказчиком задачу, учитывает все его
капризы, а также выявляет все возможные и невозможные проблемы и затем
объясняет задачу программисту: что он должен создать и почему за столь
малый срок. Вот он-то (постановщик задач, конечно) и обязан был предус­
мотреть подобную ситуацию и разъяснить программисту, что 5,4 и 5.4 - это
одно и тоже число, как это ни странно.
Конечно, самое простое решение - это переложить проблему на клиента:
N=float(input('введите число (десятичные числа вводите

через точку):'))

Это не есть хорошо!2 Мы-то с вами, в отличие от Питона, понимаем, что хо­
тел сказать пользователь - не зря же относимся к виду ’’Человек разумный”.3

Поэтому придётся переписать программу примерно таким образом:
while True:
N=input (’введите число:')# вводится строка!
if ’ , ' in N: # Проверяем наличие запятой вместо точки
N=N. replace
#заменяем запятую на точку
try:
N=fLoat (N) # преобразуем строку в число
print(N)
break #и покидаем программу
except: #не смогли сделать из строки число

print (1 Это не число. Повторите ввод')
2
Ироничное подражание разговору иностранцев
3
А знаете ли вы, что в своё время, каких-то 100 000 лет назад, на Земле существовало
как минимум 4 биологических вида человека: неандертальцы; человек флоресский - карликовый
представитель рода Ното с острова Флорес, известен также как "хоббит"; денисовцы - жили в
Денисовой пещере на Алтае; и наконец, Homo Sapiens, то есть мы с вами

4

Таким образом программа ожидает от клиента строки, состоящей из цифр,
запятых и точек, превращает все введённые запятые в точки и пытается
полученную строку превратить в число. Это всё равно может не получить­
ся - но тут уж любой бухгалтер поймёт, что записи ” 112036,, 11” и ’’Люблю
Васю” никак не тянут на числа; и просьбу ’’Повторите ввод” воспримет
спокойно.
^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHIIIIIIIIIIIIIIIk

| Упражнение 18.2
Допустим, что у нас есть фрагмент огромной программы, в
котором к строчному значению переменной abc добавляется
значение переменной Dobo, которая иногда таинственным
образом принимает численное значение, что вызывает
появление ошибки и остановку программы. Программа
огромная! Пишется многими людьми из разных стран! И
кто в ней накосячил - разбираться некогда - завтра сдавать
проект! Надо просто обойти эту проблему, а уж дальше найти
виновного и...........................................!!!!!4

|
|
|
|
I
|
|
|
|

|

Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

HjTe
утчГ

Совершенно неожиданная возможность есть в Питоне подложить соломку в те места, где ожидается прилёт тела
программиста. Определяем опасные места в программе, и с
помощью неразлучной парочки try / except благополучно избегаем
остановки.

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

4

"Дальше следует непереводимая игра слов с использованием местных идиоматических
выражений" - бессмертная фраза из "Бриллиантовой руки"

Глава 19.

ИЗВНЕ

ИЗВНЕ1

Для открытия (то есть для загрузки в программу) файла в Питоне ис­
пользуется функция open () ("открыть" в переводе с английского):

Flf=open('test.txt', mode)
Здесь test. txt- это название открываемого файла, a mode - подсказывает
Питону, в каком режиме мы будем дальше работать с файлом (чтения и/или
записи. Если ничего не указано, файл открывается в режиме чтения). Ну, а
Flf - это переменная, где теперь лежит содержимое файла?
Как бы не так! Flf сейчас - это файловый объект! К нему нельзя подсту­
питься также запросто, как к переменной какой-нибудь.
Это - конструкция гордая, даже распечатываться не желает; наберите:^

»>print (Flf)

"

и получите набор местных идиоматических выражений языка Питон:

«Jo.TextIOWrapper name='test.txt' mode='r' encoding-ср1251’>
(эти питонистые ругательства я даже переводить не берусь).

1

Это отсылка к названию первой повести А. и Б. Стругацких - о посещении Земли
Пришельцами...

Как из Flf сделать нормальную переменную я расскажу немного позже, а
пока давайте создадим файл test. txt. Напишите в блокноте, что-нибудь
умное, например "Hello, world!". Зачем вы взяли бумажный блокнот? Пито­
ны не едят бумагу!

Сделайте запись в компьютерном Блокноте (или любом текстовом редакто­
ре) и сохраните в той же папке, где лежат все ваши программы на Питоне
под именем test.txt, естественно. В окне, когда записываете название файла,
посередине есть запись "Кодировка". Убедитесь, что там написано UTF-8.
Сохранили? Пишем программку:/л

Flf=open (’ test. txt ’)
А вот теперь давайте прочитаем содержимое файлового объекта Flf ме­
тодом . read () , а полученный результат присвоим уже нормальной пере­
менной ТХТ:

TXT=Flf.read()
print (TXT)
Flf.close ()

Да, после того как вы поработали с файлом, его необходимо закрыть
("close" - в переводе с английского "закрыть").

Почему? Освобождается память компьютера. Ладно, у нас пока что файл
малюсенький, а потом мы будем работать с файлами в миллионы знаков! Так
что привыкайте: открыли - закрыли!
Запускаем программу... Красота:

Hello, world!

Автор, чрезвычайно довольный, хихикает в уголке на пару с Питоном: во
всех учебниках "Hello, world" идёт в самом начале, а у меня появляется толь­
ко в конце книги !...

А почему фраза на английском? Давайте добавим что-нибудь по-русски,
например, напишем в файле test.txt на следующей строке "Я знаю Питон!".
Запускаем программу, и ..

Hello, world!
PI P PSP’CTi РиРёС.РэРБ!
А вот не надо было хвастаться! Не знаем мы ещё Питон!..
Что же произошло?

Как вам известно из 14 главы, каждая буква в компьютере записывается
в двоичном коде, например, q - это последовательность из 8 бит:
00101011

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

F=open('test.txt', encoding = "utf-8")
Далее как обычно:

TXT=F.read()
print (TXT)

Hello, world!
Я знаю Питон!

Не всегда нам надо читать весь файл целиком, можно считать только
несколько символов (но почему-то только с начала):^

F=open('test.txt'r encoding="utf-8" )
TXT=F.read(5)
print (TXT)

На экране:

Hello

С другой стороны, если вы знаете, откуда начинается ваша информация,
можно просто промотать лишнее:
F=open(’test.txt’, encoding=”utf-8” )# открываем файл
TXT=F.read(21) # промотаем 21 символ
TXT=F.read(5)
print (TXT) # и печатаем остальные
на экране:z\

Питон
А вот метод . readline () (’’прочитать строку” в переводе) считывает
одну полную строку из указанного файла за раз, концом строки считается
символ переноса ’\п’, либо конец файла. Этот символ переноса строки тоже
будет присутствовать в строке, для считывания следующей строки метод
надо применить ещё раз.
Вот, допустим, я создал в Блокноте файл с небольшим стихотворением под
названием Ananas.txt. Считаем его построчно:

F=open (' Ananas. txt ’ , encoding="utf -8 " ) # открываем файл
TXT=F.readline() #считаем 1 строку
print (TXT) #печатаем
TXT=F.readline() #считаем 2 строку
print (TXT) #печатаем

TXT=F.readline() #считаем 3 строку
print (TXT) ((печатаем
TXT=F.readline() #считаем 4 строку
print (TXT) ^печатаем
F.close ()
На экране:

На медведя вы, сосна,

Шишку бросили со сна,
А на нас, а на нас

Уроните ананас!2
На экране строчки разделеныпустой строкой. Это из-за того, что один пе­
ренос идёт из прочитанной строки (Блокнот в конце каждой строки обяза­
тельно добавляет знак переноса '\п'), а второй добавляется самой функцией
print. Так что print удобнее записать так:

print (TXT,end="")

~~7
def readlyO :

TXT=F.readline()
print

(TXT,

#считаем 1 строку

end=’’)

return
F=open(’Ananas.txt’,

#печатаем

encodings"utf-8”

)# открываем файл

for i in range(4):

readly()
F.close()

Печать каждой строки осуществляется пользовательской функцией без ар­
гументов (так можно!), а на экране мы наконец-то видим то, что я записал в
файл Ananas.txt в нормальном виде:
2

Смешные, каламбурные стихи Я. Козловского (каламбур - игра слов с использованием
разных значений одного слова или разных слов или словосочетаний, сходных по звучанию)

На медведя вы, сосна,
Шишку бросили со сна,
А на нас, а на нас
Уроните ананас!

А если я хочу считать сразу весь файл построчно? Да нет проблем!
Метод . readlines () ("прочитать строки") к нашим услугам!
F=open('Ananas.txt', encoding="utf-8" )# открываем файл
TXT=F.readlines() #считаем файл построчно
print (TXT)
#печатаем
F.close() # закрываем

Но на экране какой-то бардак:
[*На медведя вы, сосна,\п', 'Шишку бросили со сна,\п', 'А на нас, а на нас\п‘,
'Уроните ананас!\п1

Объясняю в чём дело: метод . readline () считывает файл построчно в
строчную переменную, а .readlines () - в список!

Вспоминайте, чем эти типы данных отличаются, так что вот вам и упражне­
ние:^
IflllllllllllllllllllHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIILL

Упражнение 19.1
Переделайте последнее упражнение так, чтобы
замечательный стих Я. Козловского был выведен на экран
как положено - построчно. Обязательно используем метод
.readlines().
TIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIlIir

Файл мы открываем, конечно, не для того, чтобы его распечатать, нет! В
файл после его открытия, как правило, вносятся какие-то изменения,
после чего изменённый файл записывается под старым (или новым) именем

ф

и закрывается. К примеру, возьмём вот такое четверостишие (не всё же нам
одно- и двустишиями заниматься! Надо расти!):?

В наш век искусственного меха
и нефтью пахнущей икры
нет ничего дороже смеха,
любви, печали и игры/

И запишем его в файл garik.txt с помощью программы. Это очень просто:

text = ’’’В наш век искусственного меха
и нефтью пахнущей икры
нет ничего дороже смеха,
любви, печали и игры'''
garik = open(’garik.txt', 'w')# откроем файл для записи
garik.write(text) # запишем в файл
garik.close()# закроем файл
Сначала в строку text запишем текст (слишком длинный текст, в котором
есть переносы строки, записываем с помощью трёх апострофов в начале
текста и трёх в конце). Затем откроем файл, в который желаем записать ин­
формацию, причем, если такого файла нет, он будет создан.

По умолчанию файл открывается для чтения, а если мы собираемся
что-то в него записать, то надо указать режим чтения 'w' (write - писать);
если надо в него что-то добавить - режим ’a' (add- добавить); читать и
записывать - режим

Затем записываем то, что надо, в файловый объект (это ещё не в файл! Пока
в некий промежуточный объект), а файл будет создан окончательно только
после выполнения метода . close (). Находим в папке, где вы сохраняете
все наши программы, файл garik. txt, открываем - вот он наш гарик!
Ну а теперь поработаем с другим текстом, совершенно изумительным:

з

Автор - Игорь Губерман. Он известен своими ироничными и очень точными
четверостишиями, которые называют "гариками"

Чудная картина,
Как ты мне родна:
Белая равнина,
Полная лу2на,
Свет небес высоких,
И блестящий снег,
И саней далёких
Одинокий бег.4

Почему изумительным? Да потому, что в этом полном движения и жизни
стихотворении нет ни одного глагола\ Проверили? Убедились в волшебстве
А. Фета? Так вот в это волшебное стихотворение агенты иностранной раз­
ведки (ну а кто же ещё?) зачем-то запихнули цифру, как видите, и сохранили
в файле fet.txt (проделайте то же сами, уважаемые читатели).
Наша задача - прочитать файл, найти в нём цифру (причём мы не знаем, ни
какая это цифра, ни где она находится), удалить её и перезаписать исправ­
ленный файл, после чего показать язык иностранным разведкам.
F=qpen(’fet.txt’f ' r ’, encoding=”utf-8")# открываем файл для
чтения
TXT=F.read() #считаем файл построчно
F.close()# Закроем файл
for j in ’0123456789’: #ищем цифру в тексте
if j in TXT: #цифра найдена
break #прерываем цикл - мы нашли цифру!
txt=TXT.split(j) #разделяем строку на 2 по найденной цифре
F=open(’fet.txt’ , ’w’ ,encoding=”utf-8”)# открываем файл для
записи
T2=txt[0] + txt[l] #сливаем 2 строки в одну
F.write(T2) #записываем новую строку в файл
F.close() #закроем файл

Откройте файл fet.txt и убедитесь - мы сделали это!
"Ну и что же?" -скажет мне читатель
Удивлённый простотой задач.
"Я б руками всё быстрее сделал
Посложнее, автор, озадачь!"
Ну а здесь автор - Афанасий Фет
г-

•

Вот так! Я даже на стихи перешёл, вдохновившись Губерманом и Фетом!
Хорошо, вот вам задача, которую вручную решить невозможно:
^llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllillllllllllllllllllllllllllllllllllllllllllllllllllillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllillllllllllllllllb

Упражнение 19.2.1
Создайте строку длиной в 100 000 (Сто тысяч !) символов из
букв и ,н, п, о, т, идущих в случайном порядке, и сохраните
её в файл с каким хотите именем. Ага! Вручную как-то
тяжело... Создавайте с помощью цикла и модуля random,
предназначенного, если ещё не забыли, для генерации
случайных чисел.
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

illlllllllllllllllllilllilllllllllllllliilllllllllllllllllllllllllllllllllllililllllllilllllllilllillllllllllllllillilllilllllllllililllilllilllllllilllillllllllilllllliillllllllllllllllilllllilllllllllllilllllllllllllllilllilllllllilllllliib

Упражнение 19.2.2
Откройте файл с сохранённой строкой в 100 000 символов
и найдите, сколько раз в этом файле идущие подряд буквы
образовали случайно слово "питон".
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Ну а теперь допустим, что открываемого файла нет! Ну или совсем нет, или
он лежит в другом каталоге... Тогда вы увидите на экране:а

Traceback (most recent call last):
File "С:\Как бы диск 0\Питоновы программы\питон.ру", line 12, in
F=open(,pyton.txt,,encoding="utf-8" )# снова открываем файл
FileNotFoundError [Errno 2] No such file or directory: 'gaik.txt'
(нет такого файла или директории: 'gaik.txt).
А если вы допустили распространённую ошибку, записав:

A=open(garik .txt)

(Имя файла записывается в кавычках, или апострофах, или вообще в виде
строчной переменной - а здесь этого нет!).
В таком случае на экране:

Traceback (most recent call last):
File "С:/Как бы диск D/Питоновы программы/ореп.py", line 1, in
F=open(garik.txt)
NameErron name 'test' is not defined
(имя 'test'не определено)
И вот вам на основе этих проблем следующее упражнение: а
^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIU.

Упражнение 19.2.3
Пользуясь ранее изученным оператором try, и программой
поиска слова "питон" в 100 000 символов из предыдущего
упражнения, смоделируйте обе возможные проблемы с
открытием файла и сообщите пользователю о возникших
проблемах. Если проблем нет - пересчитаем слова "питон" в
файле.

Давайте, в конце концов, на основе имеющихся знаний создадим ещё одну
полезную программу. Как какая ещё была полезная программа?! Программа
для решения квадратных уравнений! Куда уж полезней!
Но это мы помогали математикам. Теперь - поможем самим себе!

Упражнение 19.3
Надо написать программу "Телефонный справочник". Пусть
в ней будет только фамилия, имя и телефон абонентов.
Программа должна ловко находить в списке нужного
абонента по его фамилии, или имени, или номеру. Не
нашёлся нужный человек - предлагаем его ввести, и затем,
естественно, сохраняем новый список на диске. Ещё пусть
программа умеет выводить список на экран, да не как
попало, а красиво - столбиками. Да, надо придумать "защиту
от дурака" - не хорошо это, когда при малейшей ошибке
клиента программа "вылетает"! Ну и вишенка на торте: в
нашем случае программа должна позволять клиенту вводить
№ абонента как попало: и так 8(888) 000.0007 и эдак +7-888000,0007 (хранить-то всё равно будем в виде 88880000007).
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Да, основная задача программирования, как правило утчг получить какие-то данные, обработать их и сохранить на своём
компьютере, передать по Интернету другому программисту, от­
править на хранение в облако (нужное подчеркнуть). Работа несложная
- открываем файл, обрабатываем, записываем и закрываем.

При создании программ нам частенько приходилось сталкиваться (и все
столкновения заканчивались нашей победой, заметьте!) с необходимостью
сделать какие-то однотипные преобразования во всех элементах последова­
тельности. Как вы заметили, у добрых Творцов Питона почти на все наши
выдумки есть готовые ответы, как правило, принимающие облик функций.

218

Глава 20.

НУ-КА ВСЕ ВМЕСТЕ

Допустим, надо возвести в квадрат все целые числа от 0 до 1 000 000, а ре­
зультаты записать в какой-нибудь список. Да, и надо провести хронометраж
этой работы. Да не "хренометраж", а узнать, сколько времени выполняется
эта работа. Ну, теперь-то нам, наученным сладким опытом программиро­
вания, как говорят программисты - " Это как два пальц... Нет-нет! Как два
байта переслать!":

from time import time
M1000000=range(l_000_000)
T=time()
A2=[]
for i in M1000000:
A2.append (i**2)
print ('надо', time()-T,'секунд')
Результат:

надо 0.08774685859680176 секунд
Что случилось? Чему вы так удивлены? Первому оператору? Согласен, чуд­
ны дела твои, господи...1

Дело в том, что range ()- это функция, и результатом её работы явля­
ется ... ну конечно же, объект (который, как вы знаете, есть вещь в себе
и обычными способами не разделывается)!
1

Библейский фразеологизм

Но мы имеем право назвать этот объект, например Ml000000 и разобрать его
на кусочки в цикле, что мы и сделали.
Итого хронометраж дал результат выполнения всей работы -0,087 секунд.

Так вот, для такого рода работ (проделать какие-то занудные преобразо­
вания со всеми членами последовательности) создатели Питона приду­
мали функцию map () :z-\

тар (, Chern= ’Хотели как лучше, а получилось как всегда'4
4

Наверное, многие позабыли автора этого бессмертного высказывания - В. Черномырдина,
известного советского и российского политика

Легким движением превратим его в список строк (я понятно выражаюсь?):

»>che=Chern. split ()
»>che
['Хотели', 'как', 'лучше,', 'а', 'получилось', 'как', 'всегда']
И применим к нему подходящий метод работы со строками (обращаю ваше
внимание, что не любой метод работает с функцией шар () - это довольно
капризная дама).

Начнём с чего-нибудь попроще, давайте сосчитаем длину каждого элемента
полученного списка:^

»>ChL=list (map (len, che))
>»ChL
[6, 3, 6,1,10, 3, 6]

Мы сосчитали последовательно длины всех слов в великом высказывании
знаменитого В. Черномырдина.
А теперь сделаем первые буквы заглавными:

»>list (map(str.capitalize,che))
['Хотели', 'Как', 'Лучше,', 'А', 'Получилось', 'Как', 'Всегда']
Все буквы заглавными:
»>list (map (str.upper,che))

['ХОТЕЛИ', 'КАК', 'ЛУЧШЕ,', 'А', 'ПОЛУЧИЛОСЬ', 'КАК', 'ВСЕГДА']

А ведь print () - это тоже функция! А ну-ка попробуем вот так:^.

»>list (map (print, che))
Ура - сработало:

Хотели
как
лучше,
а
получилось
как
всегда
[None, None, None, None, None, None, None]
Вот только что означает последняя строчка? Здесь получилось, не как всегда:
функция тар() аккуратно передаёт в print() по одной значения из Che, печа­
тает их и ... ничего не возвращает в объект тар(). А ’’ничего” по-английски
’’None”. 7 строчек - и 7 раз получили None - вот они и выскочили на экран.

Ну ладно. Так ведь и input() - функция! А ну-ка, попробуем:

»>Txt= [ ’ первое ’ , ' второе ’ , ’ третье
»>Menu=list (map (input,Txt))

' ]

На экране пойдёт бурная переписка:-^

первое борщ
второе котлета с рисом
третье компот

и результат-

>»Мепи
['борщ', 'котлета с рисом', 'компот']

Обращу ваше внимание ещё на одно преимущество использования функции
тар() - список Menu не надо объявлять заранее - он организуется сам (точ­
нее, его заводит и заполняет услужливая функция тар()).
А теперь давайте, для тренировки, вычислим синусы вот такой линейки
углов:

♦

1,2,5,10,15,30,60,75,90
Углы даны в градусах, конечно. Коль речь у нас пошла о синусах, то надо
вызвать модуль math. Всё-таки выражение ’’вызов модуля...”, да ещё из
каких-то таинственных глубин Питона, вызывает у меня сильные ассоциа­
ции с вызовом каких-то потусторонних сил из сказок. ”Да пребудет с нами
Сила5 и модуль math!”.

from math import *

Ну вот мы и вооружились и можем вступить в бой за святые синусы. Созда­
дим сначала список градусов q

grad=[1,2,5,10,15,30,60,75,90]
который надо превратить в список радианов (вы же помните, что синус рабо­
тает только с радианами?), для чего удобно, опять-таки, использовать функ­
цию map:z-\

Rad=map(radians,grad)
print (Rad)
Проверим, как это работает (нажимаем F5):



Я забыл, что результат работы функции - объект - зверь опасный и непред­
сказуемый, работать с ним умеют только опытные программисты; ну а мы
для укрощения используем проверенную функцию list (). Немного пере­
делаем предпоследнюю строчку программы и запустим полученный код:
from math import *
grad=[1,2,5,10,15,30,60,75,90]
Rad=list(map(radians,grad))
_______print (Rad)
5

Ну тут уж все знают: это цитата из "Звездных войн"!

На экране теперь получим:

[0.017453292519943295, 0.03490658503988659,
0.08726646259971647, 0.17453292519943295, 0.2617993877991494,
0.5235987755982988,1.0471975511965976,1.3089969389957472,
1.5707963267948966]
Чудесные цифры, не так ли? Это радианы, полученные из градусов.

Sin=list(map(sin,Rad))
print (Sin)

и на экране:
[0.01745240643728351, 0.03489949670250097, 0.08715574274765817,
0.17364817766693033, 0.25881904510252074, 0.49999999999999994,
0.8660254037844386, 0.9659258262890683,1.0]
но вот только разобраться, какой синус какому градусу соответствует, до­
вольно сложно. Давайте создадим словарь, в котором будут градусы, а через
двоеточие - соответствующие синусы.

Для этого используем промелькнувшую, как метеор в главе 17, функцию
zip (). Это тоже гордая, объектообразующая функция, укрощаемая по­
средством функции list () :^э

ZIPPO=dict(list(zip(grad,Sin)))
print(ZIPPO)

Результат:
{1:0.01745240643728351,2:0.03489949670250097, 5:0.08715574274765817,
10:0.17364817766693033,15:0.25881904510252074,30:0.49999999999999994,60:
0.8660254037844386,75:0.9659258262890683,90:1.0}

Теперь намного понятней! Вот только углу в 30°соответствует значение сину­
са 0,49999... Зачем нам такая точность?

Попробуем округлить синусы посредством функции тар (), причём в
интерактивном режиме - для проверки:-)

»>RndSin=list (map (round, Sin))
»>RndSin
[0, 0, 0, 0, 0, 0,1,1,1]

Ну конечно, ведь round () без параметров в скобках округляет до
ближайшего целого числа!

А нам-то надо 2-3 цифры после запятой? Что же делать?

Давайте применим нашу краткую, как выстрел, лямбда-функцию:

from math import *
grad=[1,2,5,10,15,30,60,75,90]
Radslist(map(radians,grad)) #градусы -> радианы
Sin=list(map(sin,Rad)) #радианы -> синусы
(21.1)
RndSin=list(map(lambda Rnd3: round(Rnd3, 3), Sin))
ZIPPOdict(list(zip(grad,RndSin))) #сцепим градусы с синусами
print ('Градусы: значения синусов\п',ZIPPO)

И на экране всё стало красиво и понятно:

Градусы: значения синусов
{1:0.017,2:0.035, 5:0.087,10:0.174,15:0.259,30: 0.5,60:0.866,75:0.966,90:1.0}
Спешу сообщить вам о довольно неожиданном открытии:

В начале главы я писал, что с тар () можно использовать любую функ­
цию при условии, что эта функция принимает 1 аргумент.

230

Так вот это не совсем верно...

Что вы говорите? "Аффтар, выпей йаду?". Ну что же, где-то вы правы...

В программу вместо строчки

RndSin=list(map(lambda Rnd3: round(Rnd3, 3), Sin))

вставим вот такие 2 строки:'Л

precision^(0,1,2,3,4,5,6,7,8)
RndSin=list(map(round, Sin, precision))

И в результате увидим на экране изумительный вывод:
Градусы: значения синусов
{1:0.0,2:0.0,5:0.09,10:0.174,15:0.2588,30:0.5,60:0.866025,75:0.9659258,90:1.0}
То есть в кортеже precision мы задаём значения точности, и Питон
послушно выдал значения синусов с нарастающим числом знаков после за­
пятой!

Ну а теперь расскажу вам, за что ещё программисты любят функцию тар ().

Во-первых, писать программу через шар () удобнее, в чём вы сами уже
убедились. И, во-вторых, если результаты работы тар() не надо выво­
дить на экран, то её частенько можно использовать и дальше прямо как
объект в других функциях, так что нашу программу можно перезаписать
в виде:

from math import *
grad=[1,2,5,10,15,30,60,75,90]
Rad=map(radians,grad)
(21.2)
Sin=map(sin,Rad)
RndSin=list(map(lambda Rrr: round(Rrr, 3), Sin))
ZIPPO-list(zip(grad,Sin))
print(ZIPPO)

И вот теперь-то она заработает раз в 100 быстрее!

^1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111И11£

Упражнение 20.3
Сравните скорость исполнения программы (21.1) с её же
вариантом (21.2), а то мало ли что я тут понапридумывал.
Ч||111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111П11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111Н111ГГ

Как нам уже известно, Питон умеет работать только с текстовыми файлами
(ну, это не совсем верно, но пока будем считать так). Так вот, обогащённые
знаниями о функции тар (), давайте сделаем:^

^iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiini-

Упражнение 20.4.1
Следует создать текстовый файл из 10 000, естественно,
случайных чисел, не превышающих 100 000, с двумя знаками
после запятой. При создании следует применить функцию
тар(). Для чего это надо? Исключительно для того, чтобы
сделать упражнение 20.4.2!
-tllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

illlllllllllllllllllllllllllllllllllllllllllllllllillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllillllilllllllllllllllllillllllllllllllllllllllllllllllllllllilllillllllllllllllllllllllllllllllllib

Упражнение 20.4.2
Следует открыть файл, созданный в предыдущем
упражнении и найти в нём все пары чисел, сумма которых
делится на число 131 313!
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Что-то мы всё о серьёзном. Давайте немного подурачимся с пользой для
окружающих!

Г-----[ 233__ j

Глава 21.

ВРЕМЯ ПОИГРАТЬ

Мы уже несколько раз использовали модуль time, который занимается
измерением времени.

А давайте на его основе сделаем простенькие игры? Игры? С временем? Ну,
не совсем игры! Скорее тесты. Прямо сразу и начнём!
import time
print("+++ сейчас мы измерим вашу реакцию +++")

Естественно, для начала импортируем модуль time и начнем готовиться
к измерению скорости реакции пользователя. Для начала надо расслабить
пользователя, то есть сделать задержку программы на какое-то время.

Модуль time любезно предоставляет нам метод, который так и называ
ется . sleep (t) - и задерживает выполнение программы на t секунд
(sleep по-английски "спать").

time.sleep(3)
st=time.time()

Засекаем время и ждём нажатия клавиши:

Txt = input ("Нажмите клавишу Enter!")
fin=time. time ()
Г 236 1

Далее вычисляем время реакции:

reac=fin-st
print("Время реакции:

",

reac ," секунд" )

Запустите программу... Как там ваша реакция?
Ну в одну и ту же клавишу попадать достаточно просто.
Усложним задачу:^
^iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiilililililiiiilllilliilillliliiiiiiiiiiiiiiiiiiiiilililliliiiliiilliiiliiiiiiiiiiiiilliillliiiliililililililliilliiiiililiiililllilllilllllllllllllliliilllliilllilllilllllilllilliilllllllllb

Упражнение 21.1
Пусть теперь пользователь нажимает на определённую
числовую или буквенную клавишу, которая определяется
случайным способом, а мы рассчитаем время реакции.
-П111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111НГ

^llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll.

Упражнение 21.2
Напишите программу, которая проверяет ваше умение
определять интервалы времени. Программа задаёт время,
через которое надо нажать клавишу Enter, и выдаёт величину
допущенной ошибки.
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Это всё хорошо, вот только мерять время в секундах от начала каких-то не­
запамятных времён как-то не очень удобно, это почти как у поэта: ’’Какое,
милые, у нас / Тысячелетье на дворе?”1

Нам бы поточнее желательно

в годах, днях и минутах... Пожалуйста!

Есть такой милый метод .ctime(). Если ему скормить количество секунд,
прошедших с начала эпохи, то в ответ мы получим строку, содержащую
местное время:-;

»>sec = time. time ()

4

Это, разумеется, цитата из стихотворенья Б. Пастернака

»>Ltime = time. ctime (sec)
»>print (Ltime)

Вот она, строка:/^
Thu Jan 19 12:46:34 2023

Вот только строка на английском, увы...
А глава СЛОВАРИ зачем в этой книге? Вот давайте, воспользовавшись сло­
варём, переделаем время и дату с английского на русский.
import time
sec = time.time() #получим число секунд
Ltime = time.сtime(sec) # Строка с местным временем
WEEK=Ltime[0:3] #день недели
MON=Ltime[4:7] #Месяц
DAY=Ltime[8:10] #Дата
TIME=Ltime[11:19] #Время
YEAR=Ltime[20:25] #Год
# Словарь переводит дни недели с английского на русский
WeRu={ ’ Thu ’ : ’’Четверг" , ’ Fri ' : "Пятница" , ’ Sat ’ :
"Суббота",’Sun’:"Воскресенье","Мои":"Понедельник",
’Тие’:"Вторник",’Wed':"Среда"}
WRu=WeRu[WEEK] # заменяем англ, день недели на русский
# Словарь переводит названия месяцев на русский
MonRu={ ’Jan’:"января",’Feb':"февраля", ’Маг':"марта",
'Apr':"апреля",'Мау':"мая",'Jun':"июня",'Jul':"июля", 'Aug'
:"августа",'Sep':"сентября",'Oct':"октября",'Nov':"ноября",
'Dec':"декабря"}
MRu=MonRu[MON] #заменяем англ, месяц на русский
print ('
В вашей местности сейчас')
print (DAY,MRu,YEAR, ' года, ',WRu)
print ('
Время', TIME)

На экране всё красиво

В вашей местности сейчас
19 января 2023 года, Четверг
Время 17:29:12

*

Ну а теперь, зная, как получить время и дату на данный момент и используя
СЛОВАРЬ для перевода, сделаем:
^illlilllllllllllllIllIllllllIlllllllllllllllllllllIIllllIllllllllllllllllllllllllllllllllllllllllllllllllIllllIlllllllllllllllllllllllllilllllllllllllllllllllllllllllllillllllllllllllllllillllllllllllllllllllllilllllllllllllilllillilllllllE

Упражнение 21.3
Вы заметили, что в последнее время стало модно указывать,
например, в каком возрасте Пеле2 забил свой первый гол
на чемпионате мира, причём возраст указывается в днях,
месяцах и годах? Почему? Появились соответствующие
программы.
Ну а мы чем хуже? Давайте напишем программу, которая,
получив ваше время и место рождения - нет, место рождения,
по-моему, не надо! - сообщит возраст вас, любимого, в
днях, месяцах и годах. При этом я хочу, чтобы при выводе
числительное было согласовано с существительным, то есть
чтобы вывод был в виде:
Ваш возраст 1 год 4 месяца 29 дней

Или

Сегодня вам 11 лет 6 месяцев 22 дня
А не:
Ваш возраст 1 лет 4 месяцев 21 дней

Для согласования числительного с существительным можно
использовать программу из упражнения 5.5!
lllllllllllllHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHIIIIIIIIIIIIIIIIIIinilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllfT

Цу что Ж, книга прочитана, упражнения, надеюсь, сделаны.
Я ЬынуЖден попрощаться со обоими умными и, главное, тер­
пеливыми и любознательными читателями. Надеюсь, Вам было
интересно. А ещё больше надеюсь, что моя книга помог­
ла Вам распахнуть дВерь В интереснейший, занимательный,
чрезвычайно обширный и богатый (Во Всех смыслах этого
слоВа) мир программирования на Python!

DIXI3
2
ф

Пеле - великий бразильский футболист, единственный на планете трёхкратный чемпион мира по
футболу. Свой первый гол на чемпионатах мира он забил в возрасте 17 лет, 7 месяцев и 27 дней]_____

3............... Я-В££-Сказал_(латынь)........................................................................................................... Г 239 1

ОТВЕТЫ НА
УПРАЖНЕНИЯ

Упражнение 0.1
Если считать по 1 числу в секунду по 8 часов в день, причём
без выходных, то это займёт почти 35 дней!
-riiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiirr

Cat2y, Almaz1996, R___ T, 0600, - правильные имена
переменных.

Неправильные имена:

Out!, TU-154 - содержат символы ! и

3R, 3_т - начинаются с цифры;
_3т - начинается с символа подчёркивания;

ОооШ - содержит букву Ш. Использовать можно, но не
рекомендуется;
import - совпадает с ключевым именем.

»>х=2.5

»>у=4
»>х=х*у
10.0

»>у=х-у
-nillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

Г 242

6.0

I

»>y=x//2
5.0

I
I

»>y=y%3
2.0

|
|

»>x=x/3

|

3.3333333333333335

I

»>x=x//l

j

3.0

I

Сразу, конечно, не получилось? Ну что поделаешь - "тяжело в |
учении - легко в бою"...1 А, кстати, что за странная последняя I
операция х=х//1? Так как здесь целочисленное деление, то
таким образом отброшена дробная часть. Вскоре вы узнаете,
как это сделать красиво, а не столь корявым способом.
TiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiF

Упражнение 2.2.
Должно получиться вот так:

|
|
|
|
|
|

»>а=4
»>Ь=3
>»а=(а+Ь)/2
3.5
>»а=а**2-2*Ь
6.25

| >»Ь=Ь-а//(а-Ь)
I 2.0
I »>а=а**0.5
j 2.5
| Да, последний оператор извлекает квадратный корень из 6,25
| и получает 2,5.
TIIIIIIIIIIIIIIIIIIIIIIHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIlIir

1

Слегка переделанное высказывание великого полководца А. В. Суворова. На самом деле он
сказал так: 'Тяжело в учении — легко в походе! Легко в учении — тяжело в походе!1

Г 243 1

!
|
|
|
|
|
|

Легко сказать - оцените! А как? Очень просто: надо заданную
площадь разделить на 1 000 000 квадратиков. В центре
каждого квадратика поместим горошину. Расстояние между
горошинами - длина стороны полученного квадратика. Ну а
по площади квадрата мы легко вычислим его сторону, для
этого надо извлечь квадратный корень. Как извлекать корни
(квадратные, конечно) - я рассказал в упражнении 2.2.

I Вот вам и программа:

|
|
|
I
|
|

Sq=125
Sq=Sq*10000
q=Sq/1000000
L=sq**0.5
print ('Расстояние между центрами горошин было менее',
L, "см")

| На экране:
| Расстояние между центрами горошин было менее 1.118033988749895 см

| То есть сами горошины должны быть меньше 1 см! А ведь
| комната в 125 квадратных метров побольше хорошей
| квартиры! Да, миллион - это очень большое число...
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Нет, ребята, так:
х=3
у=2

дело не пойдёт! Представьте, что вам надо поменять
значения х и у где-то в середине программы, а реальные
значения х и у вы не знаете.
Ну и что тут сложного? Тогда вот так:
х=2
HIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

dlilillllillllllllllllilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllb

I
1
|
|

y=3
X=y
У=х
print ('x=',x,' y=',y)

| Набираем - запускаем - с изумлением читаем:
| х= 3 у= 3
|
|
|
|

После выполнения оператора х=у прежнее значение 2
из х исчезло, х стал равен 3 и у благополучно получил
назад своё же значение 3... Что же делать? Вводить
вспомогательную переменную:

I х=2
I
|
|
|
|

У=3
w=x
Х=у
У=*
print ('х=',х,'у=',у)

| Вот теперь правильно, на экране читаем:

| х= 3 у= 2
| Небольшой фокус! В этом изумительном Питоне есть понятие
1 группового присваивания, то есть без вспомогательной
| переменной:

I х=2
| у=з

I х,у=у,х
| print ('х=',х,’у=’,у)

| На экране:
| х=3 у=2
| Пока не рекомендую пользоваться этим фокусом: во-первых,
I это ухудшает чтение программы, а во-вторых, там есть
Г---------

[L 245
_ j

подводные камни при работе со списками. Что такое списки?
"Всякому овощу своё время" - узнаете в соответствующей
главе.
'nilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllltllllfT

1жпнт»нпмипжпнпт»тнптппнп>нпш«типнтнтжпжтнтжпнтнипнптжттжпъипнтитштнтжпънпятн«пнтжтнпннпжт«

Возьмём т сразу побольше:
Т=10000

Количество минут определяется запросто, как остаток от
деления Т на 60:
Min=T%60

А теперь разделим Т на 60 нацело, чтобы получить количество
часов:

Т1=Т//б0
print (Т1)
Запустим полученную программу, чтобы посмотреть, что у
нас получилось (кстати, так и следует отлаживать программы
- написали небольшой, но совершенно понятный кусочек
большой программы - запустили, посмотрели на результат):

166

М-да, что-то многовато получилось - в сутках же всего 24
часа... О! 24 часа! Да надо же просто Т1 разделить нацело
на 24 и полученный результат вычесть из Т1! Ой... Да это же
остаток от деления:

Ноиг=Т1%24
print (Hour)
На экране:

166
22
Tllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllilllllllllllllllllllllllllllllll

111111111 IIIIII III III III II IIIlllllIIIIIII III Illi II III IIII Illi IIIIIIII Illi I III I III I Illi III I III 11IIIIIIIIIIIIIIIIII Illi III Illi Illi III I III I III IIIIIIIIII111IIIIII Illi III I III 111111II Illi III I III I III IIIIIIIIIIIIIIII III 11II11II Illi Illi II11 Illi llll^

Вполне разумный результат. Вот теперь убираем из
программы лишнее, задаём для проверки т... А к чему бы нам
приравнять т, чтобы можно было легко проверить результат?
Пусть для начала т=300 минут, то есть 5 часов.
Набиваем программу, убирая из неё лишние операторы
print (), которые мы вводили для отладки:

Т=300
Min=T%60
Т1=Т//60
Ноиг=Т1%24
print (Hour,*:',Min)

Оператором print () можно печатать несколько переменных,
отделяя их друг от друга запятой.
На экране - показания электронных часов:
5:0

Согласен, часики у нас довольно неказистые... А вот как
сделать их вполне "казистыми" мы узнаем немного позже, в
главе "ЕЩЁ АРИФМЕТИЧЕСКИЕ ОПЕРАТОРЫ".
А теперь поставьте т=10000 и не забудьте полюбоваться на
результат:
22:40
-nilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Ну конечно же, вы уже написали что-то подобное:

R=7
А=60
Omega=(A/R)**0.5
print ('Скорость вращения:',Omega)
~П111111111111111111|||1111|11||1|11111111111111111|111|111|11111111111111111111111|1||11||111111111111111111111|||1|11111|1111111111111111111||||1|1|11|11111111111111111111|1|||1|11|1111111111111111111111|11|11||11111111111111111111111111НГ

♦

Г 247 1

^Illllllillllllllllllllllllllllllllllllllllllllllllllilllllllillllllllllllllllllllllllllllllllllilliillllilllilllillllllllllllllllllllillilililllilllilllilllllillllllllllllllllllillllilllllllllllllllllllllllilllllllllllllllllilllilliilllllib

Переменная А равна 60 м/сек2 - это перегрузка 6д - ускорение
свободного падения составляет почти 10 м/сек2. Запускаем,
мгновенно получаем ответ:

Скорость вращения: 2.9277002188455996
И только теперь задумываемся о единицах измерения.
Скорость вращения ы в чём измеряется? Отвечаю - в
радианах в секунду, как и положено в математике... Придётся
радианы в секунду пересчитать в обороты в минуту!
2тт радианов в секунду - это 1 оборот в секунду, или 60
оборотов в минуту. Следовательно, для пересчёта надо
применить формулу:

N=—■60
И немного переписать программу:
R=7
А=60
Pi=3.14
Omega=(A/R)**0.5
N=Omega*30/Pi
print ('Скорость вращения:',N,

'оборотов в минуту1)

На экране:

Скорость вращения: 27.971658141836937 оборотов в минуту
Ну вот, совсем другое дело! Если посмотреть фильм
о подготовке Гагарина к полёту, то можно увидеть, что
центрифуга где-то так и вращается - со скоростью пол­
оборота в секунду.
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Примерно так:

L=42195
T1IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111II111111111111111111111111111111111111111111111111111111111

| H=2
j M=10

|
I

j В переменную L запишем длину дистанции в метрах, Н и М | это время в часах и минутах:

|

| sec=H*3600+M*60

I

| Пересчитали время на секунды:

|

I V=L/sec

|

| Рассчитаем скорость марафонца в метрах в секунду:
I

I

t=1000/V

| За время t (в секундах) бегун пробежит 1000 метров:

I
|

|
I

tS=t%60
tM=t//60

| Время в секундах получим как остаток от деления t на 60, а
| время в минутах - результат деления нацело.
| print ('марафонец пробегает 1 км за:',tM,'минуты и',
j tS,'секунд')

|
|

| Остаётся только вывести результат на экран в понятной
| форме и ... застыть в страшном изумлении:
| марафонец пробегает 1 км за: 3.0 минуты и 4.856025595449694
I секунд

|
|

| оказывается, марафонец-чемпион проносится КАЖДЫЙ

| километр своей дистанции быстрее норматива III взрослого
| разряда по бегу на 1 км!

|

Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

t...................................................................................................................

Г14Я

Упражнение 4.1
1жиншжшжшы

Сразу не получилось? "Ну что ж! — сказал Пудик. — Всему
сразу не научишься!”25
А скрипт примерно такой:
print(str(int(input ("Введите целое число:"))**2)[-1])

Ну это просто шедевр лаконичности Питона!
Сначала через функцию input вводим число в виде
строки, функция int превращает полученную строку в
число, которое тут же возводим в квадрат. Как отрезать
от результата последнюю цифру? Можно, конечно,
классическим способом: print ((int (input ("Введите целое
число: ")) **2) %10); но нам надо обязательно применить
функцию str () ,так что преобразуем полученный результат
назад в строку и печатаем последний знак.
tiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiF

А вот теперь это элементарно:
print(str(int(input("Введите целое число:"))**2)[0])

Это не более чем пример изумительных возможностей
Питона, на самом деле ТАК писать программы не
рекомендуется. Лучше (и понятней для самого себя)
проделать всё это по частям:

Int=input("Введите целое число:") # Вводим целое
Int=int(Int) #Делаем из строки число
Out=Int**2 # Возвели в квадрат
Out=str(Out) # Превратили в строку
print(Out[0]) # Вывод ПЕРВОЙ цифры
Rllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

4s

М. Горький "Воробьишко"

к_

Примерно так:
Chehov='''Подумав немного, он положил на блины самый жирный кусок
сёмги, кильку и сардинку,

потом уж, млея и задыхаясь, свернул оба блина в трубку, с чувством
выпил рюмку водки,

крякнул, раскрыл рот...
Но тут его хватил апоплексический удар.'''

CHEH=Chehov.lower()

#в нижний регистр

while True: # вечный цикл

fraza=input("жду фразу ")

# Ждун

if fraza.isdigit(): #фраза= цифре?
# да=выход из цикла

break

С=СНЕН.count(fraza) #метод count считает число вхождений
print(fraza,

’:', С)

#выводим результат

print ("работа закончена")

Ну и как? Как быстро вы сосчитали, сколько раз в этом отрывке
встречается фраза 'ил* ? 4 раза? Правильно!

Между прочим, мы левой ногой решили вполне серьёзную
лингвистическую задачу! Например, лингвисты сосчитали
без всяких компьютеров в середине (!) XX века, что в поэме
Пушкина "Полтава" всего примерно 13 000 букв, но "Ф"
встречается только 3 раза. Представляете, какой адский труд?
Да ещё и чреватый ошибками: с помощью небольшой добавки
к приведённой выше программе я уточнил, что в "Полтаве"
39796 букв (а вот "Ф" действительно встречается только 3
раза). Мы можем переменной Chehov присвоить любой текст
и в доли секунды произвести над ним вполне серьёзный
лингвистический анализ по наличию любых фраз.
-rilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

Stroka="H Вере наша Саша не реви!...
'nilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Г 292 1

^Illlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

Сделаем все буквы прописными,

| Str=Stroka.lower()

т.к.

начало |

| фразы идёт с прописной

|

# Удаляем все пробелы

',' ')

Str=Str.replace('

Str=Str.replace('.',’ ')
Str=Str.replace(',',' ')
Str=Str.replace('!',' ')
Str=Str.replace

')

Str=Str.replace

'')

1 rtS=Str[::-1]
| if Str==rtS:

|

# Удаляем знаки препинания

.,!?

# переворачиваем строку

|

# перевёрнутая строка совпадает с исходной?

- Палиндром!!!")

print(Stroka, "

# Если да - палиндром

| else:
|

I

print(’Увы...

-

,

не палиндром')

Stroka,

# если

|

1

| нет - не палиндром

|
|
|
|

|
|

Я специально назвал переменную Str, так как знаю, что str название функции, превращающей в строку всё подряд (то есть
встроенный идентификатор), а в таких случаях ещё в начале
книги я рекомендовал использовать заглавные буквы.

Tllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllff

Программа получилась довольно простой:
Jerom='Hac
Гаррис,
я и
Jerom2=''

было четверо —
Монморенси'

Джордж,

Уильям Сэмюэль |
|

#сюда загрузим обновлённый текст

|

sch=0

|

for i in range(len(Jerom)-1):
if Jerom[i]!='
подряд -

'

#идём по тексту

or Jerom[i+1]?='

Jerom2=Jerom2+Jerom[i]

':

|

# нет 2-х пробелов

# добавим букву

|
|

|

else:

|

sch+=l Цсчётчик пробелов +1

Jerom2=Jerom2+Jerom[i+1]

|

#добавим последний знак

print

(Jerom2)

print

('Удалено',sch,'пробелов')

|

#выводим исправленный текст

|
|

tiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiit

Г

^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIILt

| В результате имеем на экране:
| Нас было четверо — Джордж, Уильям Сэмюэль Гаррис, я и Монморенси |
| Удалено 15 пробелов
|
liiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiir

Упражнение 14.2
м1иншншншниишмнижшжижш*шиншнижшнииншнижшншжижшжшниж

Здесь тоже всё просто:
Oi=[2,12,-5,-3.9,10,6,-3,5,22,-2.5,10]
Ai=[]

# исходный список

# новый список

for i in range(1,len(Oi)-1):

# цикл no списку

ai=(Oi[i-1]+Oi[i]+Oi[i+1])/3 #среднее арифметическое

Ai.append(round(ai,2))
print

# добавим в новый список

(Ai)

На экране:

| [3.0, 1.03, 0.37, 4.03, 4.33, 2.67, 8.0, 8.17, 9.83]

|

Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllinillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Упражнение 14.3
| Читать с закрытыми глазами - программа секретная!

31

^Illlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirf
_________ ,

f

|

# программа "РАЗВЕДЧИКИ”

|

I

# формируем последовательность букв

|

|

# № позиции,

|

import random

|

|

f=’qwertyuioplkjhgfdsazxcvbnm ' #список латинских букв

1

|

Q=[]

|

|

L=1000 #кол-во ящиков

где стоит "аи”,

даёт № ящика со спецгрузом

#здесь будет список букв

| for i in range

|

|

1

(L):

|

x=random.choice(f)

|

|

Q-append(x)#формируем случайныйсписок букв

|

|

Z=’’.join(Q)

|

AU=('au'

|

if AU:

|
|
|

#преобразуем в строку

in Z)

|

#есть ли ”au” всписке

|

#если есть - печатаем № ящика

|

print(’ящик №’,Z.index(’аи’))

|

1

else:

print('сегодня отгрузки не будет...’)

|

Hllillillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllilllllllllililiilllllliillllirr

Примерно так:
I Lst=list(’Значит,

так:,

автобусом,

к,

Тамбову,

|

| подъезжаем,')#текст

|

| Symb=',’#Символ к удалению

|

| L=Lst.count(Symb) # Количество символов к удалению

1

| for i in range(L-l):

|

|

J=Lst.index(Symb)# находим,

|

Lst.pop(J)# удаляем символ

где стоит символ

|
|

| Q="".join(Lst)# создаём исправленную строку

|

| print(Q)# печатаем её

|

|
|
|
|
|

Как я уже неоднократно писал, программа должна быть легко
перенастраиваемая. Например, если завтра надо будет убрать I
из другого текста букву а, то мне потребуется изменить в
программе 2 первые строки: ввести другой текст и задать
другое присвоение Symb= ’ а'.

^nilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

Упражнение 14.5
Программа выглядит примерно так:
import random # Импорт датчика случ.
А=[]

чисел

#создаём пустой список А длиной О

М=4 # на сколько символов сдвиг
Q=10 # длина списка

for i in range

(Q):

A.append(random.randint(1,100))# заполняем А случ.

print(A)

числами

# печатаем список A
# создаём список В

B=A

for k in range(M):

# M раз повторяем сдвиг списка вправо на 1

символ

x=B[Q-l]

# запомним в х последний элемент

for i in range

(Q-1,-1,-1):

B[i]=B[i-l]

#цикл справа налево

# копируем элементы вправо

В[0]=х #по окончании цикла последний элемент делаем первым

print(В)

На экране мы увидим, например:
[49, 74, 29, 61, 6, 66,19, 86, 39, 50]
[19, 86, 39, 50, 49, 74, 29, 61, 6, 66]

При каждом новом запуске первая строчка будет другой, ведь она
создаётся случайным образом!

Упражнение 14.6
Программа, конечно, не сильно сложная:
from random import randint
YesOrNo=0 #есть совпадение или нет
povtor=1000 #количество повторов
Grup=25 #сколько народу в группе

Импортируем нужный датчик случайных чисел и выставляем
296

константы:
for N in range(povtor): #болыиой цикл

Чтобы получить результат поточнее, надо провести расчёты в
разных группах:
DR=[] #здесь лежат дни рождения

Чтобы не заморачиваться с месяцами и днями рождения,
будем использовать просто номер дня с начала года, а всего
в году, будем считать, 365 дней - для простоты.
for i inrange(Grup):

x=randint(1,365)

DR.append(x)

#случайным способом формируем список ДР

Итак, получили список DR с номерами дней рождения

cnt=0

Обнуляем малый счётчик - в нём храним количество
совпадений дней рождения для данного повтора
for i in range(Grup):
for j in range(i+1,Grup):
if DR[i]==DR[j]: #Совпали ДР?
Сосчитаем количество совпадающих чисел в списке DR
cnt+=l #ДА
if cnt!=0:
YesOrNo+=l #есть совпадение

А вот в YesOrNo храним количество групп, в которых есть
совпадающие дни рождения:
print('Вероятность совпадения дней рождения в группе
из',Grup,'человек -',round(YesOrNo/povtor,3))
IllIllllIlliillIlillIllIilllIllIliliilliiiiililillllillIllIlllllllllllliillillliiiiiiiliiillilliillIllIlillllllllilliilIlIliilliiiiillIllllIllIIllIllllllilillIllilllIlilllilIllIllllllllllIlllIllilililllillllllllllllllllllllllllllllllllIlF

Г 297 1

^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIU.

После запуска мы получим совершенно неожиданный результат:

Вероятность совпадения дней рождения в группе из 25 человек - 0.566

То есть в каждой второй группе из 25 человек есть люди,
родившиеся в один день! По-научному это называется
"Парадокс дней рождения" - мы никак не ожидаем, что в
столь небольшой группе вероятность совпадения дней
рождения (число и месяц) хотя бы у двух людей
превышает 50 %. Для 57 и более человек вероятность такого
совпадения превышает 99 % . Запустите программу при Grup=57
и компьютер вам выдаст:
Вероятность совпадения дней рождения в группе из 57 человек - 0.992
Ну а 100 % она достигает, согласно здравому смыслу,
только тогда, когда в группе не менее 367 человек (тут
уж по любому у 2-х человек день рождения совпадёт - с
учётом високосных лет). Программа, кстати, считает довольно
точно - математически рассчитанная вероятность совпадения
дней рождения в группе из 25 человек составляет 0,5692*.

Обдумаем алгоритм решения задачи. Сначала надо
импортировать из модуля random метод .shuffle(), который умеет
случайным образом перемешивать (то есть тасовать!) элементы
списка. Определимся с обозначением масти карт: обозначим
"черви" буквой "ч", "бубны" - буквой "б", "крести" - "к", "пики"
- "п". Достоинства карт обозначим большими буквами: "туз"
буквой "Т", "король" - "К", "дама" - "Д", "валет" - "В". Десятки,
разумеется, обозначим "10", девятки - "9" и так далее. Так что
"9к" это 9 крести, а "Дп" - пиковая дама.
'nillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

26
Это при условии, что дни рождения в году распределены равномерно, а это не совсем верно.
Например, в США самый распространённый день рождения - 9 сентября, а наименее распространённый 25 декабря. Первое встречается примерно в два раза чаще, чем второе(!)

ф

IflllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllLL

Полную колоду разобьём на 4 подколоды - исключительно для
удобства. Из перетасованной методом .shuffle() колоды карты
игрокам будем выдавать с помощью метода .рор() - он удаляет
и выдаёт последний элемент списка - если не указать индекс. Из
оставшейся колоды показываем нижнюю карту - с номером 0 она и определяет козыри. Далее из комментариев, надеюсь, всё
более-менее понятно:
from random import shuffle
K_cherv=['Тч',•Кч','Дч','Вч','10ч','9ч','8ч','7ч','6ч']
K_bub=['Тб','Кб','Дб','Вб','106','96','86','76','66•]
K_krest= [' Тк' , ' Кк' , ' Дк' , ' Вк' , ' Юк' , ' 9к' , ’ 8к ’ , ’ 7к' , ' бк' ]
K_pik=['Тп','Кп','Дп','Вп','10п','9п','8п','7п','бп']
KOLODA=K_cherv+K_bub+K_krest+K_pik #собираем полную колоду
Igrl=[];Igr2=[]; 1дгЗ=[]
shuffle(КОLODA) # перетасуем колоду
for i in range(б):
x=KOLODA. pop () # выдаём карту и сразу её убираем из колоды
Igrl.append(х) # добавляем эту карту игроку 1
x=KOLODA. pop () # выдаём карту и сразу её убираем из колоды
Igr2.append(х) # добавляем эту карту игроку 2
x=KOLODА. pop () # выдаём карту и сразу её убираем из колоды
Igr3.append(х) # добавляем эту карту игроку 3
print('карты игрока l',Igrl)
print('карты игрока 2
',Igr2)
# печатаем карты игроков
print('карты игрока 3
*,1дгЗ)
karta=KOLODA[0] # вынимаем нижнюю карту из колоды
print ('
карта устанавливает козыри: ' , karta) # и печатаем её
#
определяем козырь
if karta[1]=='п':
ког=’ПИКИ '
elif karta[1]=='к':
koz=’КРЕСТИ '
elif karta[1]=='б’:
ког='БУБИ '
else:
koz='ЧЕРВИ '
print (koz,'козыри у нас') # печатаем козырь
print("в колоде остались картыKOLODA) # и остатки колоды
□^llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllfT

i 299 1

iJIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHIIIIIIIIIIIIIIIU.

Результат работы программы каждый раз новый, но примерно
такой:
карты игрока 1 ['Тб1, 'Тч', ,Тк\ ’Юк1, '76', ’9ч’]

I

карты игрока 2
['Дб', ’Вб', '7k', ‘Кп', 'Кк', 'Кб']
карты игрока 3
['Tn', ’961, ,8п,г 'бб', '86', '9п']
карта устанавливает козыри: 6п
ПИКИ козыри у нас
в колоде остались карты: [‘бп', '9к', '7п', ’Вп', 'ТОч', '8k', '106', Дп', Дк', 'Вч1, '7ч', 'вч',
Дч', 'Кч', 'Юп', 'Вк', '6ч', 'бк']

I
I
|
|
!
|

TiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiiiiiiiiiiiiiiiiF

Упражнение 14.8
Просим у пользователя день, месяц и год рождения, а также
какой день со дня рождения желаете отметить:
| DayOfBorn=int(input('день вашего рождения
| MonthOfBorn=int(input('месяц,

'))

когда вы родились

| YearOfBorn=int(input('год рождения полностью

(номер)

'))

'))

| Days=int(input('Какой ДЕНЬ рождения желаете отметить:

'))

|
|
|
|
|

Конечно, можно попросить пользователя вводить свой
месяц рождения в привычной форме, но здесь я применил
своеобразную "защиту от дурака": при вводе месяца в
текстовой форме можно запросто ошибиться: "сегтябрь",
"сетябрь"... При вводе числом вероятность ошибки меньше.

|
|
|
|
|

А теперь давайте придумаем алгоритм расчёта требуемой даты.
Сначала рассчитаем целое число лет, прошедших за введённое
пользователем число дней. Для этого поделим количество дней
Days на 365.25 (это усреднённое количество дней в году) и
добавим год рождения.

| days-Days
| God=int(days/365.25)+ YearOfBorn

| Найдём теперь остаток от деления на 365,25:
TIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

I 300

days=days%365.25
Деление этого остатка на 30,5 (среднее количество дней в
месяце) даст нам число прошедших месяцев:

Mes=int(days/30.5)+ MonthOfBorn

А вот после сложения полученного числа с месяцем рождения
нас, быть может, ожидает неожиданность - суммарное число
месяцев может оказаться больше 12! Ну, здесь всё понятно уменьшаем число месяцев на 12, а число лет увеличим на 1:
if Mes>12:
Mes=Mes-12
God+=1
Остаток от деления на 30,5 даст нам число дней, которые надо
добавить к дате рождения:
days=int(days%30.5) + DayOfBorn
Здесь аналогичная проблема - результат может превысить
число дней в месяце:

if days>30:
days-=30
Mes+=1
И здесь результат может опять-таки превысить число месяцев:

if Mes>12:
Mes=Mes-12
God+=1
Мы получили номер месяца, когда мы будем праздновать свой
миллионный день рождения, а для пущей красоты нам надо
вывести номер месяца привычным словом: "октября", "мая"...
Ну это просто - надо создать список месяцев:
Ч|11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111П11111111Г

ф

^Illllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllt

Moons=[1 января','февраля','марта','апреля1,'мая','июня1, '
июля','августа','сентября', 'октября','ноября', 'декабря']
print ('Ваш',Days,'день рождения отмечайте',days, Moons
[Mes-1],God,'года')

Запускаем программу и...

Ваш 1000000 день рождения отмечайте 11 июля 4698 года
Вот это да! Я подозревал, что до миллионного дня рождения
дожить довольно проблематично, но что до такой степени...
Умерим аппетиты, рассчитаем 30 000 день рождения:
Ваш 30000 день рождения отмечайте 25 октября 2042 года

Ну вот это уже в пределах разумного. Посчитайте даты для
себя, например, созовите друзей на свой внеочередной, 5555
день рождения! Или 22222. Или 123451
. ...................................... .

Dem=tuple('''Никогда, никогда ни о чем не жалейте —
Ни потерянных дней, ни сгоревшей любви.
Пусть другой гениально играет на флейте,
Но ещё гениальнее слушали вы.''')
start=0 #начало поиска
for m in range (Dem.count('д')): #цикл по всем буквам
i=Dem.index('д',start) #адрес следующей буквы
print(i, end=' ') #печать адреса
start=i+l #продолжим поиск со следующего адреса

А вот и результат:

5 14 53 85
-niiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiilllllllilllllliiiilllillllilliliiliililiiiililiiiiiiiiiF

Упражнение 15.2
щншжшжшншншншншжшжшшшшмншншншншж1шшжшншжшншншжшншшшш)жижшнижшжшнижшжшнижшжижижшжшш1жшншншж<

Программа несложная, результат в одном месте неожиданный.
##функция возвращает в виде кортежа:
##
- аргумент, умноженный на 2
##
- квадрат аргумента
##
- квадраты. корень из аргумента, если возможно
def multi(х):
Х=х*2
Х2=х**2
if хMax:
# Найден более частотный символ?
Мах2=Мах # Перегружаем предыдущий максимум
Symb2=Symb #Перегружаем предыдущий максим, символ
Max=ABC[j] # Новое максим, число
Symb=j # здесь храним самый частый символ
print ("Символ", Symb, "встречается", Мах, "раз")
print ("А символ", Symb2, "встречается", Мах2, "раз")

Конечно, парой строк тут не обойтись:)
Hlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllt-

Упражнение 16.3
Конечно, на первый взгляд программа простая, но... Но защита
от дурака и корректный выход при нажатии цифры существенно
её усложнили...
# Используем словарь для подсчета количества очков за собранное

слово в Эрудите
def test():

#Проверяем введённое слово

while True:
word = input("Введите слово:

word = word.upper()

")

#переводим все буквы в верхний

регистр

if word.isdigit():

#если введена цифра

return О
else:
ind=l

for j

in word:

ind=ind*(j
if not(ind):

#нет ли в слове латинских букв

in points)

# если была хотя бы буква на латинице,

to ind будет 0
print

("Слово должно состоять только из русских

букв”)

else:

return word # Слово правильное, вернём его
# Создаем словарь с соответствием букв и очков за них

points = {"А" :

"Ж" :

5,

"Н" :

1,

"У" :
„щи .

2,

10 ,

1,

"Б" :

3,

"В"’

1

3,

” р”•

"К":

2,

"Д":

2,

"3" :

5,

"И" :

1,

"Й":4,

"0" :

1,

"П" :

2,

"Р":

1,

"С":

1,

"Т":

1,

"Ф" :

8,

"X" :

5,

"Ц":

5,

"Ч":

5,

"Ш":

8,

"Ь" :

while True:

3,

"Ы" :

5,

"Ъ":

15,

"Э" :

"Л":

8,

запускаем бесконечный цикл

word=test()

if word!=0:

# Считаем количество очков

score = 0 #обнулим счётчик

2,

"Ю":

"Е":
"М":

1,"Ё"
2,

8,"Я":3}

illllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllliu

for ch in word:

Цсчитаем из словаря вес каждой буквы

score = score + points[ch]
# Выводим результат

print("число очков",
else:

score)

# функция вернула О

break #конец работы

print

(

’--до новых встреч!

--’

)

Проверим, как работает:
Введите слово: пастернак30
число очков 11

Надо же, какое длинное слово и как мало очков. Но подсчёт
правильный!
Введите слово: объём
число очков 22

Верно!
411111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111(1

С помощью множеств задача решается на раз-два-три:
Anagl=set('отсечка')

Anag2=set(’сеточка’)
Anag3=set(’тесачок')

Anag4=set(’чесотка')
if Anagl|Anag2|Anag3==Anag4:

print('Это анаграммы')
else:
Tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

30

Я знаю, что в "Эрудите" нельзя использовать имена собственные. Но это слово в данном
случае означает не фамилию великого, но малоизвестного советского поэта, а название также
малоизвестного огородного растения типа петрушки
4

dJIllllllllliiiliillllllllllllllllllillillllllllllllllllliliiiillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllilliilllllllllllllllllllililillllllllllllllliilillllilliilllllllllllililllillllllllllllllliilllilllillllllllb

print('Это не анаграммы')

На экране:
I Это анаграммы

=

Tiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiirr

Первоначально задача кажется проще некуда. Делаем из
панграммы множество, и если в нём 33 элемента, то перед
нами панграмма!
PAN='Съешь же ещё этих мягких французских булок да выпей чаю'

LenPan=len(PAN)
setPAN=set(PAN)
if len(setPAN)==33:
print

('Это панграмма.

В ней',LenPan,

'букв')

else:

print

('Это не панграмма.')

Запускаем и программа выносит вердикт:

Это не панграмма.

Как не панграмма?! Я же самолично всё посчитал - 33 разных
буквы, а всего их - 55... В чём дело? А давайте посмотрим на
состав множества setPAN:

»>setPAN

Первое же, что бросается в глаза - в множестве две буквы
"С" - заглавная и строчная, это для Питона разные буквы!
И второе - пробел, естественно, считается за букву! Это мы
мигом исправим - благо, есть подходящие методы.
А если строчка окажется не панграммой - добавим список

Ф

недостающих для счастья букв. Как? Да просто из эталонного
множества, содержащего все 33 буквы нашего алфавита,
вычтем множество, составленное из букв неудавшейся
ланграммы. Программа немного преобразится:
Etalon=set('ёйцукенпшцзхъэждлорпавыфячсмитьбю ')
PAN='Съешь же ещё этих мягких французских булок да выпей чаю'
PAN=PAN.lower() #сделаем все буквы строчными
LenPAN=len(PAN)#сколько букв в исходнике
setPAN=set(PAN) #сделаем из фразы множество
setPAN.discard(' ')# удалим пробелы
if len(setPAN)==33:
print ('Это панграмма. В ней’,LenPAN, 'букв')
else:
Netu=Etalon-setPAN # находим недостающие буквы
print ('Это не панграмма. Нет 6yKB',Netu)

|
|
|
I
|
|
|
|
|
|

Запустим... Вау! Работает!
Это панграмма. В ней 55 букв

1

А теперь удалим в проверяемой фразе буквы "г" и "о":
Это не панграмма. Нет букв {'г',

'о')

|

Ну что ж. Хорошо. Я бы даже сказал - отлично. Поэтому

изменим подопытную фразу, пусть теперь это будет: "Любя,
съешь щипцы, — вздохнёт мэр, — кайф жгуч" (к сожалению,
все предельно короткие панграммы какие-то идиотские - это
расплата за краткость). Вставляем фразу в программу, в
переменную PAN, запускаем и читаем не менее идиотский ответ: I
Это не панграмма. Нет букв set()

|

В нашей фразе завелись знаки препинания, и длина
множества setPAN превысила отметку в 33 знака! Поэтому
при вычитании Etalon-setPAN мы получили как бы
.................................................................................................................... ё

отрицательное множество. Вы можете представить множество
с отрицательным числом элементов? Вот и Питон не может.
Спасибо, что хоть программа не вылетела, а выдала странный,
но всё же ответ.

Значит, надо удалить из множества, содержащего знаки
из подопытной фразы, всё, что не буква! Вместо строки,
удаляющей пробелы, вставим в программу вот такой фрагмент:
for j in setPAN: #Цикл no элементам множества!
if not (j.isalpha()):
setPAN.discard(j)

Запускаем... Питону этот фрагмент не понравился:
for j in setPAN: #Цикл по элементам множества!
RuntimeErron Set changed size during iteration

Перевод: "множество изменило размер в процессе итерации",
то есть в процессе считывания значений в заголовке цикла мы же удаляем из множества знаки препинания, вот его длина
и меняется прямо в ходе цикла. Ой, ну подумаешь! Сделаем
копию множества и поработаем с ней:
setPAN2=setPAN#caenaeM из фразы множество ещё раз
for j in setPAN2: #Цикл no значениям копии!
if not (j.isalpha()):
setPAN.discard(j) #всё, что не буква - удаляем из
основного множества!

Запускаем... И получаем от Питона такой же ответ:
for j in setPAN2: #Цикл по элементам множества!
RuntimeErron Set changed size during iteration
Внимание! Важный момент! He рекомендуется присваивать
одной последовательности значение другой. На самом деле

Г 315 1

вы получите при этом одну последовательность (то есть
множество, кортеж, список) с 2 именами. Вот вам пример:

»>R=[2,3,4]

|

»>R2=R
>»R[l]=-5
»>R2
[2f -5, 4]

|
|
I
|

To есть изменили значение в списке R, а изменился также и
список R2!

Аналогичное явление произошло и у нас. Поэтому сделаем
копию непосредственно из фразы:
setPAN2=set(PAN)

|

ну а программу запишем вот так:
Lno=''

# здесь будет список букв,

которых нет в заданной строке

|

Etalon=set('ёйцукенпшцзхъэждлорпавыфячсмитьбю 1)

|

РАЫ='Любя,

|

съешь щипцы,

LenPAN=len(PAN)

— вздохнёт мэр,

— кайф жгуч.’

|

#сколько всего букв во фразе

PAN=PAN.lower()#сделаем все буквы строчными

|

setPAN=set(PAN)#сделаем из фразы множество

|

#Избегайте прямых присваиваний типа setPAN2=setPAN.

При

|

изменении значения

|

# в одной последовательности,
# Поэтому и проводится это,

может измениться и другая!

на первый взгляд,

нелогичное

setPAN2=set(PAN)#сделаем из фразы множество ещё раз

in setPAN2:

if not

|
|

присвоение

for j

1

#Цикл по значениям копии!

(j.isalpha()):

setPAN.discard(j)

|

|
|

#всё,

что не буква - удаляем из

|

основного множества!

1

if len(setPAN)==33:

1

print

else:

(’Это панграмма.

В ней’,LenPAN,

'букв’)

|
|

^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHIIIIHIir

^Illlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllt

Netu=list(Etalon-setPAN) # находим недостающие буквы
# здесь мы просто организуем красивый вывод без фигурных скобок
for j

пробел

in Netu:

Lno+=j+’

print

'

# выведем отсутствующие буквы через

('Это не панграмма.

Нет букв:',Ьпо)

Запускаем... Ура! Работает!
Это панграмма. В ней 47 букв

Удалим в подопытной фразе первое слово. На экране:
Это не панграмма. Нет букв: я ю б л
Alillllllliiilliliiiillilillllllllllllllllllllllllllllliiiiiliiililililililiiiliiililllllllllllllilllililililililiiilillllllllllliiiiiiiiiiiiiiiliilllllliiliiillillliiiliiiiiiiiiiiiiiiiiiiiiiiiiitllllllllllllllllllllllllllllllllllllllllllllllllllirr

Примерно так (игру заканчиваем, как и обещал, при нажатии
редкой клавиши - "Ъ"):
import random

abc='абвгдежзик’# список букв
Pole=set()#создаём пустое множество

for i in range(len(abc)*4):
X=random.choice(abc)# координата X - буква

Y=random.randint (1,len(abc))# координата Y - число
Z=X+str(Y)#собираем пару буква-число

Pole.add(Z)# и сохраняем пару в множестве
IN=0 # счетчики попадании...
OUT=0 #...

и промахов

while True:#
XY=input('Стреляй

if

XY=='t>'
print

')#ждём координаты от игрока

or XY==”b' :# конец игры
("У вас ",IN,

" попадания и ", OUT

break
elif XY in Pole:# попал???!

IN+=1
print ('

Попал!!!!’)

/’промахов!")#

iJIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIKIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIU

else: #
мимо!!!!!
OUT+=1
print("Мимо")
4iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiililllliiiliiliilllllllllllliiiiiiiiiilliiillillllilllllllllllllllilllllllilllllilllilllllllllllllllllllllllllllllllllllllillliilllllllllllllllllllliillilllllllllllllllliF

Задача оказалась посложнее, чем сначала казалось. Сначала,
естественно, получилась вот такая программа:
import random
SKLAD=set()#создаём пустое множество
х=1000
у=1000
z=10
while len(SKLAD)жхмш1жшжижш*шиншншн4шшжшжшншжшнижшншн синусы

RndSin=list(map(lambda Rrr:

round(Rrr,

3),

Sin))

'nilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

^IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIILL

ZIPPO=dict(list(zip(grad,RndSin)))

#сцепим градусы с синусами

Tl=time()-T

print('Время работы с преобразованием на каждом этапе',Т1)

T=time()# вновь засекаем начало работы

Rad=map(radians ,grad)#градусы -> радианы
Sin=map(sin,Rad)

#радианы -> синусы

RndSin=list (map (lambda Rrr:

round(Rrr,

3),

Sin))

ZIPPO=list(zip(grad,RndSin))#сцепим градусы с синусами
T2=time()-T

print('Время работы с преобразованием только на последнем
этапе',Т2)

Запускаем - наблюдаем результат:

Время работы с преобразованием на каждом этапе 0.002038240432739258
Время работы с преобразованием только на последнем этапе 0.0
Какой Питон шустрый! Ладно, увеличим размеры списка grad()
до 10 000 элементов:

Время работы с преобразованием на каждом этапе 0.009956121444702148
Время работы с преобразованием только на последнем этапе
0.004992246627807617
М-да, ожидаемого ускорения в 100 раз не получилось... Почему?
"Темна вода во облацех...32", не всегда можно предугадать
скорость выполнения программ...
-tlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

from random import randint
Ff=open(’ 100.txt' ,

'w')

# Создадим новый

(или переделаем старый)

файл

Rand=[]

#сюда поместим наши случайные числа

Alllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

32

Очередная цитата из Библии. Так говорят о чём-то непонятном

NumDig=10_ООО #количество чисел
гazbros=10_000_000 #разброс случайных чисел

Сначала, как обычно, создаём список, куда поместим
полученные числа, и задаём константы.
for i in range(NumDig):
x=randint (l,razbros) # получаем случайное число
Rand.append(x/100) #вот вам числа с 2-мя знаками после
запятой
Digi=" ". join(map(str, Rand)) #Преобразуем список чисел в строку

А здесь самое сложное. Сначала мы функцией тар ()

преобразуем каждое число в строчку, а затем методом . join ()
получаем, наконец, длинную строку для записи в файл.
Ff.write(Digi) #записали файл
Ff.close () #закрыли файл
^iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiniiiiiiiiiiiiiii

Ц1жшншжшнш*штишшнижшшш*шжшш1жшжшншжшшшшмншншжшшмнш«шшшжижштш»шжшншмшжшншжшншншжижшжштш*шиштижи

Здесь всё понятно из комментариев:
F100=open(’100.txt’)
Digi=F100.read()# Содержимое файла —> в текстовую переменную
DigTxt^Digi. split(’ ') # разбиваем на список, состоящий из чисел
в виде текста
digs=list(map (float,DigTxt)) # преобразуем текст в числа
cnt=0
Dig_Del=131313 # число, на которое должна делится сумма

for i in range (len(digs)):
for j in range(ill,len(digs)):
X=digs[i]+digs[j] # складываем очередную пару
if X%Dig_Del==0: #делится на заданное число?
print (digs[i],digs[j]) # печатаем пару
cnt+=l # увеличиваем счётчик

^llllllllllllllllilllllllllllllllilllllilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllb

print('Делится на',Dig_Del,':',ent,'пары')
FlOO.closef) # закрываем файл

На экране, для примера:

70648.55 60664.45
55109.69 76203.31
81606.99 49706.01
Делится на 131313 : 3 пары

Как вы уже давно поняли, при использовании функций из модуля

random у вас каждый раз будут получаться несколько иные
результаты.
'rilllllllllllllllllllllllllllllllllllllllllllllilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllir

шжшншжшш1жш*шин1инижшнижшжиж11яшжиикшнш*шжимншнижшншжшш1жшжиншжшшшшжшжшш1жииш1ншжшншншжшнижижшншншжшм

У меня получилась вот такая программа:

import time
import random
AZ=’1234567890qwertyuiopasdfghjklzxcvbnm' #список всех букв
и цифр
print("+++ сейчас мы измерим вашу реакцию +++")
k=random.randint (0,len(AZ)) #Выбираем случайным образом букву
из AZ
time.sleep(3) #ждём 3 сек.
start = time.time()#начало ожидания
txt = input(”Нажмите клавишу "+str( AZ[k])+'
')
if txt==str(AZ[k]):
end = time.time() #нажата верная клавиша
reac = end - start #время ожидания
print("Время вашей реакции: ", reac," секунд.") #вывод
else: # неверная клавиша
print (’мимо’)

Ну что ж, проверьте свою же реакцию своей программой.
'nillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirr

Упражнение 21.2
Вот такая несложная программа получилась
|

import time

1

|

import random

I

|

Q=random.randint(8,15)

|

tl=time.time()

# засекаем начало

|

a=input(’через

'+str(Q)+’

|

t2=time.time()

# засекаем момент нажатия

|

T=round(t2-tl-Q,1)

|

if Т < 0:

|
|
|

|
|
|
|
|

print

else

# генерация числа из интервала

|

|

секунд нажмитеENTER’)

#определяем отклонение от заданноговремени

|
|

|
1

("Поторопились на",

-Т,

’секунд')

|

:

print

|

("задержались на",

Т,

'секунд')

|

Сделайте несколько замеров своего ощущения времени.
А теперь определите свой темперамент: если вы сильно
торопитесь - холерик, немного торопитесь - сангвиник, немного
задерживаетесь - меланхолик, сильно задерживаетесь флегматик.

I

Tiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiinrf

Займёмся сначала функцией согласования числительного с
существительным "день". В качестве аргументов функция
получает целое число дней и ... слово "день", которое надо
согласовать с числом. Этой же функции в дальнейшем
предстоит согласовать слова "месяц" и "год". Дадим ей звучное
имя YeMeDay (сокращение от "год-месяц-день" для знающих
английский)

def YeMeDay(n, k):
какое слово будем согласовывать:

if k=='день':

0

T1IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII

lliiiiiiiiiiiiiiiiiilliilliiliiiiiliiiiiiiiiiiiiliiiiiiiiiliiilllilllllllllillllililillllilllllllllllilllllllllillllillllilllllliilllllllllllllillilllililiillliliiiiiiiiiiiiiiiiiiiiiiiillllilllillllillllllllllllilliilliiiiiiiiiiiiiiiiiiiiiilb

|
I
|
I
|
|
|

Мне не хочется повторять код из упражнения 5.5 - любая
сложная программа имеет несколько вариантов написания.
Поэтому сделаем немного по-другому: сначала сразу
проверим попадание числа дней в самый сложный интервал
от 20 до 10:

|

if 20 > п > 10:

I

|

return 'дней'

I Дальше пойдёт проще; если числительное оканчивается на
| цифру 1, то пишем "день":
|
|

|

elif п%10==1:
return
'день'

|
|

| А вот если оканчивается на цифры 2,3>4 - пишем "дня":
|

elif (4 >= (п%10) >= 2):

|
|

return 'дня'
return 'дней'

|
|
|

I Аналогично напишем фрагмент для слова "год" (не забудьте,
I
|
|
|

что в русском языке не пишут "20 годов", а пишут "20 лет" наверное, чтобы замучить иностранцев, изучающих русский
язык). А для слова "месяц" фрагмент будет ещё и проще -13
месяцев бывает только в сказках.

|

| В результате функция выглядит так:

|

| def YeMeDay(n,k) :
|
if к=='день':
|
if 20>n>10:

|
|
|

|

I
|
|

|

return 'дней'
elif п%10==1:
return 'день'
elif (4>=(п%10)>=2):

I
|
|

^llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllirf

F----- 1
[к 337

£1111111... Illlllll.... I.. ............................... .........................................lllllllllll.. lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllilllllli

return 'дня'
return 'дней'
elif k=='месяц':
if n==l:
return 'месяц'
if 4>=n>=2:
return 'месяца'
return 'месяцев'
else:
if 20>n>10:
return 'лет1
elif n%10==l:
return 'год'
elif (4>=(n%10)>=2):
return 'года'
return 'лет'
Оставим функцию в покое и перейдёмк написанию собственно

|
|
|
|
1
|
|
|
I
|

I
|

I
|
|

|

программы, которая получилась довольно солидная:
Day=int(input("Введите день вашего рождения: "))
Monsint(input("Введите месяц вашего рождения(числом): "))
Year^int(input("Введите год вашего рождения: "))

|
|
|

Здесь всё просто: получаем от пользователя день, месяц и год
рождения.
DM=[31,28,31,30,31,30,31,31,30,31,30,31]

I

Список DM содержит число дней в каждом месяце.
MonDig=(•Jan':1,'Feb':2, 'Mar':3,'Apr':4,'Мау':5,' Jun':б,' Jul':7,
'Aug':8,'Sep':9,'Oct':10,'Nov':11,'Dec':12)

j
|

А вот словарь MonDig ("месяц-число") превращает сокращённое |
английское название месяца в его порядковый номер в году.
AlllllllllllllllllllllllllllllllllllllllllllilllllllllllllIlllIlllllllIllIllllllllllIllllllllllllllllllllllllllllllllllinillllllllllllllllllllllllllllllllllllllllllllllllllllllllllillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllF

^Illlllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllilllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllb

I

|
|
|
|
|
|

sec = time.time()#время в секундах с начала эпохи
Ltime = time.сtime(sec) # местное время в виде строки
MonStr=Ltime[4:7] # сокращённое название месяца на английском
MON=MonDig[MonStr] #с помощью словаря MonDig переведём месяц
в число
DAY=int(Ltime[8:10]) #вычленяем из строки день
YEAR=int(Ltime[20:25]) #... и год (числом)

I Начинаем расчёты. Из номера года на данный момент вычтем
| год рождения:
|

Ye=YEAR-Year #сколько лет прошло

|
|
|
|
|

1
|

|
|

| Из номера месяца вычитаем месяц вашего рождения:
|

|
|
|
|
i

Mo=MON-Mon #сколько месяцев

|

А здесь нас может ожидать сюрприз! Если вы родились в
ноябре, а сейчас на дворе февраль, то число прошедших
месяцев станет отрицательным (2-11=-9... А между февралём и
ноябрём 3 месяца! Значит, добавляем к результату 12 месяцев
(то есть 1 год), и, соответственно, уменьшаем число лет на 1.

| if Мо=n>=2:

return
return
else:

'месяца’

'месяцев'

# согласуем года

if 20>n>10:

return

'лет'

elif n%10==l:

return k
elif

(4>=(n%10)>=2):

return
return

'года'

'лет'

def Counter():
Day=input("Введите день вашего рождения:

if Day.isdigit():

")

#введено число

Day=int(Day)

33
Свояк - муж сестры жены, племянник - сын брата или сестры, Лионель Месси - выдающийся
аргентинский футболист современности, Александр Овечкин - выдающийся российский хоккеист современности

Г------к 341_ j

^Illllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll^

else: # введена буква
print ('
Сеанс окончен. До свидания!')
return 0
Mon=int(input("Введите месяц вашего рождения (числом): "))
Year=int(input("Введите год вашего рождения: "))
DM=[31,28,31,30,31,30,31,31,30,31,30,31]

|
1
1
1
|
|

1
MonDig={’Jan’:1,'Feb’:2, ’Маг’:3,’Apr’:4,'Мау’:5,’Jun’:б,
| ’Jul’:7, ’Aug’:8,’Sep’:9,’Oct’:10,’Nov’:11,’Dec’:12}

|
|

|
sec = time.time()#время в секундах с начала эпохи
|
Ltime = time.сtime(sec) # местное время в виде строки
|
#print("Местное время:", Ltime)
|
MonStr=Ltime [4:7] # сохраненное название месяца на английском
|
M0№MonDig [MonStr] #с помощью словаря MonDig переведём месяц
| в число
|
DAY=int(Ltime[8:10]) #вычленяем из строки день
|
YEAR=int(Ltime[20:25]) #... и год (числом)
|
print (MON,DAY,YEAR)

|
|
|
|
1
I
|
|
|

I

|
|
|
|
|

|
Ye=YEAR-Year #сколько лет прошло
|
|
Mo=MON-Mon #сколько месяцев
|
|
if Моdeca. center (36, ’ : ’)
мыслю, - значит, существую::::'
Афоризм Р. Декарта - великого французского математика, философа, физика и физиолога
В переводе с английского "Всё, что тебе нужно - это любовь" - знаменитая песня группы "The Beatles"
Ь2с (по-английски пишется business-to-consumer) — это модель бизнеса, в которой компания
продаёт товар частному лицу. К примеру, это - продуктовые магазины, развлекательные
центры, кафе и рестораны, кинотеатры

1
2
3

346

count(str, [start],[end]) - выдаёт количество вхождений подстроки str в
диапазоне [start,end] (а по умолчанию от начала до конца).
»>deca. count (' ю')
2

»>deca.count ('ю' ,20,30)
1

find (str, [start], [end]) - выдает номер первого вхождения подстроки str в
диапазоне [start,end] (а по умолчанию от начала до конца), выдаёт -1, если
подстрока не найдена.
»>deca.find( 'ю' ,20,30)

index (str, [start],[end]) - выдает номер первого вхождения подстроки str
в диапазоне [start,end] (а по умолчанию от начала до конца), выдаёт
ValueError, если подстрока не найдена. Это полезно, если нам надо обой­
ти этот случай с помощью оператора try.

»>BEATLES. index ('O')
5
>»BEATLES . index (' О' , 5)

5

»>BEATLES. index ('0'6)

isalnum() - проверяет, состоит ли строка из цифр или букв. Выдаёт True в
таком случае:
»>deca. isalnum ()

*

ran

False
(в строке есть запятая и тире)

»>BEATLES . isalnum ()
False

(оказывается, пробелы за буквы не считаются! Вот так сюрприз от имени Питона!)
>»Ь2с. isalnum ()

True

isalpha() - проверяет, состоит ли строка из букв. Выдает True в таком
случае:

»>deca. isalpha ()
False
(в строке есть запятая и тире)

isdigit() - проверяет, состоит ли строка из цифр. Выдаёт True в таком
случае:

»>deca. isdigit ()

False
(в строке вообще нет ни одной цифры)
»>' 021' . isdigit ()

True

islower() - состоит ли строка из символов в нижнем регистре.
»>deca. islower ()
True
>»Ь2с. is lower ()

True

То есть цифры игнорируются

istitle() - начинаются ли слова в строке с заглавной буквы.
»>BEATLES.istitle()
False
ЧТО? Да здесь ведь вся строка состоит из заглавных букв! Я что-то не
так понимаю? Совершенно верно - не так. Здесь слова должны только
начинаться с заглавных букв, а дальше должны идти обычные строчные
буквы:

»>'А11 You Need Is Love'.istitle()
True
»>' All you need is Love'.istitle()

False

^непоследовательность:») - самый необычный метод, в нём всё
наоборот. Он отвечает за объединение списка строк с помощью опре­
деленного разделителя. Метод собирает из последовательности любого
типа строку, разделяя элементы стоящим впереди разделителем:

=.]от()
>»' . ' .join(deca)

'я. .м.ы.с.л.ю.,..-. .з.н.а.ч.и.т.,. .с.у.щ.е.с.т.в.у.ю'
Ну, собрать из строки строку большого ума не надо.

>»m=' 1' , ' 2 ' , ’ 3 '

ljust(width, char) - делает длину строки не меньшей width, заполняя симво­
лы справа знаком char.

»>BEATLES. 1 just (32, ' * ')
'ALL YOU NEED IS LOVE************'

Iower() - переводит все символы строки в нижнии регистр.
»>BEATLES. lower ()
'all you need is love*

Istrip([str]) - удаляет указанные (по умолчанию пробелы) символы в нача­
ле строки.
»>BEATLES . lstrip (' ALL')

' YOU NEED IS LOVE'

replace (old, new, [max]) - заменяет подстроки old на подстроки new.
Необязательный параметр устанавливает максимальное число замен.
»>deca. replace (’ с' , 1 ч' , 2)

'я мычлю, - значит, чуществую*

F----------- 1

rfind (str, [start], [end]) - выдаёт номер первого с конца вхождения под­
строки str в диапазоне [start,end] (а по умолчанию от начала до конца),
выдаёт -1, если подстрока не найдена. То есть поиск начинается спра­
ва, о чём говорит буква "г" в названии метода ("right" - правый).

»>deca. rfind (' ю')
27

rjust(width, char) - делает длину строки не меньшей width, заполняя
символы слева знаком char.

»>BEATLES.гjust(32,'+')

'++++++++++++ALL YOU NEED IS LOVE'

rstrip([str]) - удаляет указанные (по умолчанию пробелы) символы в
конце строки.

То есть, если в самом конце строки символ не нашёлся - ничего не
делаем

зр1Щ[ [,]]) - разбивает строку на подстроки по
указанному разделителю. Если скобки пустые - разделяем по пробелу.
Второй параметр ограничивает количество подстрок.

»>BEATLES. split ()

['ALL', ■YOU', ‘NEED1, 'IS', 'LOVE']

»>BEATLES. split (' L')

[•А1,", * YOU NEED IS ', 'OVE']

»>BEATLES . split (' О' , 1)
['ALLY', 'U NEED IS LOVE']
Как видите, разделитель исчезает из строки.

strip([str]) - удаляет указанные (по умолчанию пробелы) символы в на­
чале и конце строки.

»>' абракадабра' . strip (' a')
'бракадабр'

swapcase() - заглавные буквы заменяются на строчные и наоборот.

>»Реса='Я Мыслю, - Значит, Существую

»>Deca. swapcase ()
'я МЫСЛЮ, - ЗНАЧИТ, СУЩЕСТВУЮ'

title() - делает заглавной первую букву каждого слова
»>deca. title ()

'Я Мыслю, - Значит, Существую'

upper() - делает заглавными все символы строки
»>deca. upper ()

'Я МЫСЛЮ, - ЗНАЧИТ, СУЩЕСТВУЮ'

352

||||—Самое главное, что методы строк, в отличие
1Гот методов обработки списков, не изменяют

саму строку,

а потому результат выполнения
надо записывать к какую-нибудь (можно в ту же са­
мую) переменную.

353

Приложение 2.

ОСНОВНЫЕ МЕТОДЫ
ОБРАБОТКИ СПИСКОВ

Введём подопытные списки:

append(q) - добавляет элемент q в конец списка.

»> Dig. append (' ещё')
»> Dig

[11,12,13, ‘ещё’]

extend(Q) - добавляет список Q в конец списка. Главное, здесь можно
добавить сразу список, а не 1 элемент, как в append(q).

»>mini. extend (Wrd)

>»mini
[-1.1, -12.3, 'слово', 'дело']
То же самое можно сделать, используя + (конкатенацию)

index(x, [start [, end]]) - возвращает положение первого элемента со
значением х (при этом поиск ведётся от start до end)

»>Wrd. index (' дело')

1
»>Many= [1,2,3,4,5,б,7,8,9]

»>Many. index (5)

insert( i, Q) - вставляет элемент Q на i-oe место.

»>Wrd. insert (1, ' и')

»>Wrd
['слово', 'и', 'дело']

[-1.1,-12.3,’дело’]
Г 357 1

РОР(Ш) - удаляет i-ый элемент в списке. Если индекс не указан удаляет последний.

»>Wrd.pop (1)
'и'

»>Wrd
['слово1, 'дело']

remove(Q) - удаляет первый элемент в списке, имеющий значение Q.
Происходит ошибка ValueError, если такого элемента не существует.

»>mini. remove (' слово')
»>mini

[-1.1, -12.3, 'дело']

reversef) - переворачивает список.
>»Dig. reverse ()
»>Dig

['ещё', 13,12,11]

Вот только сортировать этот метод умеет лишь списки, состоящие из одно­
родных элементов:
»>Wrd. sort ()
»>Wrd

['дело', 'слово']

»>Dig. sort ()
Traceback (most recent call last):

File "", line 1, in
Dig.sortQ

TypeErron '«' not supported between instances of 'str* and 'int*
Перевожу: "не умею я сравнивать строки и числа".

Приложение 3.

ОСНОВНЫЕ МЕТОДЫ
ОБРАБОТКИ СЛОВАРЕЙ

Где подопытная строка? Вот она:

сору() - возвращает копию словаря.

»>LTl=Lat. copy ()

»>LT1
{1: ‘Finis', 2: 'coronat', 3: ’opus')

get(key[, default]) - возвращает значение ключа; если указанного значе­
ния ключа нет, выводит значение default (по умолчанию None).

»>Lat .get (2)
'coronat'

final

362

Это последняя сноска в книге, поэтому очередная латинская пословица переводится как
"Конец - всему делу венец"

Если вы уверены, что нужный ключ есть в словаре, удобнее, конечно,
обращаться к значению прямо по ключу:
»>Lat[2]

'coronat'

pop(key) - удаляет ключ и возвращает его значение. Если ключа нет получим ошибку KeyError и остановленную программу.
»>Lat.pop (2)
'coronat'

»>Lat
{1: 'Finis', 3: 'opus'}
А теперь попытаемся удалить уже несуществующий ключ:

»>Lat.pop (2)

Traceback (most recent call last):
File "", line 1, in

Lat.pop(2)

KeyErron 2
Получаем ошибку.
363

update([other]) - обновляет/дополняет словарь, добавляя пары (ключ,
значение) из other. Существующие ключи перезаписываются.
Можно вот таким, затейливо-запутанным способом:

»>Lat. update ([ (4, ' Gloria') ])

»>Lat
{1: 'Finis', 2: 'coronat', 3: 'opus', 4: 'Gloria'}
А можно проще, просто добавляя куски словаря:

»>Lat. update ({ 5: ' victory bus ' })
»>Lat
{1: 'Finis', 2: 'coronat', 3: 'opus', 4: 'Gloria', 5: 'victory bus'}

Перезапишем ошибочный ключ:
»>Lat. update ({5: ' victoribus ' })
»>Lat
{1: 'Finis', 2: 'coronat', 3: 'opus', 4: 'Gloria', 5: 'victoribus'}

valuesQ - выдает значения в словаре, причем в виде объекта:
»>Q=Lat. values ()
А как "прочитать" содержимое объекта, мы уже знаем - функцией list:
»>list (Q)
['Finis', 'coronat', 'opus', 'Gloria', 'victoribus']

Г 364 1

Список использованных источников информации:

•

Кольцов Д.М., Дубовик Е.В.

Справочник PYTHON.

Кратко,

быстро,

под рукой - Спб.:

Наука и Техника, 2021.

•

Сузи Р.А. Python. - СПб.: БХВ-Петербург, 2002.

•

Лутц М. Изучаем Python, 3-е издание - Пер. с англ. - СПб.: СимволПлюс, 2009.

•

Любанович

Билл Простой

Python.

Современный

стиль программирования. — СПб.:

Питер, 2016.

•

Мюллер, Джон Пол Python для чайников, 2-е изд. : Пер. с англ. - СПб. : ООО "Диалекти­
ка", 2019.

•

python-script.com

•

pythonru.com

•

habr.com

•

pythononline.ru

•

https://icons8.ru/icon/pIJdjOoL6KfU/%D0%BF%D0%B8%D1%82%D0%BE%D0%BD

•

https://www.flaticon.com/free-icon/python_3049800?term=python&related_id=3049800

Издательство «Наука и Техника»
КНИГИ ПО КОМПЬЮТЕРНЫМ ТЕХНОЛОГИЯМ,
МЕДИЦИНЕ, РАДИОЭЛЕКТРОНИКЕ

Уважаемые читатели!
Книги издательства «Наука и Техника» вы можете:
> заказать в нашем интернет-магазине БЕЗ ПРЕДОПЛАТЫ по ОПТОВЫМ ценам

www.nit.com.ru
• более 3000 пунктов выдачи на территории РФ, доставка 3—5 дней

• более 300 пунктов выдачи в Санкт-Петербурге и Москве, доставка — на следующий день

Справки и заказ:
• на сайте

www.nitcom.ru

• по тел. (812) 412-70-26

• по эл. почте nitmail@nit.com.ru

> приобрести в магазине издательства по адресу:
Санкт-Петербург, пр. Обуховской обороны, д.107

М. Елизаровская, 200 м за ДК им. Крупской
Ежедневно с 10.00 до 18.30

Справки

и заказ: тел. (812)412-70-26

> приобрести в Москве:
«Новый книжный» Сеть магазинов

тел. (495) 937-85-81, (499) 177-22-11

ТД «БИБЛИО-ГЛОБУС»

ул. Мясницкая, д. 6/3, стр. 1, ст. М «Лубянка»
тел. (495) 781-19-00,624-46-80

Московский Дом Книги,

ул. Новый Арбат, 8, ст. М «Арбатская»,

«ДК на Новом Арбате»

тел. (495) 789-35-91

Московский Дом Книги,

Ленинский пр„ д.40, ст. М «Ленинский пр.»,

«Дом технической книги»

тел. (499) 137-60-19

Московский Дом Книги,

Комсомольский пр., д. 25, ст. М «Фрунзенская»,

«Дом медицинской книги»

тел. (499) 245-39-27

Дом книги «Молодая гвардия»

ул. Б. Полянка, д. 28, стр. 1, ст. М «Полянка»

тел. (499) 238-50-01

> приобрести в Санкт-Петербурге:
Санкт-Петербургский Дом Книги
Буквоед. Сеть магазинов

Невский пр. 28, тел. (812) 448-23-57
тел. (812) 601 -0-601

> приобрести в регионах России:
г. Воронеж,

«Амиталь» Сеть магазинов

г. Екатеринбург,

«Дом книги» Сеть магазинов

г. Нижний Новгород, «Дом книги» Сеть магазинов
г. Владивосток,

«Дом книги» Сеть магазинов

тел. (473) 224-24-90
тел. (343) 289-40-45
тел. (831)246-22-92

тел. (423) 263-10-54

г. Иркутск, «Продалить» Сеть магазинов

тел. (395) 298-88-82

г. Омск, «Техническая книга» ул. Пушкина, д.101

тел. (381)230-13-64

Мы рады сотрудничеству с Вами!

Книги по компьютерным технологиям, медицине, радиоэлектронике

Уважаемые авторы!
Приглашаем к сотрудничеству по изданию книг по IT-технологиям, электронике,
медицине, педагогике.

Издательство существует в книжном пространстве более 20 лет и имеет большой
практический опыт.
Наши преимущества:

- Большие тиражи (в сравнении с аналогичными изданиями других издательств);
- Наши книги регулярно переиздаются, а автор автоматически получает гонорар с
каждого издания;
- Индивидуальный подход в работе с каждым автором;
- Лучшее соотношение цена-качество, влияющее на объемы и сроки продаж, и, как
следствие, на регулярные переиздания;
- Ваши книги будут представлены в крупнейших книжных магазинах РФ и ближнего
зарубежья, библиотеках вузов, ссузов, а также на площадках ведущих маркетплейсов.
Ждем Ваши предложения:

тел. (812)412-70-26

/ эл. почта: nitmail@nit.com.ru

Будем рады сотрудничеству!

Для заказа книг:
>

интернет-магазин: WWW.nit.COm.ru/ БЕЗ ПРЕДОПЛАТЫ по ОПТОВЫМ ценам
более 3000 пунктов выдачи на территории РФ, доставка 3-5 дней

более 300 пунктов выдачи в Санкт-Петербурге и Москве, доставка 1-2 дня
•

тел. (812) 412-70-26

эл. почта:

>

nitmail@nit.com.ru

магазин издательства:

г. Санкт-Петербург, пр. Обуховской обороны, д.107

метро Елизаровская, 200 м за ДК им. Крупской

ежедневно с 10.00 до 18.30
справки

>

и заказ:

крупнейшие книжные сети и магазины страны
Сеть магазинов

>

тел. (812) 412-70-26

«Новый книжный»

тел. (495) 937-85-81, (499) 177-22-11

маркетплейсы ОЗОН, Wildberries, Яндекс.Маркет, Myshop и др.

Иванов С. С.

Начнем

PYTHON
Просто о сложном

Группа подготовки издания:

Зав. редакцией компьютерной литературы: Л/. В. Финков

Редактор: Е. В. Финков
Корректор: А. В. Громова

ООО "Издательство Наука и Техника"
ОГРН 1217800116247, ИНН 7811763020, КПП 781101001

192029, г. Санкт-Петербург, пр. Обуховской обороны, д. 107, лит. Б, пом. 1-Н
Подписано в печать 05.06.2023. Формат 70x100 1/16.

Бумага офсетная. Печать офсетная. Объем 23 п.л.
Тираж 2000. Заказ 6914.
Отпечатано с готового оригинал-макета
ООО «Принт-М», 142300, М.О., г.Чехов, ул. Полиграфистов, д.1