WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     || 2 |
-- [ Страница 1 ] --

Чаплыгин А. Н.

Учимся программировать вместе с Питоном (Start with Python) Revision: 170 Ревизия: 170 Содержание Содержание Содержание........................................................................................................................................2 Предисловие...................................................................................................................................... 5 Благодарности...................................................................................................................................7 Введение............................................................................................................................................. 8 §0.1. Базовые знания......................................................................................................................9 §0.2. Где достать интерпретатор языка Питон?..........................................................................9 §0.3. Установка интерпретатора языка Питон в UNIX............................................................ §0.3.1. Установка/обновление Питона из rpm-пакета......................................................... §0.3.2. Установка Питона из исходного кода....................................................................... §0.4. Установка Питона в ОС Windows..................................................................................... §0.5. Запуск программ, написанных на Питоне........................................................................ §0.6. Среда разработки................................................................................................................ Глава 1. Базовые понятия............................................................................................................. §1.1. Алгоритмы и программы................................................................................................... §1.2. Языки программирования и уровни абстракции............................................................. §1.3. Формальные и естественные языки.................................................................................. §1.4. Интерпретаторы и компиляторы....................................................................................... §1.5. Первая программа............................................................................................................... §1.6. Что такое отладка?.............................................................................................................. §1.6.1. Синтаксические ошибки (syntax errors).................................................................... §1.6.2. Ошибки выполнения (runtime errors)........................................................................ §1.6.3. Семантические ошибки (semantic errors).................................................................. §1.6.4. Процесс отладки.......................................................................................................... Глава 2. Переменные, операции и выражения......................................................................... §2.1. Значения и типы.................................................................................................................. §2.2. Преобразование типов........................................................................................................ §2.3. Переменные......................................................................................................................... §2.4. Имена переменных и ключевые слова.............................................................................. §2.5. Выражения........................................................................................................................... §2.6. Выполнение выражений..................................................................................................... §2.7. Операторы и операнды....................................................................................................... §2.8. Порядок операций............................................................................................................... §2.9. Простейшие операции над строками................................................................................ §2.10. Композиция....................................................................................................................... Глава 3. Функции........................................................................................................................... §3.1. Подпрограммы.................................................................................................................... §3.2. Вызовы функций................................................................................................................. §3.3. Справочная система............................................................................................................ §3.4. Импорт модулей и математические функции.................................................................. §3.5. Композиция......................................................................................................................... §3.6. Создание функций.............................................................................................................. §3.7. Параметры и аргументы..................................................................................................... §3.8. Локальные переменные...................................................................................................... §3.9. Поток выполнения.............................................................................................................. §3.10. Стековые диаграммы........................................................................................................ §3.11. Функции, возвращающие результат............................................................................... Глава 4. Компьютерная графика................................................................................................ Ревизия: 170 Содержание Глава 5. Логические выражения, условия и рекурсия........................................................... §5.1. Комментарии в программах............................................................................................... §5.2. Простые логические выражения и логический тип данных........................................... §5.3. Логические операторы....................................................................................................... §5.4. Выполнение по условию и «пустота»............................................................................... §5.5. Ввод данных с клавиатуры................................................................................................ §5.6. Альтернативные ветки программы (Chained conditionals).............................................. §5.7. Пустые блоки....................................................................................................................... §5.8. Вложенные условные операторы (Nested conditionals)................................................... §5.9. Рекурсия............................................................................................................................... §5.10. Стековые диаграммы рекурсивных вызовов.................................................................. §5.11. Максимальная глубина рекурсии.................................................................................... §5.12. Числа Фибоначчи.............................................................................................................. Глава 6. Циклы............................................................................................................................... §6.1. Оператор цикла while......................................................................................................... §6.2. Счетчики.............................................................................................................................. §6.3. Бесконечные циклы............................................................................................................ §6.4. Альтернативная ветка цикла while.................................................................................... §6.5. Табулирование функций.................................................................................................... §6.6. Специальные и экранируемые символы........................................................................... §6.7. Числа Фибоначчи и оператор цикла while....................................................................... §6.8. Вложенные операторы цикла и двумерные таблицы...................................................... §6.9. Классификация операторов цикла.................................................................................... §6.10. Управляющие структуры................................................................................................. Глава 7. Строки.............................................................................................................................. §7.1. Оператор индексирования................................................................................................. §7.2. Длина строки и отрицательные индексы......................................................................... §7.3. Перебор и цикл for.............................................................................................................. §7.4. Срезы строк......................................................................................................................... §7.5. Сравнение строк.................................................................................................................. §7.6. Строки нельзя изменить..................................................................................................... §7.7. Функция find........................................................................................................................ §7.8. Циклы и счётчики............................................................................................................... §7.9. Модуль string....................................................................................................................... §7.10. Классификация символов................................................................................................ §7.11. Строки unicode.................................................................................................................. Глава 8. Списки.............................................................................................................................. §8.1. Создание списков................................................................................................................ §8.2. Доступ к элементам списка................................................................................................ §8.3. Длина списка....................................................................................................................... §8.4. Принадлежность списку..................................................................................................... §8.5. Списки и цикл for............................................................................................................... §8.6. Операции над списками..................................................................................................... §8.7. Срезы списков..................................................................................................................... §8.8. Изменение списков............................................................................................................. §8.9. Удаление элементов списка............................................................................................... §8.10. Объекты и значения.......................................................................................................... §8.11. Ссылки на объекты........................................................................................................... §8.12. Копирование списков....................................................................................................... Ревизия: 170 Содержание §8.13. Списки-параметры............................................................................................................ §8.14. Вложенные списки............................................................................................................ §8.15. Матрицы............................................................................................................................ §8.16. Списки и строки................................................................................................................ Глава 9. Кортежи............................................................................................................................ Глава 10. Словари.......................................................................................................................... §10.1. Создание словаря.............................................................................................................. §10.2. Операции над словарями................................................................................................. §10.3. Методы словарей.............................................................................................................. §10.4. Использование псевдонимов и копирование................................................................. §10.5. Разряженные матрицы...................................................................................................... §10.6. Подсказки.......................................................................................................................... §10.7. Тип «длинное целое число»............................................................................................. §10.8. Подсчет букв..................................................................................................................... Глава 11. Файлы и обработка исключений............................................................................... Глава 12. Классы и объекты......................................................................................................... Глава 13. Классы и функции........................................................................................................ Глава 14. Методы........................................................................................................................... Глава 15. Наборы объектов.......................................................................................................... Глава 16. Наследование................................................................................................................. Глава 17. Связные списки............................................................................................................ Глава 18. Стеки............................................................................................................................. Глава 19. Очереди и очереди с приоритетами........................................................................ Глава 20. Деревья......................................................................................................................... Глава 21. Функциональное программирование..................................................................... Заключение. С высоты птичьего полета................................................................................. Приложение A. Советы по отладке программ........................................................................ Приложение B. Создание и использование модулей............................................................. Приложение C. Создание типов данных.................................................................................. Приложение D. Написание программ с графическим интерфейсом................................. Приложение E. Методологии командной разработки........................................................... Приложение F. Методические указания преподавателям................................................... Ревизия: 170 Предисловие Предисловие Все началось с того, что летом 2002 года я окончательно разочаровался в языке php, на котором в то время довольно много писал. Специализировался я на веб-программировании, поэтому выбор инструмента был в общем-то логичным, но при разработке крупных проектов php показывал себя далеко не с лучшей стороны: сказывалось отсутствие средств каскадной обработки исключений, множественного наследования и пространств имен.

Короче, php меня не устраивал и по практическим соображениям, и с точки зрения идеологии. Как говорится, ничто так не ограничивает полет мысли программиста, как компилятор/интерпретатор.

Я начал искать альтернативу php. До php мне приходилось работать с языком perl, который меня не устраивал по тем же причинам. C++ тоже не самый удобный язык для разработки web-приложений, т.к. стоимость владения такими приложениями довольно велика. И вот я наткнулся на Питон (Python, http://python.org).

Идею использования Питона подхватил Дмитрий Бречалов, мой знакомый, с которым мы очень продуктивно переписывались и обменивались книгами. Он довольно быстро освоил Питон и умудрялся писать на нем даже для своего «наладонника» Psion. Он же прислал мне по электронной почте ссылку на сайт проекта «How to think like a computer scientist. Learning with Python» (http://greenteapress.com/thinkpython/). Книгу я прочитал на одном дыхании, меня поразил способ подачи материала. Например, понятие рекурсии в этой книге вводится раньше синтаксических конструкций, реализующих циклы, причем очень понятно и элегантно. В школьных же программах рекурсивные алгоритмы обычно выносятся в разряд олимпиадных задач.

Окончательным толчком послужило то, что я начал преподавать компьютерные курсы в фонде «Интеллект-клуб» для детей в возрасте от 9 до 13 лет. Эксперименты с паскалем были неудовлетворительными, т.к. приходилось отвлекаться на тонкости реализации типов и различные ограничения, присущие этому языку, отвлекаясь от сути программирования.

Использовать C++ я даже не пытался, т.к. он еще сложнее. На помощь опять пришел Питон.

Хотелось бы поблагодарить исполнительного директора фонда, Репях Андрея, который предоставил мне полную свободу, поощряя мои эксперименты.

Для того чтобы быть уверенным, что ничего не упустил, я попробовал другой язык – Ruby (сайт проекта http://ruby-lang.org/en/), но вскоре вернулся к Питону. Ruby, как и perl, изобилует конструкциями, которые способны читать только «гуру», что совсем не помогает начинающим программистам. Да и в плане количества модулей Питон его пока превосходит.

Чтобы дети могли заниматься самостоятельно, я решил перевести книгу «How to think like a computer scientist». Но в процессе перевода у меня постоянно возникало желание дополнить ее своими собственными идеями, переставить местами главы, чтобы изложение материала было более логичным. Более того, я обнаружил множество спорных моментов. В конечном итоге я взялся за свою собственную книгу, основанную на «How to think like a computer scientist», но с дополнениями и исправлениями. Можно сказать, что это русскоязычная редакция или ответвление от проекта.

Книга получилась немного сложнее, чем планировалось: в целом она соотвествует уровню старших классов и начальных курсов ВУЗов, но и младшеклассники при поддержке преподавателя тоже смогут без особого труда освоить материал книги.

Данная книга распространяется по лицензии OPL (http://www.opencontent.org/openpub/) с ограничением VI-B. Это означает, что текст данной книги может использоваться свободно в любых целях, за исключением коммерческих.

Ревизия: 170 Предисловие Разумеется, некоммерческие копии должны распространяться вместе с лицензией и без изменения авторства книги. В остальном Вам предоставляется полная свобода. Take it. Use it.

:) Ревизия: 170 Благодарности Благодарности Данная книга распространяется так же свободно, как и устная речь. Поэтому она так же свободно развивается, без ограничений какими-либо лицензиями, кроме OPL. Эта книга появилась во многом благодаря вкладу людей, перечисленных в данном списке:

• Шляков Дмитрий • Рудских Вячеслав • Волошин Евгений • Бельченко Александр • Бречалов Дмитрий • Откидач Денис • Олищук Андрей • Чуранов Михаил • Пушилин Сергей • Литвинова Елена • Липанин Антон • Жуков Борис Большое спасибо энтузиастам движения свободного программного обеспечения (http://opensource.org/), живущим по всему миру, за то, что они делают.

Отдельная благодарность проектной команде открытого офисного пакета OpenOffice.org (http://OpenOffice.org/, http://OpenOffice.ru/) за хороший продукт, в котором и была написана эта книга.

Ревизия: 170 Введение Введение В школе учительница спрашивает учеников, кем работают их родители. Руку тянет девочка:

– У меня папа доктор.

– Это хорошая профессия, – говорит учительница.

– А у меня папа водитель, – хвастается один из мальчишек.

– Какая интересная профессия. А чем твой папа занимается? – спрашивает учительница Вовочку, на что тот невозмутимо отвечает:

– Он в борделе на пианино играет.

Учительница в шоке;

в тот же день она идет к Вовочке домой и возмущенно говорит отцу:

– Как вы можете в таких условиях воспитывать ребенка?! Вы действительно играете на пианино в борделе?!

Папа Вовочки смущенно:

– Видите ли, я программист. Специализируюсь на сетях TCP/IP, пишу распределенные сетевые приложения для операционных систем UNIX, но как это объяснить семилетнему мальчугану?

Профессия программиста (да и любого другого компьютерного специалиста) со стороны, быть может, выглядит несколько загадочно. «Чем эти люди занимаются? Сидят целыми днями у компьютера и рассказывают друг другу странные анекдоты» – еще недавно так рассуждало большинство. Но на сегодняшний день информационные технологии проникли практически во все сферы деятельности человека: от таких уже привычных вещей, как мобильные телефоны, до космических технологий. Компьютеры упрощают работу с документами и помогают оптимизировать бизнес-процессы. Благодаря ничем не приметным людям, просиживающим за компьютером ночи напролет, мы можем общаться в реальном времени с друзьями и бизнес-партнерами, находящимися в любой точке мира с помощью интернета. Дзен-буддисты говорят: «Работы мастера не видно».

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

Отдельный наиболее важный навык компьютерного специалиста – умение решать задачи. Этот навык подразумевает способность их формулировать, творчески подходить к поиску возможных решений и четко излагать выбранный вариант. Как оказывается, процесс обучения программированию является прекрасной возможностью выработать все эти умения.

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

Ревизия: 170 Введение Рекомендуется ознакомиться с ним прежде, чем переходить к изучению первой главы, чтобы у вас не возникало проблем в процессе освоения материала книги. Но не забывайте, что главное – это желание учиться, умение задавать вопросы и искать на них ответы.

§0.1. Базовые знания Для того, чтобы освоить материал данной книги, от вас потребуются базовые навыки работы с компьютером, а именно:

• Работа с файлами и папками (директориями);

• Запуск программ;

• Редактирование текстовых файлов;

• Если у вас на компьютере установлена UNIX-система, то будет очень полезно уметь работать в консоли;

• Работа в интернете – там можно найти много полезной информации;

• Очень пригодится хотя бы базовое знание английского языка.

Имейте ввиду, что офисные пакеты (MS Office, OpenOffice.org, StarOffice и им подобные) в программировании вам не помогут. Программы набираются в простых текстовых редакторах типа MS Notepad (он же Блокнот).

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

Неважно, какая операционная система установлена у вас на компьютере – Питон имеет реализации под все самые распространенные платформы: Windows, UNIX (GNU/Linux, FreeBSD и др.) и даже для Mac OS X. Более того, программы, написанные в одной операционной системе, будут успешно выполняться в любой другой при наличии установленного интерпретатора Питона!

Питон входит в комплект поставки большинства дистрибутивов GNU/Linux, но не факт, что это последняя версия. Поэтому стоит все-таки заглянуть на страницу Питона и ознакомиться с новостями. Питон, как и большинство проектов сообщества open source, развивается очень динамично. Настоятельно рекомендуем пользоваться интерпретатором Питона версии 2.3.3 или выше – в этом релизе были исправлены ошибки, которые затрудняли написание неанглоязычных программ.

Теперь рассмотрим более подробно процесс установки интерпретатора Питона в различных операционных системах.

§0.2. Где достать интерпретатор языка Питон?

Интерпретатор языка Питон распространяется свободно на основании лицензии Python Software Foundation (PSF) Licence (http://python.org/psf/license.html), которая, в некотором роде, даже более демократична, чем GNU GPL (GNU General Public License:

http://gnu.org/copyleft/). Официальный сайт проекта языка Питон располагается по адресу http://python.org/. Здесь же в разделе «Downloads» можно скачать свежую версию для вашей операционной системы. Для UNIX-подобных систем дистрибутив интерпретатора имеется в двух вариантах: в исходных кодах (архив.tar.gz), в виде rpm-пакета (.rpm,.src.rpm, собранных для вашего дистрибутива) или пакета.deb (для дистрибутива Debian Linux). Для ОС Windows скачайте exe-файл, в котором упакованы сам интерпретатор и программа установки.

Ревизия: 170 Введение §0.3. Установка интерпретатора языка Питон в UNIX Во всех UNIX-подобных операционных системах (любые BSD-системы, GNU/Linux, Solaris и др.) процесс установки будет в целом одинаковым. В дистрибутивах GNU/Linux, поддерживающих систему управления пакетов RPM, помимо стандартного для UNIX процесса установки из исходных текстов, можно установить Питон и из rpm-пакета. Причем в RPM-based дистрибутивах GNU/Linux (RedHat Linux, Mandrake, SuSE Linux, ASPLinux, ALTLinux) рекомендуется устанавливать Питон именно из rpm.

Скачайте дистрибутив Питона и установите его соответствующим образом. Для этого Вам потребуются права суперпользователя (root). Если у вас нет пароля суперпользователя, то, очевидно, Вам стоит попросить помочь системного администратора, обслуживающего Ваш компьютер.

§0.3.1. Установка/обновление Питона из rpm-пакета Если вы вошли в систему в качестве непривилегированного пользователя, то перейдите в режим суперпользователя:

$ su Password:

# Затем перейдите в папку, к которой находится rpm-пакет и наберите команду (с учетом того, какую именно версию Питона вы скачали):

# rpm -i python-x.x.rpm §0.3.2. Установка Питона из исходного кода Распакуйте исходный код из скачанного архива:

$ gzip -cd python-x.x.tar.gz | tar xvf Перейдите в папку, в которую был распакован дистрибутив и выполните команду:

$./configure Затем следует запустить процесс сборки Питона:

$ make После его завершения необходимо перейти в режим суперпользователя и выполнить команду make install:

$ su Password:

# make install Вообщем-то, здесь нет никаких отличий от стандартной для UNIX-подобных операционных систем установки из исходного кода. В большинстве систем сборку программного обеспечения рекомендуется производить в папке /usr/local/src/.

Ревизия: 170 Введение §0.4. Установка Питона в ОС Windows Установка Питона в ОС Windows более проста, чем в UNIX. Достаточно скачать установочный файл (например, Python-2.3.3.exe), запустить его на своей машине и ответить на все вопросы программы установки, завершая ответ нажатием кнопки «Next».

Сначала необходимо указать куда интерпретатор должен быть установлен. По умолчанию он ставится в каталог C:\PythonXX, где XX – номер версии. На этом шаге достаточно нажать кнопку «Next».

Далее программа спросит, нужно ли сохранять резервные копии заменяемых файлов.

Если вы ставите Питон впервые, то отметьте вариант «No, do not make backups».

Следующий шаг – выбор устанавливаемых компонентов. Лучше включить установку всего, что предлагается (в том числе, документацию). Полный комплект занимает на жестком диске порядка 20 мегабайт.

Наконец, нужно задать название группы для главного меню. Можно просто нажать «Next» Программа покажет сводную информацию о том что и куда будет установлено. Еще раз нажмите «Next» и дожидайтесь окончания установки. Нажмите «Finish» для выхода из программы установки.

§0.5. Запуск программ, написанных на Питоне Для того, чтобы запустить программу, написанную на Питоне, в UNIX-системах необходимо вызвать интерпретатор Питона и передать ему в качестве параметра название файла, в котором находится запускаемая программа:

$ python my_program.py Кроме того, в операционных системах UNIX есть возможность в программе указать, какой интерпретатор необходимо вызвать для ее выполнения. Для этого в первой строке программы можно написать:

#! /usr/bin/env python Затем нужно сделать файл со скриптом исполняемым:

$ chmod u+x my_program.py После этого скрипт можно будет выполнять, просто набрав в командной строке его имя:

$ my_program.py или, если первый вариант не работает:

$./my_program.py Последовательность символов #! программисты обычно читают как «she-bang!».

В ОС Windows программы, написанные на Питоне запускаются привычным способом – найдите при помощи Проводника файл, содержащий программу, и дважды щелкните на его иконке левой кнопкой мыши. Питон при установке связывает расширение файла.py с интерпретатором Питона, поэтому при двойном щелчке на таком файле будет запущен Питон, который выполнит программу, записанную в файле. Если Ваша программа не имеет графического интерфейса, то операционная система Windows откроет окно консоли. После завершения работы программы это окно будет сразу же закрыто, поэтому вы можете не Ревизия: 170 Введение успеть увидеть результат ее работы. Избежать этого можно, добавив в конце программы следующую строку:

raw_input("Press any key to exit") Это заставит интерпретатор дождаться нажатия любой клавиши, прежде чем завершить программу.

Если же вы задали другое расширение, то метод запуска двойным щелчком не сработает. В Windows программы на Питоне всегда должны иметь расширение.py или.

pyw. Второй вариант отличается тем, что Питон запускается «молча», то есть без открытия окна консоли. Расширение.pyw рекомендуется давать программам, имеющими графический интерфейс, которые не нуждаются в окне консоли вообще.

Другой вариант – это открыть окно сеанса MS-DOS (или запустить FAR) и выполнить следующую команду:

C:\Examples> python my_program.py Этой командой мы запускаем интерпретатор Питона и указываем ему, программу из какого файла он должен выполнить.

§0.6. Среда разработки В стандартный комплект поставки Питона входит интегрированная среда разработки IDLE, в которой редактировать программы будет намного удобнее, чем в простом текстовом редакторе. IDLE написан на Питоне с использованием платформонезависимой библиотеки Tcl, поэтому легко запускается в любой операционной системе, для которой существует реализация Питона. IDLE так же имеет встроенную систему отладки, позволяющую запускать программу построчно, что облегчает процесс поиска ошибок. Если по какой-то причине IDLE Вас не устраивает, то можете попробовать другие среды разработки.

В UNIX-системах есть множество редакторов, имеющих свои прелести и недостатки, как консольные редакторы (vi, emacs, встроенный редактор mc), так и графические (vim, emacs, kate, редактор IDLE и др.).

Самым простым выбором может стать Kate – он входит в комплект поставки оконной среды KDE последних версий. Kate умеет подсвечивать синтаксические конструкции программы, имеет встроенный эмулятор консоли и специальный модуль, облегчающий работу с программами, написанными на Питоне: браузер кода, который включается через меню «Настройка» в разделе «Приложение Модули».

Еще один интересный редактор: SciTE (http://scintilla.org/SciTE.html). Помимо подсветки он умеет «схлопывать» блоки текста, что очень облегчает работу при работе с большими программами, но не имеет браузера кода (по крайней мере в стандартном комплекте поставки), кроме того, SciTE еще необходимо русифицировать, что может вызвать некоторые затруднения у начинающих.

Для программирования на Питоне в ОС Windows также существует несколько хороших редакторов и сред, кроме IDLE.

Во-первых, это PythonWin – очень хорошая среда разработки на Питоне для Windows (ее можно скачать с сайта http://pywin32.sf.net). PythonWin отличается отсутствием проблем с русскими символами, удобной средой программирования и интеграцией с операционной системой.

Ревизия: 170 Введение Можно также порекомендовать редактор UniRed (скачать его можно с сайта http://www.esperanto.mv.ru/UniRed/RUS/index.html). Это отличный текстовый редактор для ОС Windows 95/98/NT/2000/XP, «понимающий» как синтаксис Питона, так и все возможные кодировки (в том числе все кириллические и все кодировки семейства Unicode).

Наконец, для разработки и запуска программ очень пригодится файловый менеджер FAR. Тот, кто работал с Norton или Volkov Commander, прекрасно разберется и с FAR'ом.

Встроенный редактор понимает обе русские кодировки, применяемые в Windows, а сам менеджер гораздо удобнее для запуска консольных программ, чем стандартное окно DOS. В ОС Windows FAR, пожалуй, является наиболее подходящей средой для запуска программ на Питоне.

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

Ревизия: 170 Базовые понятия Глава 1. Базовые понятия Для начала придется разобраться с некоторыми базовыми понятиями. Не стоит их заучивать – достаточно их понять хотя бы на интуитивном уровне. Позднее вы начнете использовать их на практике, и все встанет на свои места. Это, пожалуй, одна из самых утомительных частей книги.

§1.1. Алгоритмы и программы Понятие алгоритма является одним их центральных понятий всей компьютерной дисциплины. Слово «алгоритм», в сущности, является синонимом слов «способ» или «рецепт». Можно говорить, в этом смысле, об алгоритме нахождения корней уравнения по его коэффициентам, или об алгоритме разложения натурального числа на простые множители. Если в основе алгоритмов лежат простые вычисления, то такие алгоритмы называют численными. Впрочем, довольно часто рассматриваются и нечисленные алгоритмы. Например, в роли исходных данных и результатов могут выступать последовательности символов: тексты, формулы и т.д. В роли операций – не привычные операции сложения, умножения и подобные им, а операции сцепления строк или операции замены одних символов на другие по некоторой таблице соответствий. Примером может служить кодирование текста азбукой Морзе. Существуют алгоритмы построения сложных графических объектов и их преобразования. Для того, чтобы научить компьютер что-то делать, нужно предварительно составить алгоритм.

Алгоритм – это описанный со всеми подробностями способ получения результатов, удовлетворяющих поставленным условиям, по исходным данным.

Программа – это последовательность машинных инструкций, описывающая алгоритм.

Разумеется, для того, чтобы написать программу, нужно придумать алгоритм.

Компьютерные программы обычно составляются на специальных языках программирования.

§1.2. Языки программирования и уровни абстракции Существует несколько подходов к программированию. Изначально вычисления описывались на уровне машинных команд в двоичном коде. Логику подобных программ было довольно трудно уловить из-за того, что программисту приходилось уделять внимание таким вопросам, как, например, сколько ячеек памяти необходимо выделить для хранения того или иного значения. Для сложения двух чисел необходимо было предварительно вычислить адреса ячеек памяти, в которых хранились складываемые значения, и только после этого произвести операцию сложения двоичных чисел. Такой подход к программированию иногда называют адресным.

Прочесть и разобраться, как работает программа, написанная в двоичных кодах, было очень сложно, не говоря уже о том, чтобы найти и исправить в ней ошибку. Поэтому для упрощения своей работы программисты придумали мнемокоды (от греч. Mnemonikos mnemon – запомнить) или мнемоники – буквенные обозначения машинных двоичных команд, которые проще запомнить, чем последовательности нулей и единиц. Для упрощения работы с ячейками памяти стали использовать понятие переменной.

Переменная – в программировании это буквенное обозначение области памяти, в которой хранится некоторое значение.

Ревизия: 170 Базовые понятия Для перевода мнемокодов в машинные инструкции и имен переменных в адреса ячеек памяти использовалась специальная программа – транслятор. Языки мнемо-кодов получили название ассемблеров.

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

• Ввод данных с клавиатуры, из файла или с какого-либо устройства;

• Вывод данных на экран, в файл, на принтер или другое устройство;

• Выполнение некоторых операций над числами, строками или другими объектами;

• Выбор ветви выполнения программы на основе принятого решения (например, по результатам сравнения двух значений);

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

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

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

1.Занести в регистр edx адрес первого числа Занести в регистр-счетчик Занести в регистр eax Метка lp:

Сравнить значение регистра eax со значением, хранящимся по адресу взятому из регистра edx Если оно меньше или равно, то перейти к метке l_next Занести в регистр eax значение из ячейки, адрес которой хранится в edx Метка l_next:

Прибавить к значению регистра edx Если в регистре-счетчике не 0, то уменьшить значение в регистре счетчике на 1 и перейти к метке lp Записать в переменную Max значение из регистра eax 2.Занести в переменную Max Повторять пока переменная i изменяется от 1 до 10 с шагом +1:

Если i-е число больше Max, то занести его в переменную Max Вывести значение переменной Max.

Ревизия: 170 Базовые понятия Обе программы находят максимальное из десяти заданных натуральных чисел.

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

Чаще всего программы, написанные на языках высокого уровня работают медленнее, т.к. трансляторы строят не самый оптимальный машинный код по тексту программы. Но зато языки высокого уровня обладают многими преимуществами: их легче читать и понимать, кроме того, они имеют свойство переносимости. Это означает то, что высокоуровневые программы могут выполняться на различных типах компьютеров или под управлением различных операционных систем, причем с минимальными изменениями или вовсе без таковых, в то время как низкоуровневые программы обычно пишутся под определенный тип компьютеров или операционную систему, и для переноса таких программ на другую платформу их приходится переписывать.

Обратите внимание на то, что в первой программе результат не выводится. Способ вывода в низкоуровневой программе будет разным в зависимости от платформы, на которой будет выполняться данная программа. Более того, на процессоре Intel 80286 эта программа работать тоже не сможет, т.к. регистры edx и eax появились только в Intel 80386.

Классическими структурными языками являются C1 и Pascal. Они позволяют описывать вычислительные процессы на более высоком уровне абстракции, чем ассемблеры, но, тем не менее, им присущ ряд недостатков. В частности, программисту, пишущему на этих языках, все же приходится явно указывать тип переменных, с которыми будут работать его программы, для того, чтобы транслятор знал, сколько памяти выделять под их хранение.

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

В последнее время стали приобретать популярность так называемые языки очень высокого уровня. Они позволяют абстрагироваться от типов переменных, что открывает новые возможности. С ними мы познакомимся в процессе изучения языка Python, который является одним из представителей этой группы языков программирования.

§1.3. Формальные и естественные языки Разберемся, чем языки программирования отличаются от нашего родного языка, на котором мы разговариваем с детства. Существует два вида языков: естественные и формальные.

К естественным относятся языки, на которых разговаривают люди: русский, английский, французский, арабский и другие. Скорее всего, они возникли естественным путем, когда в древности люди пытались друг другу что-то объяснить. Все они довольно сложные, хотя мы часто этого просто не замечаем. Для того чтобы упростить изучение иностранных языков, люди придумали правила и словари, в которых словам одного языка приводятся соответствия из других языков. Самыми сложным естественным языком считается санскрит: первый сборник правил санскрита (грамматика Панини, называемая «Восьмикнижие», IV век до н.э.) содержал более 4000 грамматических правил. В санскрите падежей, 3 числа в именах, несколько сотен глагольных и отглагольных форм, имеются средства свободного образования многочисленных производных слов. Кроме того, в санскрите можно найти до нескольких десятков слов, символизирующих один и тот же объект, но отражающих различные смысловые оттенки, поэтому его выразительные возможности чаще всего превосходят средние потребности.

1 Читается как «си».

Ревизия: 170 Базовые понятия Один из самых простых языков, на которых можно разговаривать, это эсперанто.

Эсперанто придумал врач-офтальмолог Лазарь (Людовик) Маркович Заменгоф в XIX веке.

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

У Заменгофа были отличные способности к языкам, и еще школьником кроме родных русского, польского и идиша он изучил немецкий, французский, английский, латынь, древнегреческий, древнееврейский – всего около четырнадцати языков. Вскоре он убедился, что ни древние, ни современные языки не годятся в качестве общего. Тогда он задумал создать новый язык, который не принадлежал бы ни одному народу, был бы легок для изучения, но в то же время не уступал бы национальным языкам в гибкости и выразитель ности. И это ему удалось – вся грамматика эсперанто (вместе с фонетическими правилами) умещается на двух печатных страницах, все слова международные, а по выразительности эсперанто не уступает (и в чем-то даже превосходит) русский. Esperanto estas tre interesa kaj esprima lingvo.

Можно ли эсперанто назвать естественным языком? Пожалуй, нет. Несмотря на то, что он живет своей жизнью и развивается естественным путем, грамматика эсперанто по прежнему жестко формализована. Поэтому он, скорее, относится к формальным языкам.

Формальными называют языки, придуманные людьми для решения специфических задач. Например, набор специальных знаков и правил записи формул, используемых математиками для записи формул и доказательств теорем, является формальным языком.

Химики так же используют свой формальный язык для записи химической структуры веществ. Языки программирования – формальные языки, предназначенные для описания алгоритмов.

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

Например, 3+3=6 является синтаксически правильной математической записью, а 3=+6$ – нет. H2O – синтаксически правильная химическая формула вещества, а 2Zz – нет.

Когда вы читаете предложение на русском языке или выражение на формальном языке, вы определяете его структуру, часто неосознанно. Этот процесс называется синтаксическим анализом или синтаксическим разбором. Эквивалентный англоязычный термин – parsing.

Например, когда вы читаете фразу «Мама мыла раму», вы по пробелам определяете начало и конец слов и только после этого находите подлежащее («мама») и сказуемое («мыла»). Разобрав синтаксическую структуру, вы можете понять ее смысл – семантику.

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

Использование символа $ в формуле 3=+6$ не имеет смысла, и это является одной из причин, почему оно неверно с точки зрения математики. Та же проблема в «химической» формуле Zz: в таблице Менделеева нет элемента с обозначением Zz.

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

последовательностью следования символов. Выражение 3=+6$ имеет неверную структуру, т.к. сразу после знака равенства не может следовать знак сложения. Аналогично, в молекулярных формулах используются нижние индексы, но они не могут идти перед обозначением химического элемента.

Ревизия: 170 Базовые понятия Хотя формальные и естественные языки имеют много общего, они имеют ряд важных отличий:

1. Однозначность В естественных языках множество идиом и метафор;

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

2. Избыточность Для того чтобы избавиться от неоднозначности и избежать недопониманий в естественных языках используется избыточность: определения и дополнения.

Формальные языки краткие и максимально выразительные.

Большинство людей, привыкших к естественным языкам, обычно с трудом привыкают к формальным языкам (и программам в том числе). Но стоит помнить, что плотность смысла в таких языках больше, поэтому они медленнее читаются и понимаются. В формальных языках очень важна структура, поэтому чтение справа налево или снизу вверх – не лучший способ их понять. И, наконец, мелочи важны. Маленькие орфографические и пунктуационные ошибки (и опечатки тоже), которые в естественных языках могут быть проигнорированы, в формальных языках будут иметь большое значение, вплоть до изменения смысла на противоположное.

В математике есть целый раздел, посвященный теории формальных языков. Именно на математическом аппарате этой теории основаны синтаксические анализаторы трансляторов.

§1.4. Интерпретаторы и компиляторы Существует два типа трансляторов, преобразовывающих исходный код программ в машинные команды: интерпретаторы и компиляторы. Интерпретатор читает высоко уровневую программу (или исходный код) и, напрямую взаимодействуя с операционной системой, выполняет ее. Преобразование и выполнение программы выполняется построчно.

Результат Исходный Операционная Интерпретатор выполнения код система программы В отличие от интерпретаторов, компиляторы полностью преобразовывает исходный код программы в машинный код (или так называемый объектный код), который операционная система может выполнить самостоятельно. Это позволяет выполнять скомпилированные программы даже на тех компьютерах, на которых нет компилятора.

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

Объектный Результат Исходный Операционная Компилятор (исполняемый) выполнения код система код программы Впрочем, современные интерпретаторы тоже способны сохранять промежуточный код, на выполнение которого затрачивается меньше времени за счет экономии на синтаксическом разборе исходного кода. Тем не менее, такой промежуточный код понятен Ревизия: 170 Базовые понятия только интерпретатору, поэтому для запуска программы его наличие на компьютере все равно необходимо.

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

Язык Питон является интерпретируемым, т.к. написанные на нем программы выполняет интерпретатор.

Для Windows-версии Питона существует любопытный проект: py2exe, позволяющий создавать независимые exe-файлы из скриптов.

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

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

Однако, полученный исполняемый файл может работать только под операционной системой Windows. Если ваша программа предназначена для выполнения только в этой системе и вы не хотите требовать от пользователей непременной установки Питона, то py2exe может оказаться весьма полезным инструментом.

Получить дополнительную информацию и скачать py2exe можно здесь:

http://starship.python.net/crew/theller/py2exe/. Там же можно найти ссылки на другие аналогичные проекты.

§1.5. Первая программа Настало время запустить интерпретатор Питона и написать первую программу.

Существует два способа использования интерпретатора: командный режим и режим выполнения программ из файлов. Если в командной строке интерпретатора Питона вы наберете команду, то интерпретатор тут же выведет результат ее выполнения:

$ python Python 2.3+ (#1, Sep 23 2003, 23:07:16) [GCC 3.3.1 (SuSE Linux)] on linux Type "help", "copyright", "credits" or "license" for more information.

>>> print "Hello world!" Hello world!

Первая строка примера – команда, которая запускает интерпретатор Питона в операционной системе UNIX. В операционной системе Windows для вызова интерпретатора достаточно в меню «Пуск Программы» вызвать среду разработки IDLE. Следующие две строки – информация от интерпретатора (номер версии, авторские права – так он 2 Компилируемые языки пока незаменимы в системах реального времени, в которых даже малейшая задержка может повлечь за собой катастрофу (например, такие системы используются для управления маневрами космических кораблей и протеканием сложных физических процессов в лабораторных и производственных условиях).

Ревизия: 170 Базовые понятия представляется). Четвертая начинается с приглашения интерпретатора >>>, которое обозначает, что он готов выполнять команды. Мы набрали команду print "Hello world!", т.е. дали указание вывести на экран строку "Hello world!", и в следующей строке интерпретатор вывел то, что мы просили.

Мы также можем записать программу в файл и использовать интерпретатор для того, чтобы ее выполнить. Такой файл называют сценарием или скриптом (от англ. script – сценарий). Например, используя текстовый редактор, создадим файл prog1.py со следующим содержанием:

print "Hello world!" Названия файлов, содержащих программы на Питоне, принято завершать последовательностью символов.py (те, кто работают в операционных системах DOS или Windows, назовут это расширением). Для того чтобы выполнить программу, мы должны передать интерпретатору в качестве параметра название скрипта:

$ python prog1.py Hello world!

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

Упражнение. Попробуйте изменить свою первую программу так, чтобы в ней появились синтаксические ошибки: сначала ошибка, связанная с нераспознанной синтаксической единицей (т.е. непонятным словом), а затем – с неправильной структурой программы (можно попробовать поменять местами синтаксические единицы).

Поэкспериментируйте.

§1.6. Что такое отладка?

Программирование – довольно сложный процесс, и вполне естественно, когда программист допускает ошибку. Так повелось, что программные ошибки называют «багами» (от англ. bug – жучок). В русскоязычной литературе это слово вы не встретите, но в сленге программистов оно используется достаточно часто наряду со словом «глюк». Процесс поиска и устранения ошибок в англоязычной литературе принято обозначать термином debugging, мы же будем называть его отладкой.

Существует три типа ошибок, которые могут возникнуть в программах:

синтаксические ошибки (syntax errors), ошибки выполнения (runtime errors) и семантические ошибки (semantic errors). Чтобы находить и исправлять их быстрее, имеет смысл научиться их различать.

§1.6.1. Синтаксические ошибки (syntax errors) Любой интерпретатор сможет выполнить программу только в том случае, если программа синтаксически правильна. Соответственно компилятор тоже не сможет преобразовать программу в машинные инструкции, если программа содержит синтаксические ошибки. Когда транслятор находит ошибку (т.е. доходит до инструкции, которую не может понять), он прерывает свою работу и выводит сообщение об ошибке.

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

Даже если в вашей программе Питон найдет хотя бы незначительную опечатку, он тут же выведет сообщение о том, где он на нее наткнулся, и завершит работу. Такую программу он не сможет выполнить и поэтому отвергнет. В первые недели вашей практики разработки программ вы, скорее всего, проведете довольно много времени, разыскивая синтаксические ошибки. По мере накопления опыта вы будет допускать их все реже, а находить – все быстрее.

§1.6.2. Ошибки выполнения (runtime errors) Второй тип ошибок обычно возникает во время выполнения программы (их принято называть исключительными ситуациями или, коротко – исключениями, по-английски exceptions). Такие ошибки имеют другую причину. Если в программе возникает исключение, то это означает, что по ходу выполнения произошло что-то непредвиденное: например, программе было передано некорректное значение, или программа попыталась разделить какое-то значение на ноль, что недопустимо с точки зрения дискретной математики. Если операционная система присылает запрос на немедленное завершение программы, то также возникает исключение. Но в простых программах это достаточно редкое явление, поэтому, возможно, с ними вы столкнетесь не сразу.

§1.6.3. Семантические ошибки (semantic errors) Третий тип ошибок – семантические ошибки. Первым признаком наличия в вашей программе семантической ошибки является то, что она выполняется успешно, т.е. без исключительных ситуаций, но делает не то, что вы от нее ожидаете.

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

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

§1.6.4. Процесс отладки Старый глюк лучше новых двух.

Народная программерская поговорка Умение отлаживать программы для программиста является очень важным навыком.

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

Отладка очень напоминает работу естествоиспытателя. Изучая результаты своего предыдущего эксперимента, вы делаете некоторые выводы, затем в соответствии с ними изменяете программу, запускаете ее, и снова приступаете к анализу полученных результатов.

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

Поэтому для проверки работоспособности программы не достаточно проверить ее один раз – нужно придумать все возможные наборы входных данных, которые могут как-то Ревизия: 170 Базовые понятия повлиять на устойчивость вашей системы. Такие наборы входных данных называют граничными значениями.

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

Ядро Linux, исходный код которого содержит миллионы строк, начиналась с простой программы, с помощью которой Линус Торвальдс (Linus Torvalds) изучал возможности параллельного выполнения задач на процессоре Intel 80386. «Одной из ранних программ Линуса была программа, которая переключалась между двумя процессами: печатанием последовательностей AAAA и BBBB. Позже эта программа превратилась в Linux» (Larry Greenfield, The Linux Users' Guide Beta Version 1).

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

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

В последующих главах у вас будет возможность попрактиковаться в отладке программ.

Кое-какие полезные советы по отладке вынесены в Приложение A – обязательно почитайте его когда у вас будет свободное время, желательно, ближе к концу изучения шестой главы.

Ревизия: 170 Переменные, операции и выражения Глава 2. Переменные, операции и выражения И вот, наконец, мы приступаем собственно к программированию. Можете сразу запустить интерпретатор Питона. Не повредит, если вы проверите работоспособность примеров на своем компьютере и поэкспериментируете с ними. Если найдете какую-нибудь ошибку или опечатку – пишите на pythonbook@it-arts.ru. Возможно, ваше имя появится в списке разработчиков книги.

§2.1. Значения и типы Все программы работают со значениями. Значением может быть число или строка.

Например, в первой программе мы уже печатали на экране строковое значение "Hello world!". Аналогичным образом мы можем вывести и число:

>>> print "Hello world!" и 12 принадлежат к различным типам: str (от англ. string – строка) и int (от англ. integer – целое число)3. Интерпретатор отличает строку от числа по кавычкам, в которые она заключена.

Если есть целые числа, то, по идее, должны быть и дробные. Давайте попробуем такую команду:

>>> print 2, 2 Вот и первый пример семантической ошибки: мы предполагали, что интерпретатор выведет десятичное число, но он воспринял запятую как разделитель между двумя целыми числами и вывел их, разделив пробелом. Вообщем, он нас неправильно понял, ведь разделителем дробной и целой частей числа в Питоне, как и в большинстве других языков программирования, служит точка4:

>>> print 2. 2. Если вы не уверены в том, к какому типу принадлежит значение, это можно проверить так:

>>> type("Hello world!") >>> type(12) >>> type(2.4) Строковый тип называется в Питоне str, целочисленный носит название int, а дробный – float (от англ. floating-point number – числа с плавающей точкой).

3 В некоторых версиях Питона эти типы носят несокращенные названия: string и integer.

4 Такой непривычный для нас способ разделения целой и дробной части является американским стандартом записи десятичных дробей.

Ревизия: 170 Переменные, операции и выражения Упражнение. Проведите самостоятельно следующий эксперимент: проверьте типы значений "12" и "2.4"? Какого они типа и почему?

Упражнение. Что произойдет, если строку "8.53" попытаться преобразовать с целое число с помошью функции int()? Как решить эту проблему?

§2.2. Преобразование типов В предыдущем разделе мы научились выводить на экран целые числа – это довольно просто делается, не так ли? Но для интерпретатора эта задача выглядит несколько сложнее, т.к. ему перед выводом числовых значений приходится преобразовывать их в строки.

Программист тоже может это делать – Питон имеет целую коллекцию встроенных функций, которые умеют преобразовывать значения одного типа в другой. Например, функция int() преобразовывает значение в целочисленный тип. Если преобразование произвести невозможно, то возникает исключение:

>>> int("32") >>> int("Hello") Traceback (most recent call last):

File "", line 1, in ?

ValueError: invalid literal for int(): Hello Функция int() может приводить к целому типу и дробные числа, но не забывайте, что при преобразовании она просто отбрасывает дробную часть:

>>> int(3.99999) >>> int(-2.3) - Функция float() преобразовывает целые числа и строки в дробный тип.

>>> float(32) 32. >>> float("3.14159") 3. И, наконец, функция str() отвечает за преобразование к строковому типу. Именно ее предварительно запускает команда print:

>>> str(32) '32' >>> str(3.14149) '3.14149' Ревизия: 170 Переменные, операции и выражения Может показаться странным, что Питон различает целое число 1 от дробного 1.0: это оно и то же число, но принадлежат к различным типам. Дело в том, что от типа значения зависит способ его хранения в памяти.

§2.3. Переменные Как любой другой язык программирования Питон поддерживает концепцию переменных, но с небольшим отличием. Если в языках C++ или Pascal переменная – это имя ячейки памяти, в которой хранится значение, то в Питоне переменная – это ссылка на ячейку памяти. Различие, на первый взгляд, несущественное, но на самом деле это немного другой подход к организации хранения объектов в памяти. Впрочем, нас пока это не особо волнует.

Для того, чтобы «запомнить» значение достаточно присвоить его переменной. Это делается с помощью специального оператора присваивания который обозначается знаком равенства (=).

>>> message = "Hello world!" >>> n = >>> pi = 3. В данном примере переменной message присваивается (или сопоставляется) значение "Hello world!", переменной n присваивается значение 12, а переменной pi – 3.14159.

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

Такие рисунки иногда называют диаграммами состояния (state diagram), т.к. они отображают состояние, в котором находится переменная, т.е. какое значение ей в данный момент присвоено.

message “Hello world!” n pi 3. Команда print работает и с переменными:

>>> print message Hello world!

>>> print n >>> print pi 3. Как видите, команда print выводит не имена переменных, а их значения. Переменные, так же как и значения, имеют тип. Давайте это проверим с помощью функции type():

>>> type(message) >>> type(n) >>> type(pi) Ревизия: 170 Переменные, операции и выражения Тип переменной совпадает с типом присвоенного ей значения. Рассмотрим еще один пример:

>>> message = "Hello world!" >>> n = >>> type(message) >>> message = n >>> print message >>> type(message) Этот пример интересен по двум причинам. Во-первых, в нем использована возможность присваивать значение одной переменной другой. Конструкция message = n работает аналогично присваиванию переменной значения: переменной message присваивается значение переменной n. При этом значение 12 хранится в памяти только один раз – Питон довольно экономно расходует память.

message “Hello world!” n Во-вторых, как видно из примера, переменная message после присваивания ей значения n поменяла свой тип. Далеко не каждый язык программирования «умеет» это делать так просто.

§2.4. Имена переменных и ключевые слова Как заметил Фредерик Брукс (Frederick P. Brooks, Jr)5, самое захватывающее в профессии программиста то, что он работает с идеей в чистом виде: он записывает абстрактные идеи с помощью формальных языков, чтобы те облегчали труд другим людям.

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

Имена переменных могут быть произвольной длины, но старайтесь выбирать не слишком короткие и не слишком длинные имена – от этого зависит читабельность программы.

При составлении имен переменных в Питоне можно использовать любые латинские буквы, цифры и знак _ (знак подчеркивания). Знак подчеркивания может использоваться для 5 Фредерик Брукс (Frederick P. Brooks, Jr) руководил знаменитым проектом IBM OS/360;

его перу принадлежит принцип No Silver Bullet (NSB – «Серебрянной пули нет», в смысле универсального средства борьбы с проектами- «монстрами»). Речь идет о его книге «Мифический человеко-месяц, или как создаются программные системы».

Ревизия: 170 Переменные, операции и выражения разделения слов составляющих имя переменной: например, user_name или full_price. Но названия переменных не могут начинаться с цифры.

>>> 1message = "Hello world!" File "", line 1message = "Hello world!" ^ SyntaxError: invalid syntax >>> price_in_$ = File "", line price_in_$ = ^ SyntaxError: invalid syntax >>> class = "Computer Science 101" File "", line class = "Computer Science 101" ^ SyntaxError: invalid syntax Разберем эти три примера. Первое же выражение интерпретатору не понравилось, и он отметил знаком ^, где именно у него возникли претензии: он указал на имя переменной 1message. Действительно, имя 1message является некорректным, ведь оно начинается с цифры. Аналогичная ситуация с именем price_in_$: оно содержит недопустимый символ $. Но что интерпретатору не нравится в третьем выражении? Давайте попробуем изменить имя переменной class на что-нибудь похожее, например, class_:

>>> class_ = "Computer Science 101" >>> print class_ Computer Science Теперь все в порядке. В чем же дело? Почему имя class вызвало ошибку, а имя class_ – нет? Какие есть предположения? Поставим еще один эксперимент:

>>> print = "Some message" File "", line print = "Some message" ^ SyntaxError: invalid syntax Знакомая ситуация, не так ли? Проанализируем то, что мы получили. В качестве имени переменной мы пытались использовать команду print и получили аналогичную ошибку, значит слово class, скорее всего, тоже является командой или каким-то служебным словом.

Действительно, слова class и print являются так называемыми ключевыми словами.

Всего в Питоне версии 2.3. зарезервировано 29 ключевых слов:

Ревизия: 170 Переменные, операции и выражения and del for is raise assert elif from lambda return break else global not try class except if or while continue exec import pass yield def finally in print Полезно иметь этот список под рукой, чтобы заглянуть в него, когда вдруг интерпретатору не понравится одно из имен переменных.

Имейте также ввиду, что интерпретатор различает большие и маленькие буквы, т.е.

message и Message будут разными переменными.

Упражнение. Напишите программу, которая подтверждает, что интерпретатор Питона различает строчные и заглавные буквы в именах переменных.

§2.5. Выражения В первой главе мы уже сталкивались с понятием выражения в общем виде и использовали их в программе. Давайте дадим определение этого термина. Выражение – это последовательность синтаксических единиц, описывающая элементарное действие на языке программирования. Например, print "Hello world!" и message = n являются выражениями.

Когда вы набираете выражение в командной строке, интерпретатор выполняет его и выводит результат, если таковой имеется. Результатом выражения print "Hello world!" является строка: Hello world!. Выражение присваивания ничего не выводит.

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

print x = print x Этот скрипт выведет следующее:

И снова выражение присваивания не порождает никакого вывода.

§2.6. Выполнение выражений По сути, выражение – это последовательность значений, переменных и операторов.

Если вы напишите выражение, то интерпретатор, выполнив его, выведет на экран:

>>> 1 + Значение само по себе рассматривается как выражение, так же как и переменная:

Ревизия: 170 Переменные, операции и выражения >>> >>> x = >>> x Но выполнение и вывод результата выполнения выражения не совсем то же самое:

>>> message = "Hello world!" >>> message "Hello world!" >>> print message Hello world!

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

В скриптах, выражения вообще ничего не выводят, если в них нет инструкции print.

Например, следующий скрипт не выводит ни одной строки:

3. "Hello, World!" 1 + Упражнение. Измените скрипт из предыдущего примера так, чтобы он вывел значения всех четырех выражений.

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

>>> 1.25 + 2. >>> print _ 2. >>> 5 + _ 7. Поэтому Питон довольно удобно использовать как простой калькулятор. В последующих разделах мы разберемся с тем, какие операции способен выполнять интерпретатор Питона.

Ревизия: 170 Переменные, операции и выражения §2.7. Операторы и операнды Операторами называют специальные символы (или последовательности символов), обозначающие некоторые операции. Например, знаком + обозначают операцию сложения, а знаком * – умножение. Значения, над которыми выполняется операция, называют операндами.

Все нижеследующие выражения, с точки зрения Питона, корректны:

20+32 hour-1 hour*60+minute minute/60 5**2 (5+9)*(15-7) Значения большинства из них понять нетрудно. Значения символов +, -, * и / в Питоне такие же, как в математике. Скобки используются для группировки операций, а двумя звездочками (**) обозначается операция возведения в степень.

Если операндом является переменная, то перед вычислением выражения производится подстановка на ее место значения, на которое указывает эта переменная.

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

>>> minute = >>> minute/ Значение переменной minute равно 59;

результат деления 59 на 60 должен быть 0.98333, а не 0. Причиной этого несоответствия является то, что Питон выполняет целочисленное деление.

Когда оба операнда – целые числа, и Питон считает, что результат тоже должен быть целым. Поэтому целочисленное деление всегда отбрасывает дробную часть.

Как получить дробный результат? Достаточно принудительно преобразовать один из операндов в дробное число:

>>> minute = >>> float(minute) / 0. Другой вариант:

>>> minute = >>> minute / 60. 0. Если один из операндов принадлежит типу float, то второй автоматически преобразовывается к этому типу, как к более сложному.

§2.8. Порядок операций Большинство языков программирования позволяют группировать в одном выражении несколько операций. Это удобно, например, если нужно посчитать процентное соотношение двух величин:

Ревизия: 170 Переменные, операции и выражения >>> print 100 * 20 / 80, "%" 25 % В этом примере рассчитывается процентное соотношение двух чисел: 20 и 80. После результата выражения выводится символ % – интерпретатор вычисляет арифметическое выражение и выводит результат, а затем дописывает строку, стоящую после запятой.

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

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

Например, 2*(3-1) равно 4, (1+1)**(5-2) – 8. Скобки удобно использовать и для того, чтобы выражения было легче читать, даже если их наличие в выражении никак не отражается на результате: (100*20)/80.

Следующий приоритет у операции возведения в степень, поэтому 2**1+1 равно 3, а не 4, и выражение 3*1**3 даст результат 3, а не 27.

Умножение и деление имеют одинаковый приоритет, более высокий, чем у операций сложения и вычитания. 2*3-1 равно 5, а не 4;

2/3-1 равно -1, а не 1 (результат целочисленного деления 2/3=0).

Операторы с одинаковым приоритетом выполняются слева направо. Так что в выражении 100*20/80 умножение выполняется первым (выражение приобретает вид 2000/80);

затем выполняется деление, выдающее в результате значение 25. Если бы операции выполнялись справа налево, то результат получился бы другим.

Упражнение. Измените выражение 100*20/80 так, чтобы последовательность выполнения операций была обратной. Какой результат вы получили после его выполнения и почему?

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

message-1 "Hello"/123 "Hello"*"world!" "15"+ Но оператор + работает со строками, хотя обозначает другую операцию: конкатенацию или сцепление строк.

>>> str1 = "Hello" >>> str2 = " world" >>> print str1 + str2 + "!" Hello world!

Обратите внимание, что вторая строка начинается с пробела. Пробел такой же символ, как и любой другой.

Оператор * тоже можно использовать по отношению к строкам, но при условии, что одним из операндов будет целое число. В этом случае оператор * символизирует операцию повторения строки (или итерацию). Например, 'Fun'*3 выдаст результат 'FunFunFun'.

Ревизия: 170 Переменные, операции и выражения Можно проследить аналогию между операциями над числами и операциями над строками: так же, как 4*3 эквивалентно 4+4+4, 'Fun'*3 эквивалентно 'Fun'+'Fun'+'Fun'.

Но с другой стороны, конкатенация и повторение имеют несколько существенных отличий от сложения и умножения.

Упражнение. Все операции в математике классифицируются по их свойствам (коммутативность, ассоциативность и т.п.). Какими свойствами, присущими сложению и умножению, не обладают конкатенация и повторение?

Не ленитесь заглянуть в математический справочник – понимание свойств объектов, которыми оперируете, даст вам большие преимущества.

Упражнение. Какой результат будет получен после выполнения выражения "hello"+" world"*3?Какие выводы можно сделать на основе этого результата?

§2.10. Композиция Напоследок разберемся еще с одной важной концепцией: композицией. Сами того не замечая, мы с нею уже сталкивались.

Весь окружающий нас мир состоит из составных частей. Например, дома состоят из кирпичей или строительных блоков, кирпичи, в свою очередь состоят из мелких крупиц песка, а те – из молекул и атомов. Для того, чтобы моделировать явления окружающего мира, инструмент построения моделей должен также иметь возможность собирать мелкие объекты в системы, которые в свою очередь будут объединяться в еще более сложные комплексы.

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

Например, мы знаем, как сложить два числа и как выводить полученное значение.

Таким образом, мы можем это сделать в одном выражении:

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

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

Рассмотрим такой пример:

>>> percentage = 100 * 20 / 80;

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

вычисление проводится в порядке, определяемом приоритетами операций. Операция деления в нашем примере в качестве первого операнда принимает результат умножения – это тоже пример вложенности выражений.

Ревизия: 170 Переменные, операции и выражения Второй вариант компоновки выражений – следование. В примере два выражения (выражение присваивания и вывода значения переменной percentage) разделены точкой с запятой. Эти выражения выполняются друг за другом. Вообще говоря, любая программа представляет собой последовательность выражений. Если выражения расположены на отдельных строках, то ставить точку с запятой в конце каждого выражения не обязательно: в данном случае разделителем выражений служит символ завершения строки. Это правило относится к Питону, но в C++ и Паскале выражения обязательно должны заканчиваться точкой с запятой.

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

Упражнение. Попробуйте выполнить в командной строке интерпретатора Питона команду: 100 * 20 / 80 = percentage. Какой результат вы получили и почему?

Ревизия: 170 Функции Глава 3. Функции §3.1. Подпрограммы Еще во времена адресного программирования было замечено, что некоторые части программы можно использовать более одного раза, если изменить значение какого-то параметра. Например, в программе может несколько раз вычисляться значение по определенной формуле, но каждый раз значения, подставляемые в формулу, меняются.

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

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

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

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

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

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

В языке Pascal подпрограммы бывают двух типов: процедуры и функции. В Питоне же, так же как и в C++, подпрограммы реализованы в более общем виде, поэтому такого разделения нет – в этих языках есть только функции.

Иногда подпрограммы группируются в так называемые модули – специальные файлы, в которых хранится описание этих функций, которые можно подключать и использовать в любой части проекта или даже в других проектах. О том как создавать и подключать модули в Питоне подробно рассказано в Приложении B. Но пока приступим к освоению функций.

Ревизия: 170 Функции §3.2. Вызовы функций С вызовами функций мы уже сталкивались, когда выполняли определение и преобразование типов значений и переменных:

>>> type("Hello world!") >>> int("32") Функция, определяющая тип значения или переменной, называется type();

преобразуемое значение или переменная должны следовать после названия функции в скобках – его называют аргументом функции. Как видно из примера, вызов функции int() осуществляется аналогичным образом.

Таким образом, для вызова функции достаточно набрать ее имя и в скобках перечислить параметры, а если передавать параметры не требуется, то в скобках можно ничего не писать. Например, в функции str() первый параметр является необязательным, т.е. его можно не указывать:

>>> str() '' §3.3. Справочная система В Питоне определено множество функций, позволяющих решать различные задачи.

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

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

Для упрощения работы программиста в Питоне предусмотрена встроенная переменная doc (начинается и заканчивается парами символов подчеркивания), в которой обычно хранится минимальная справочная информация:

>>> print str.doc str(object) -> string Return a nice string representation of the object.

If the argument is a string, the return value is the same object.

>>> Функция str() «представилась» и вывела информацию о себе: какие параметры она принимает, какого типа значение возвращает, и коротко «рассказала», что она делает.

Начиная с версии 2.2, в Питоне появилась справочная система, реализованная в виде функции help(). Данная функция в качестве параметра принимает имя любого объекта (в том числе, модуля или функции) и выводит справочную информацию о нем.

Упражнение. Ознакомьтесь со справочной информацией функции str(). Имейте ввиду, что в Питоне версий ниже 2.2 функция help() работать не будет. Выход из справочной системы осуществляется клавишей [Q].

Ревизия: 170 Функции §3.4. Импорт модулей и математические функции Помимо простейших операций над числами, которые мы уже рассматривали, Питон способен вычислять значения более сложных математических функций:

тригонометрических, логарифмических и др. Для того, чтобы получить доступ к этим функциям необходимо импортировать или подключить специальный модуль, в котором хранятся определения этих функций. Сделать это можно с помощью такой инструкции:

>>> import math >>> Данная команда импортирует модуль math. Питон поддерживает частичный импорт модулей (подробнее об этом можно прочесть в Приложении B), но нам пока это не нужно.

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

>>> dir(math) ['doc', 'file', 'name', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'sin', 'sinh', 'sqrt', 'tan', 'tanh'] >>> В результате выполнения этой команды интерпретатор вывел все имена, определенные в данном модуле. В их числе есть и переменная doc. Для того, чтобы обратиться к переменной или функции из импортированного модуля необходимо указать его имя, поставить точку и написать необходимое имя:

>>> print math.doc This module is always available. It provides access to the mathematical functions defined by the C standard.

>>> print math.pi 3. >>> decibel = math.log10(17.0) Первая строка примера выводит описание модуля;

четвертая – значение константы, а шестая – вычисляет значение логарифма 17 по основанию 10. Помимо десятичного логарифма в модуле определен и натуральный логарифм (т.е. с основанием e = 2.7182818284590451): math.log(). Еще один пример:

>>> height = math.sin(45) >>> print height 0. Если вы изучали тригонометрию, то, наверное, помните, что синус 45 градусов равен квадратному корню из 2 деленному на 2. Давайте проверим результат вычисления функции:

Ревизия: 170 Функции >>> math.sqrt(2) / 2. 0. Результаты получились разные. Почему? Разработчики допустили ошибку? Вполне вероятно – никто не застрахован от ошибок. Но, прежде чем писать отчет об ошибке и отправлять его разработчикам, давайте ознакомимся со справкой по данной функции:

>>> help(math.sin) Help on built-in function sin:

sin(...) sin(x) Return the sine of x (measured in radians).

(END) Из справки видно, что в качестве параметра тригонометрические функции принимают значение угла в радианах. Нажимаем [Q] для выхода из справочной системы с чувством гордости: теперь мы знаем как работает функция math.sin();

проведем преобразование в радианы:

>>> degrees = >>> angle = degrees * math.pi / 180. >>> height = math.sin(angle) >>> print height 0. Теперь результаты совпали – все верно.

Упражнение. Выполните в командной строке интерпретатора Питона версии 2.2 или выше следующие инструкции:

>>> import math >>> print math.doc...

>>> help(math) Ознакомьтесь с описанием модуля и входящих в него функций. Вся справка на экране не поместится, но вы сможете прокручивать текст с помощью клавиш-стрелок. Выход из справочной системы осуществляется клавишей [Q].

Если возникнет желание, можете «поиграться» с этими функциями, написав несколько простеньких программок с их использованием. Где их можно применять?

§3.5. Композиция Во второй главе мы уже рассматривали композицию применительно к арифметическим операциям и простым выражениям. Но композиция позволяет комбинировать и вызовы функций: функция в качестве параметра может принимать любое выражение, возвращающее Ревизия: 170 Функции значение, которое попадает в область ее определения;

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

>>> x = math.sin(math.asin(math.sqrt(2) / 2.0) + math.pi / 2) >>> print x 0. >>> Разберем этот пример. Первая операция, с которой сталкивается синтаксический анализатор при разборе этого выражения, это присваивание значения выражения, стоящего справа от знака =, переменной x. Перед присваиванием интерпретатор должен вычислить значение этого выражения, т.е. посчитать синус значения выражения math.asin(math.sqrt (2) / 2.0) + math.pi / 2, которое, в свою очередь равно сумме значений подвыражений math.asin(math.sqrt(2) / 2.0) и math.pi / 2. Первое из них вычисляется аналогичным образом: сначала рассчитывается значение выражения, стоящего в скобках, а затем вызывается функция math.asin(), которой полученное выражение передается в качестве аргумента. Второе подвыражение равно /2. Подсчитав сумму этих двух подвыражений, интерпретатор передает полученное значение в качестве аргумента функции math.sin(), а результат присваивает переменной x.

Напишите программу, вычисляющую значения корней квадратного уравнения ax2+bx+c=0, a<>0 по коэффициентам этого уравнения. Коэффициенты должны заноситься в начале программы в переменные a, b и c.

Попробуйте переменным a, b и c задать значения 1, 0 и -1 соответственно. Программа должна вывести значения 1.0 и -1.0. Проверьте совпали ли ваши результаты с ожидаемыми.

Экспериментируя с другими коэффициентами, имейте ввиду, что существуют уравнения не имеющие решений (у таких уравнений дискриминант меньше нуля), поэтому не пугайтесь, если в вашей программе возникнет ошибка вида: ValueError: math domain error. Немного позже мы узнаем, как этого избежать.

§3.6. Создание функций До сих пор мы использовали встроенные функции Питона и функции из модулей, которые входят в комплект его поставки. Но мощь структурных языков программирования заключается в том, что мы можем создавать свои собственные функции, причем делается это довольно просто. В структурном программировании функция представляет собой имено ванную последовательность выражений, выполняющих необходимую операцию. В Питоне существует специальный оператор определения функции, имеющий следующий синтаксис:

def ИМЯ_ФУНКЦИИ(СПИСОК_ПАРАМЕТРОВ):

ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ Правила выбора имен функций полностью аналогичны правилам выбора имен переменных, описанным в предыдущей главе. Список параметров определяет набор значений, которые могут быть переданы функции в качестве исходных данных – параметры перечисляются через запятую. Первая строка определения обычно называется заголовком функции, обозначенным ключевым словом def (от англ. «define» – «определить»). Заголовок функции в Питоне завершается двоеточием. После него может следовать любое количество выражений, но они должны быть записаны со смещением относительно начала строки. Для Ревизия: 170 Функции такого смещения можно использовать один или несколько пробелов, но, пожалуй, удобнее всего вместо пробелов использовать символ табуляции (клавиша [Tab]). Напишем и протестируем нашу первую функцию;

для завершения последовательности выражений, составляющих тело функции достаточно еще раз нажать клавишу [Enter] (в редакторе, поддерживающем автоотступы, еще придется нажать [Backspace], чтобы убрать автоматически добавленный отступ):

>>> def printAnything(object):

... print object...

>>> printAnything("Some string") Some string >>> number = >>> printAnything(number) В первых двух строках примера мы определили функцию PrintAnything(), которая печатает объект, переданный в качестве параметра. Мы можем передать этой функции строку или число, что мы и попробовали сделать в четвертой и седьмой строках примера.

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

Что если передать в качестве параметра имя функции? Вызовем PrintAnything(), указав в скобках ее же имя:

>>> printAnything(printAnything) >>> Питон вывел информацию о функции: ее имя и адрес в памяти, где она хранится! В данном случае адрес равен 0x80d7554, но у вас на компьютере этот адрес может быть другим. Теперь давайте откроем текстовый редактор и напишем такую программу:

def printHello():

print "Hello!" def runFunction(function_name):

function_name() runFunction(printHello) Сохраним программу в файле с именем prog2.py и запустим ее из командной строки (в операционной системе Windows достаточно двойного клика левой кнопки мыши на пиктограмме этого файла6):

$ python prog2.py Hello!

6 Не забудьте в последней строке программы написать команду ожидания нажатия клавиши, как это описано в разделе «Запуск программ, написанных на Питоне» (см. Введение).

Ревизия: 170 Функции Наверное, вы уже поняли, что сделал Питон, когда мы вызвали функцию runFunction () и передали ей в качестве параметра имя функции printHello(): он заменил function_name на значение переданного параметра и вызвал таким образом функцию printHello(). Такой гибкостью может похвататься редкий язык программирования. В языках C++ или Pascal это делается далеко не тривиальным способом.

Имейте также ввиду, что вызывать функцию до ее определения нельзя – это приведет к возникновению исключения.

Упражнение. Переделайте программу вычисления корней квадратного уравнения в функцию printRoots(). Параметрами данной функции должны быть коэффициенты квадратного многочлена: a, b и c. Рассчитав корни уравнения, функция должна вывести их на печать.

Упражнение. Напишите функцию, рассчитывающую расстояние между двумя точками на плоскости (координаты (x1, y1) и (x2, y2) даны).

distance x1, y1, x2, y2= x2 -x12 y2 - y §3.7. Параметры и аргументы Итак, мы научились создавать собственные функции и различать определения и вызовы функций. Теперь определимся с терминологией: чем отличается параметр функции от ее аргумента? Разница есть и большая, но вы могли ее не уловить.

Параметрами функции называют список переменных, которым присваиваются передаваемые при вызове этой функции значения. А сами передаваемые значения называют аргументами. В своем теле функция оперирует параметрами, но не аргументами. Разберем пример из предыдущего раздела:

>>> def printAnything(object):

... print object...

>>> printAnything("Some string") Some string >>> number = >>> printAnything(number) Здесь переменная object является параметром, а строка "Some string" и переменная number – аргументами. Таким образом, правильно будет сказать «передать аргумент» или «передать значение в качестве параметра», но не «передать функции параметр». Старайтесь не путать эти понятия.

§3.8. Локальные переменные Вернемся к функции поиска корней квадратного уравнения PrintRoots(). Она выглядит приблизительно так:

def printRoots(a, b, c):

Ревизия: 170 Функции D = b**2 - 4 * a * c import math x1 = (-b + math.sqrt(D)) / 2 * a x2 = (-b - math.sqrt(D)) / 2 * a print 'x1 =', x1, '\nx2 =', x Последовательность символов \n в последней строке тела функции дает указание команде print перейти на новую строку. В теле функции определено три переменные: D, x и x2. Такие переменные называют локальными, т.к. к ним можно обратиться только в самом теле функции. После завершения работы функции они стираются из памяти. Это может проиллюстрировать следующая программа:

def printRoots(a, b, c):

D = b**2 - 4 * a * c import math x1 = (-b + math.sqrt(D)) / 2 * a x2 = (-b - math.sqrt(D)) / 2 * a print 'x1 =', x1, '\nx2 =', x printRoots(1.0, 0, -1.0) print D Если запустить ее, то интерпретатор сразу после завершения работы функции PrintRoots() выведет ошибку вида:

$ python prog5.py x1 = 1. x2 = -1. Traceback (most recent call last):

File "prog5.py", line 12, in ?

print D NameError: name 'D' is not defined Почему было выбрано такое поведение? Как вы думаете? Модифицируем нашу программу таким образом:

def printRoots(a, b, c):

D = b**2 - 4 * a * c import math print "In function D = ", D x1 = (-b + math.sqrt(D)) / 2 * a x2 = (-b - math.sqrt(D)) / 2 * a print "x1 =", x1, "\nx2 =", x Ревизия: 170 Функции D = 'test' print "Before function call D = ", D printRoots(1.0, 0, -1.0) print "After function call D = ", D Запустим программу и проанализируем результат.

$ python prog5.py Before function call D = test In function D = 4. x1 = 1. x2 = -1. After function call D = test Итак, после определения функции printRoots() мы присвоили переменной D значение "test" и проверили результат: вывелась строка "test". Затем вызвали функцию printRoots(), в теле которой после присвоения переменной D результата вычисления формулы дискриминанта так же выводится значение переменной D: 4.0. После завершения работы функции мы снова выводим значение переменной D: на этот раз присвоенное значение снова равно строке "test".

На самом деле, D в основной программе и D в теле функции printRoots() – это две разные переменные. Проверить это можно, немного модифицировав нашу программу.

Воспользуемся функцией id(). Она возвращает адрес объекта в памяти. Измененная программа будет выглядеть приблизительно так:

def printRoots(a, b, c):

D = b**2 - 4 * a * c import math print "In function D = ", D, "\nAdress:", id(D), "\n" x1 = (-b + math.sqrt(D)) / 2 * a x2 = (-b - math.sqrt(D)) / 2 * a print "x1 =", x1, "\nx2 =", x D = "test" print "Before function call D = ", D, "\nAdress:", id(D), "\n" printRoots(1.0, 0, -1.0) print "After function call D = ", D, "\nAdress:", id(D), "\n" Результат работы программы будет следующим:

$ python prog5.py Before function call D = test Adress: Ревизия: 170 Функции In function D = 4. Adress: x1 = 1. x2 = -1. After function call D = test Adress: На вашем компьютере адреса могут быть другими, но выводы вы сможете сделать такие же: адреса D в основной программе и D в теле функции printRoots() различаются.

Что и требовалось доказать.

Упражнение. Являются ли параметры функции локальными переменными?

§3.9. Поток выполнения Как уже было сказано, с появлением функций (и процедур) программы перестали быть линейными, в связи с этим возникло понятие потока выполнения – последовательности выполнения инструкций, составляющих программу.

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

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

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

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

Итак, представим, что у нас имеется три функции: f1(), f2() и f3(). Причем они вызывают друг друга таким образом:

def f1():

print "f1() begins" print "Hello world!" print "f1() ends" def f2():

print "f2() begins" f1() Ревизия: 170 Функции print "f2() ends" def f3():

print "f3() begins" f2() print "f3() ends" print "Main program begins" f3() print "Main program ends" Для того, чтобы проследить последовательность выполнения операций, мы добавили команды которые будут сигнализировать, когда начинается и заканчивается каждая функция.

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

$ python prog6.py Main program begins f3() begins f2() begins f1() begins Hello world!

f1() ends f2() ends f3() ends Main program ends Разберем полученный результат. Как уже было сказано, определения функций никак не влияют на выполнение основной программы. Исключением является случай, когда интерпретатор сталкивается с синтаксической ошибкой в теле функции: даже если еще не настало время ее выполнения, он выведет сообщение об ошибке и завершит работу.

Основная программа, начинается с вывода сообщения о своем начале, затем вызывается функция f3(), которая, «представившись» вызывает, функцию f2(). Та, в свою очередь, поступает аналогичным образом, вызывая f1(). f1() тоже выводит сообщение о своем начале, затем тестовое приветствие миру и сообщение о своем завершении. Поток выполнения возвращается в тело функции f2() к тому месту, откуда была вызвана f1(), после чего выполняется следующая инструкция, выводящая сообщение о том, что функция f2() завершает свою работу. Как вы уже догадались, поток выполнения возвращается в тело функции f3(), а после ее завершения – в основную программу.

§3.10. Стековые диаграммы Для наглядности можно рисовать так называемые стековые диаграммы. Называются они так не случайно: они изображают стек вызовов.

Стек – это специальная структура данных, напоминающая стопку тарелок, потому что взаимодействие со стеком производится по специальному правилу LIFO (от англ. Last In First Ревизия: 170 Функции Out – «последним вошел, первым вышел»). Возвращаясь к аналогии со стопкой тарелок, мы кладем тарелки одну на другую, а берем их, начиная сверху. Немного позже мы научимся моделировать стек и некотрые другие структуры данных, которые часто используются для решения различных задач, а пока, ограничившись интуитивным пониманием стека, изобразим стековую диаграмму для примера из предыдущего раздела.

F1() begins f1() ends f1() Hello world!

f2() begins f2() ends f2() f3() begins f3() ends f3() Main program begins Main program ends main На данной диаграмме поток выполнения указан стрелками, подпрограммы – прямоугольными блоками;

справа и слева от стековой диаграммы дописаны строки, выводимые программой. Внизу «стопки» находится основная программа (она обозначается как main);

соответственно завершиться она не может до тех пор, пока не завершатся все функции, которые в стеке вызовов находятся «над ней». Таким образом, использование стека для отслеживания потока выполнения является наиболее естественным и простым решением.

В процессе выполнения программы стек вызовов может разрастаться и опустошаться по многу раз.

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

Давайте немного подправим нашу программу так, чтобы в функции f1() было сгенерировано исключение деления на ноль, заменив вывод приветствия мира на выражение a = 1/0:

def f1():

print "f1() begins" a = 1/ print "f1() ends"...

Теперь запустим эту программу:

$ python prog6.py Main program begins f3() begins f2() begins f1() begins Traceback (most recent call last):

Ревизия: 170 Функции File "prog6.py", line 17, in ?

f3() File "prog6.py", line 13, in f f2() File "prog6.py", line 8, in f f1() File "prog6.py", line 3, in f a = 1/ ZeroDivisionError: integer division or modulo by zero После сообщения о начале выполнения функции f1() интерпретатор вывел так называемый traceback (русскоязычные программисты обычно так и говорят «трейсбэк» или просто «трейс»). Traceback содержит не только названия функций из стека вызовов, но и номера строк, из которых был произведен каждый вызов. Кроме номеров указывается еще и название файла с программой, ведь проект может содержать не один модуль. Так что найти и исправить ошибку становится гораздо проще.

§3.11. Функции, возвращающие результат Напоследок познакомимся с еще одной важной возможностью функций. Не трудно представить себе ситуацию, когда результаты работы функции могут понадобиться для дальнейшей работы программы. Но после завершения работы функции все переменные, которые были инициализированы в ее теле, уничтожаются, т.к. они являются локальными.

Поэтому при необходимости вернуть результат работы функции в подпрограмму, из которой она вызывалась, для его дальнейшей обработки применяется команда return. Выглядит это приблизительно так:

>>> def getSum(x,y):

... z = x + y... return z...

>>> print getSum(1,3) >>> Как видите, возвращаемое функцией значение воспринимается интерпретатором, как результат выражения, вызывающего эту функцию.

В Питоне функции способны возвращать несколько значений одновременно7. Для примера возьмем функцию вычисления корней квадратного уравнения:

>>> def PrintRoots(a, b, c):

... D = b**2 - 4 * a * c... import math 7 Кстати, в Паскале и C++ вернуть из функции сразу несколько значений с помощью стандартных средств невозможно. Это еще одно удобство, предоставляемое Питоном.

Ревизия: 170 Функции... x1 = (-b + math.sqrt(D)) / 2 * a... x2 = (-b - math.sqrt(D)) / 2 * a... return x1, x...

>>> print PrintRoots(1.0, 0, -1.0) (1.0, -1.0) Кроме того, результаты выполнения функции мы можем присваивать сразу нескольким переменным:

>>> x1, x2 = PrintRoots(1.0, 0, -1.0) >>> print "x1 =", x1, "\nx2 =", x x1 = 1. x2 = -1. >>> Скорее всего, вы уже догадались, что точно таким же образом значения возвращают и встроенные функции Питона.

Ревизия: 170 Компьютерная графика Глава 4. Компьютерная графика /* модуль turtle*/ Ревизия: 170 Логические выражения, условия и рекурсия Глава 5. Логические выражения, условия и рекурсия §5.1. Комментарии в программах Любой дурак может написать программу, которую поймет компилятор. Хорошие программисты пишут программы, которые смогут понять другие программисты.

Мартин Фаулер (Martin Fowler), «Рефакторинг» ("Refactoring") По мере увеличения размеров ваших программ рано или поздно вы столкнетесь с одной проблемой: их станет сложнее читать. В идеале программа должна читаться так же легко, как если бы она была написана на естественном языке, но, с одной стороны, естественные языки все же не имеют такой четкой формальной формы описания объектов и процессов, а с другой – чрезмерная формализованность зачастую приводит к усложнению описания простых вещей. Поэтому для повышения понятности кода, его полезно снабжать комментариями на естественном языке, и большинство языков программирования, не исключая Питон, предоставляют такую возможность.

Комментирование кода считается правилом «хорошего тона», поэтому не забывайте про комментарии – этим вы и себе облегчите жизнь.

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

В Питоне комментарии помечаются символом # – строки, начинающиеся с этого символа, просто игнорируются интерпретатором и никак не влияют на ее трансляцию и выполнение:

# Подсчет процентного соотношения двух величин: 20 и print 100 * 20 / 80, "%" Комментарий может следовать и после инструкций, т.е. начинаться не с самого начала строки:

>>> print 100 * 20 / 80, "%" # целочисленное деление 25 % Кроме того, комментариями стоит снабжать и функции. Для этого предусмотрен еще один способ комментирования:

def printTwice(value):

"""Описание функции printTwice() Данная функция получает значение и выводит его дважды, разделив пробелом.""" print value, value Ревизия: 170 Логические выражения, условия и рекурсия Как видите, комментарии с описанием функций должны находиться сразу после заголовка функции. Они заключаются с двойные кавычки три раза и могут занимать несколько строк. Более того, в Питоне предусмотрена возможность вывода этих комментариев. Для этого достаточно воспользоваться встроенной переменной doc (начинается и заканчивается парами символов подчеркивания):

>>> print printTwice.doc Описание функции printTwice() Данная функция получает значение и выводит его дважды, разделив пробелом.

Этот же комментарий выведет команда справочной системы Питона help (printTwice).

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

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

§5.2. Простые логические выражения и логический тип данных В третьей главе мы научились использовать функции, тем получили мощный способ управления потоком выполнения: и наши программы перестали быть линейными. Функции выполняются без проверки каких-либо условий, как только поток выполнения программы доходит до вызова соответствующей функции. Но практически в любой программе возникает потребность в выполнении той или иной части кода программы в зависимости от введенных пользователем данных, результатов промежуточных вычислений и т.п.

Во всех языках программирования высокого (и сверхвысокого) уровня имеется возможность разветвления программы;

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

Логическими выражениями называют выражения результатом которых является истина (True) или ложь (False). В простейшем случае любое утверждение может быть истинным или ложным. Например, истинность утверждения «на улице идет дождь» зависит от того, какая на улице погода в данный момент. Или 2+2 равно 4 – истинное, а 2+2 равно 5 – ложное выражение.

Операции сравнения в программировании встречаются чаще других, поэтому с них мы и начнем. Для проверки равенства двух значений в Питоне используется оператор == (два знака равенства без пробела между ними).

>>> x = 2 + >>> x == True >>> x == False Ревизия: 170 Логические выражения, условия и рекурсия Другие операции сравнения:

>>> x != 5 # x не равен True >>> x > 5 # x больше False >>> x < 5 # x меньше True >>> x >= 4 # x больше либо равен True >>> x <= 4 # x меньше либо равен True Разумеется, результат сравнения двух значений мы можем записать в переменную:

>>> y = x == >>> print y False Как вы, наверное, заметили приоритет операций сравнения меньше приоритета арифметических операций, но больше, чем у операции присваивания.

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

>>> type(y) Как видите, в Питоне предусмотрен специальный логический тип данных, но появился он только в 2.2.2 версии. До этого в Питоне истине соответствовало число 1, а ложь кодировалась как 0;

команда type(4 != 5) возвращала значение .

Упражнение. Поэкспериментируйте с преобразованием типа значений в логический тип.

Несколько предложений для экспериментов:

>>> bool(2) >>> bool(-1) >>> bool(1.0) >>> bool("string") >>> bool(true) Объясните полученные результаты.

§5.3. Логические операторы Логические выражения могут быть более сложными и состоять из нескольких простых выражений. Для объединения простых выражений в более сложные используются логические операторы: and, or и not.

Значения их полностью совпадают со значением английских слов, которыми они обозначаются. Выражение x and y будет истинным только в том случае, когда x – истина, и Ревизия: 170 Логические выражения, условия и рекурсия y – истина. Во всех остальных случаях выражение будет ложью. Выражение x or y будет истиной, если хотя бы один из операндов – истина. Оператор not символизирует отрицание:

not x – истина, если x – ложь, и наоборот: not x – ложь, если x – истина. Обратите внимание, что оператор not унарный, т.е. он работает только с одним операндом.

Упражнение. Чему должен равняться x для того, чтобы выражение not not x было ложным?

Для простоты составим таблицы со списков всех возможных комбинаций значений операндов логических выражений и самих выражений (такие таблицы в математической логике называются таблицами истинности):

x y x and y x or y x not x 0 0 0 0 0 0 1 0 1 1 1 0 0 1 1 1 Упражнение. С помощью таблиц истинности проверьте следующие свойства логических операций:

x and y эквивалентно y and x x or y эквивалентно y or x x and x and x эквивалентно x x or x or x эквивалентно x not x and not y эквивалентно not (x or y) §5.4. Выполнение по условию и «пустота» Теперь мы готовы к изучению оператора проверки условия, позволяющего организовать разветвление программы при выполнении того или иного условия. В общем виде он выглядит так:

if ЛОГИЧЕСКОЕ_УСЛОВИЕ:

ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ Первым идет ключевое слово if (англ. «если»);

за ним – логическое выражение;

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

x = if x > 0:

print "x is positive" if x < 0:

print "x is negative" Ревизия: 170 Логические выражения, условия и рекурсия print "Stopping..."

Сохраним, запустим эту программу и разберем результат ее выполнения:

$ python prog7.py x is positive Stopping...

На первой строке мы определили переменную x, присвоив ей значение 2. Затем с помощью условного оператора проверили на истинность выражение x > 0 – значение x оказалось больше нуля, поэтому Питон выполнил тело этого условного оператора: вывел строку x is positive. Далее следует еще один оператор if, проверяющий выполнение условия x < 0, которое является ложным, и поэтому тело этого условного оператора Питон пропустил и выполнил следующую за ней инструкцию.

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

>>> def PrintRoots(a, b, c):

... D = b**2 - 4 * a * c... if D < 0:

... return None, None... import math... x1 = (-b + math.sqrt(D)) / 2 * a... x2 = (-b - math.sqrt(D)) / 2 * a... return x1, x >>> >>> print PrintRoots(3, 2, 1) (None, None) Итак, уравнение 3x2 + 2x + 1= 0 корней не имеет, т.е. его дискриминант оказался отрицательным, поэтому Питон выполнил ветку программы с инструкцией return None, None. Здесь мы воспользовались тем, что выполнение подпрограмм завершается сразу после выполнения инструкции return.

Обратите внимание на то, что инструкция возвращает не пару значений (0, 0), т.к. с точки зрения математики, это неверно: корни неопределены и функция должна вернуть пустоту. Для этих целей и предусмотрена встроенная константа None.

Упражнение. Напишите функцию compare(x, y), сравнивающую x и y и возвращающую следующие значения:

Ревизия: 170 Логические выражения, условия и рекурсия 1, если x y, compare x, y= 0, если x= y, { } -1, если x y §5.5. Ввод данных с клавиатуры Программы, которые мы писали до этого, немного скучные, т.к. они каждый раз делают одно и то же, не спрашивая у пользователя, над какими данными следует произвести те или иные действия.

Но это поправимо. В Питоне имеются встроенные функции, которые позволяют получать данные с клавиатуры. Самая простая из них – raw_input(). Вызов этой функции останавливает выполнение программы и заставляет компьютер дождаться, пока пользователь не введет данные с клавиатуры. Завершение ввода осуществляется нажатием клавиши [Enter]8: сразу после нажатия этой клавиши, функция raw_input() завершается и возвращает значение введенное с клавиатуры:

>>> text = raw_input() What are you waiting for?

>>> print text What are you waiting for?

>>>type(text) Прежде чем предоставлять пользователю возможность ввода данных хорошо бы объяснить ему, что именно нужно ввести, с помощью строки приглашения (по-английски prompt). Для этого достаточно передать эту строку в качестве параметра функции raw_input ():

>>> name = raw_input("What is your name? ") What is your name? Arthur, King of the Britons!

>>> print name Arthur, King of the Britons!

Если нам нужно, чтобы пользователь ввел целое число, то мы можем использовать функцию input().

>>> prompt = "How old are you?" >>> age = input(prompt) How old are you? >>> print age Введенная пользователем строка цифр будет приведена к типу int и присвоена переменной age. Но если пользователь введет строку букв, то возникнет исключительная ситуация (исключение):

8 Или [Return] на компьютерах Apple.

Ревизия: 170 Логические выражения, условия и рекурсия >>> age = input(prompt) How old are you?

I'm 17th years old.

SyntaxError: invalid syntax Чуть позже мы научимся избегать аварийное завершение программы и обрабатывать исключения, а пока перейдем к следующему очень захватывающему разделу (не забудьте выполнить упражнение).

Упражнение. Измените программу вычисления корней квадратного уравнения так, чтобы пользователь сам мог вводить коэффициенты a, b и c.

§5.6. Альтернативные ветки программы (Chained conditionals) Условный оператор if имеет расширенный формат, позволяющий проверять несколько независимых друг от друга условий и выполнять один из блоков, поставленных в соответствие с этими условиями. В общем виде оператор выглядит так:

if ЛОГИЧЕСКОЕ_УСЛОВИЕ_1:

ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ_ elif ЛОГИЧЕСКОЕ_УСЛОВИЕ_2:

ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ_ elif ЛОГИЧЕСКОЕ_УСЛОВИЕ_3:

ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ_...

else:

ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ_N Работает эта конструкция следующим образом. Сначала проверяется первое условие и, если оно истинно, то выполняется первая последовательность выражения. После этого поток выполнения переходит строке, которая следует после условного оператора (т.е. за последо вательностью выражений N). Если первое условие равно False, то проверяется второе условие (следующее после elif), и в случае его истинности выполняется последователь ность 2, а затем снова поток выполнения переходит к строке, следующей за оператором условия. Аналогично проверяются все остальные условия. До ветки программы else поток выполнения доходит только в том случае, если не выполняется ни одно из условий.

Ключевое слово elif происходит от англ. «else if» - «иначе если». Т.е. условие, которое следует после него проверяется только тогда, когда все предыдущие условия ложны.

Чтобы было понятнее, напишем небольшую программу, иллюстрирующую использова ние условного оператора с альтернативными ветками.

choice = raw_input('Input your choice, please (1 or 2): ') if choice == "1":

function1() Ревизия: 170 Логические выражения, условия и рекурсия elif choice == "2":

function2() else:

print "Invalid choice!" print "Thank you."

Сначала программа просит пользователя ввести единицу или двойку, затем условный оператор проверяет введенное значение на равенство со строкой '1' (если не помните, функция raw_input() возвращает строковое значение). Если условие истинно, то вызывается функция function1(), после чего программа выводит строку "Thank you." и завершается;

в противном случае значение переменной choice сравнивается со строкой '2':

если условие выполняется, то вызывается функция function2(), затем выводится строка "Thank you." и программа завершается;

иначе – программа выводит сообщение о том, что введенное значение некорректно, затем «благодарность» и завершается.

В англоязычной литературе такие разветвленные условные операторы обычно называют chained conditionals, т.е. цепочками условий.

Упражнение. Измените функцию compare(x, y) так, чтобы в ней использовался всего один оператор условия.

§5.7. Пустые блоки В процессе работы над программой следует стараться после каждого изменения иметь работающую программу, но предположим, что вы запланировали использование условного оператора с несколькими условиями, успев написать только один из блоков условного оператора. При этом встает вопрос, как ее отладить, если программа не выполняется из-за синтаксической ошибки. Например, рассмотрим программу:

choice = raw_input('Enter your choice, please:') if choice == "1":

function1_1() finction1_2() elif choice == "2":

elif choice == "3":

elif choice == "4":

else:

print "Invalid choice!" Блоки для случаев, когда значение переменной choice равно "2", "3" или "4", еще не написаны, поэтому программа не выполняется из-за ошибки Expected an indented block.

Избежать этого можно с помощью ключевого слова pass, которое можно вставить на место отсутствующего блока:

choice = raw_input('Enter your choice, please:') if choice == "1":

Ревизия: 170 Логические выражения, условия и рекурсия function1_1() finction1_2() elif choice == "2":

pass elif choice == "3":

pass elif choice == "4":

pass else:

print "Invalid choice!" Это ключевое слово может использоваться и в качестве тела функции:

def f1():

pass Эта функция ничего не делает – поток выполнения, «заглянув в нее», сразу переходит к выполнению следующей за вызовом этой функции инструкции.

§5.8. Вложенные условные операторы (Nested conditionals) В блоках условного оператора тоже могут встречаться условные операторы, ведь они, с точки зрения Питона, ничем не отличаются от других инструкций. Например:

if x == y:

print x, "and", y, "are equal" else:

if x < y:

print x, "is less than", y else:

print x, "is greater than", y Первый логический оператор содержит две ветви, вторая из которых тоже разветвляется. Но не стоит слишком злоупотреблять вложенными логическими операторами, т.к. это может привести к ухудшению читабельности программы. Здесь на помощь нам приходят логические операции. Рассмотрим пример программы:

if x < 1:

pass else:

if x < 10:

print "x is between 1 and 10" Ревизия: 170 Логические выражения, условия и рекурсия Этот код работает так: если x < 1, то ничего не происходит, т.к. поток выполнения, встретив инструкцию pass, перейдет к строке, следующей после условного оператора;

в противном случае выполнится проверка логического выражения x < 10, и если оно истинно, то интерпретатор выведет строку "x is between 1 and 10". Можно написать семантически идентичный условный оператор, но гораздо короче:

if not x < 1 and x < 10:

print "x is between 1 and 10" Можно ли сделать его еще проще? Хотелось бы избавиться от логического оператора отрицания в выражении, проверяемом оператором if.

Выражение not x < 1 истинно, если x не меньше единицы, или x больше либо равно единицы – x >= 1:

if x >= 1 and x < 10:

print "x is between 1 and 10" В такой записи незнакомый с кодом программист разберется гораздо быстрее, не так ли? Но не будем на этом останавливаться. В математике имеется более короткий способ записи условия принадлежности x некоторому отрезку числовой прямой: 1 x10.

Адаптируем ее под операторы сравнения, которые имеются в языке Питон:

>>> x = >>> if 1 <= x < 10:

... print "x is between 1 and 10"...

x is between 1 and >>> Питон прекрасно нас понял. Надо сказать, что такой возможности нет ни в Паскале, ни в C++, ни в других распространенных языках.

Что ж, пришло время попрактиковаться.

Упражнение. Упростите выражение:

if x < -5:

print "x is NOT between -5 and 5" else:

if x < 5:

print "x is between -5 and 5" else:

print "x is NOT between -5 and 5" Упражнение. Объясните почему условие 10 < x < 0 никогда не будет истинным.

Ревизия: 170 Логические выражения, условия и рекурсия §5.9. Рекурсия Разобравшись с логическими операциями и условным оператором, перейдем к изучению очень мощной концепции, которая называется рекурсией. Для того, чтобы лучше понять, где она применяется, рассмотрим задачу, которая сама приведет нас к ней.

Помимо привычных нам арифметических в математике есть и другие операции. В частности, факториал: например, 3!=1 2 3 =6. В общем виде n!=1...n, где n{0 }, причем 0!=1.

Растут значения факториала очень быстро, например 5!=120, 7!=5040, а 10!=3628800. Поэтому логично было бы поручить вычисление факториалов компьютеру.

Прежде чем приступать к реализации функции факториала давайте проанализируем формулу, по которой она вычисляется. При условии, что мы не знаем чему равно число n применить формулу n!=1...n «в лоб» не получится. Поэтому давай-те ее проанализируем:

n!=12...n, n1!=12...nn1=n!n1, иначе говоря:

n!=n-1!n Это уже что-то. По сути, зная значение n-1!, мы можем вычислить n! всего за одну операцию. Аналогично, n-1!=n-2!n-1. Попробуем реализовать эту идею на Питоне. Мы уже говорили о том, что из тела одной функции можно вызывать другую функцию. Почему бы не попробовать вызвать из функции эту же самую функцию? Это как раз то, что нам надо, давайте попробуем:

>>> def fact(n):

... return fact(n-1)*n...

>>> fact(3) File "", line 2, in fact [...] File "", line 2, in fact RuntimeError: maximum recursion depth exceeded Хм, вызывать функцию из самой себя, видимо, можно, но интерпретатор вывел длинный список обратной трассировки и сообщение об исключении: RuntimeError:

maximum recursion depth exceeded – «Достигнута максимальная глубина рекурсии».

Вот и упоминание рекурсии. Сформулируем определение – возможно, это нам поможет в поиске решения проблемы.

Рекурсивными функциями являются функции, получаемые в результате конечного числа применений самих себя для целочисленных значений аргумента (параметра). Важно 9 Читается как «три факториал».

10 Число n принадлежит множеству натуральных чисел, объединенному с нулем, иначе говоря, может быть равным 0, 1, 2, 3 и т.д.

Ревизия: 170 Логические выражения, условия и рекурсия заметить то, что такие функции применимы лишь к целочисленным значениям, но не к дробным.

Мы передали целочисленный аргумент – 3, но возникло исключение. Видимо, мы имеем дело с семантической ошибкой: программа делает не то, что мы подразумевали.

Давайте попробуем повторить выполнение нашей программы в уме.

Итак, вызов funct(3) должен вернуть funct(2)*3, далее funct(2) – это все равно что funct(1)*2;

затем идет вызов funct(0), потом funct(-1). Но n – должно быть натуральным числом или нолем! Получается, что, дойдя до граничного значения области допустимых значений n, наша программа продолжает выполнять вызов функции funct() как ни в чем ни бывало, и даже не думает останавливаться. Более того, программа «не знает» чему равен 0! – мы забыли это указать, но все поправимо.

>>> def fact(n):

... if n == 0:

... return... return fact(n-1)*n...

Pages:     || 2 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.