Это короткий фрагмент для ознакомления с книгой.
Купить эту книгу в ЛитРесБилл Любанович Простой Python. Современный стиль программирования
2016
Переводчики Н. Витько, Е. Зазноба Технический редактор Н. Рощина Литературный редактор Н. Рощина Художники А. Барцевич, Н. Гринчик, С. Заматевская Корректоры О. Андриевич, Е. Павлович Верстка Г. Блинов© Copyright c 2015 Bill Lubanovic. All rights reserved © Перевод на русский язык ООО Издательство «Питер», 2016 © Издание на русском языке, оформление ООО Издательство «Питер», 2016 © Серия «Бестселлеры O’Reilly», 2016
* * *
Мари, Карин, Тому и Рокси
Введение
Эта книга познакомит вас с языком программирования Python. Она предназначена для начинающих программистов, но даже если вы уже писали программы и хотите лишь добавить Python к списку доступных вам языков, издание «Простой Python. Современный стиль программирования» поможет в этом. Книга представляет собой неторопливое введение, которое постепенно проведет вас от основ к множеству более углубленных тем. Я использовал смесь стилей учебника и поваренной книги, чтобы по очереди объяснить новые термины и идеи. Код, написанный на языке Python, включен даже в самые первые главы. Несмотря на то что книга ориентирована на начинающих читателей, я включил в нее темы, которые могут показаться сложными, вроде баз данных NoSQL или библиотек передачи сообщений. Я выбрал их потому, что они помогут решить многие проблемы лучше, чем стандартные приемы. Вы загрузите и установите те внешние пакеты Python, которые пригодятся, когда «встроенные батарейки» не подойдут для вашего приложения. Пробовать что-то новое весело. Я также включил в книгу несколько примеров того, чего делать не нужно, особенно если вы уже работали с другими языками программирования и пытаетесь адаптировать их стиль для Python. Не буду утверждать, что язык программирования Python идеален, — просто покажу вам, чего следует избегать.Иногда я буду делать подобные врезки, когда что-то может быть непонятно или же существует более питонский способ сделать это.
Аудитория
Эта книга пригодится всем, кто заинтересован в изучении потенциально самого популярного языка программирования, независимо от того, изучали ли вы другие языки программирования ранее.Краткое описание
В первых семи главах объясняются основы языка программирования Python, их нужно читать по порядку. В последующих главах показывается, как язык программирования Python используется в определенных областях, таких как Интернет, базы данных, сети и т. д., их можно читать в любом порядке. В первых трех приложениях демонстрируется применение языка программирования Python в искусстве, бизнесе и науке. Далее вы узнаете, как установить Python 3, если у вас его нет. После этого идут ответы к упражнениям, расположенным в конце каждой главы, а затем несколько полезных списков. Глава 1. Программы похожи на руководства по вязанию носков или жарке картошки. С помощью реальных программ, написанных на языке Python, демонстрируются синтаксис языка, его возможности и способы применения в реальном мире. При сравнении Python не проигрывает другим языкам, но он не идеален. Более старая версия Python (Python 2) уступает место более новой (Python 3). Если у вас установлен Python 2, установите на свой компьютер Python 3. Воспользуйтесь интерактивным интерпретатором, чтобы самостоятельно запустить примеры из этой книги. Глава 2. В этой главе показываются простейшие типы данных, применяемые в языке программирования Python: булевы переменные, целые числа, числа с плавающей точкой и текстовые строки. Вы также изучите простейшую математику и текстовые операции. Глава 3. Мы рассмотрим встроенные структуры данных более высокого уровня: списки, кортежи, словари и наборы. Вы будете пользоваться этими типами данных, как конструктором Lego, чтобы создавать более сложные структуры. Вы научитесь проходить по ним с помощью итераторов и списковых включений. Глава 4. Здесь вы будете сплетать структуры данных из предыдущих глав со структурами кода, чтобы выполнять сравнение, выборку или повторение операций. Вы узнаете, как упаковывать код в функции и обрабатывать ошибки с помощью исключений. Глава 5. В этой главе показывается, как перейти к более крупным структурам данных: модулям, пакетам и программам. Вы узнаете, где можно разместить код и данные, ввести и вывести данные, обработать различные варианты и исследуете стандартную библиотеку Python. Глава 6. Если вы уже занимались объектно-ориентированным программированием на других языках, Python по сравнению с ними покажется вам более простым. В главе 6 объясняется, когда следует использовать объекты и классы, а когда лучше применить модули, списки или словари. Глава 7. Научитесь профессионально управлять данными. Эта глава полностью посвящена текстовым и двоичным данным, особенностям использования символов стандарта Unicode, а также вопросам ввода-вывода. Глава 8. Данные нужно где-то размещать. В этой главе вы начнете работать с простыми файлами, каталогами и файловыми системами. Далее узнаете, как управляться с простыми файловыми форматами вроде CSV, JSON и XML. Вы также научитесь сохранять и получать данные из реляционных баз данных и из современных хранилищ данных NoSQL. Глава 9. Всемирной сети посвящена отдельная глава, где рассматриваются клиенты, серверы, извлечение данных, API и фреймворки. В главе 9 вы разработаете реальный сайт, используя параметры запроса и шаблоны. Глава 10. Эта глава посвящена системному программированию. Здесь вы научитесь управлять программами, процессами и потоками, поработаете с датой и временем, автоматизируете выполнение некоторых задач системного администрирования. Глава 11. Тема этой главы — сети, а именно: службы, протоколы и API. В качестве примеров рассматриваются как низкоуровневые сокеты, библиотеки обмена сообщениями и системы массового обслуживания, так и развертывание на облачных системах. Глава 12. В этой главе содержатся советы для разработчиков, пишущих на языке программирования Python. Они касаются установки, использования IDE, тестирования, отладки, журналирования, контроля исходного кода и документации. Глава 12 также поможет вам найти и установить полезные пакеты сторонних разработчиков, упаковать свой код для повторного использования, а также узнать, где получить более подробную информацию. Приложение А. В первом приложении рассматривается, что люди делают с помощью языка программирования Python в искусстве: графике, музыке, анимации и играх. Приложение Б. Некоторые особенности языка программирования Python можно применить и для бизнеса: визуализацию данных (графики, графы и карты), безопасность и регулирование. Приложение В. Язык программирования Python широко используется в научной деятельности: математике и статистике, физике, биологии и медицине. В приложении демонстрируются возможности инструментов NumPy, SciPy и Pandas. Приложение Г. Если вы еще не установили Python 3 на свой компьютер, в этом приложении вы найдете информацию о том, как это сделать, независимо от того, какая операционная система у вас установлена: Windows, Mac OS/X, Linux или Unix. Приложение Д. Здесь содержатся ответы на упражнения, приведенные в конце каждой главы. Не подглядывайте туда, пока не попробуете решить задачи самостоятельно. Приложение Е. В этом приложении содержатся справочные данные.Версии Python
Языки программирования со временем меняются — разработчики добавляют в них новые возможности, а также исправляют ошибки. Примеры этой книги написаны и протестированы для версии Python 3.3. Версия 3.4 вышла в то же время, когда и эта книга, и я расскажу вам о некоторых нововведениях. Если хотите узнать, что и когда было добавлено в язык программирования Python, посетите страницу https://docs.python.org/3/whatsnew/. Там представлена техническая информация. Она, возможно, покажется трудной для понимания, если вы только начинаете изучать Python, но может пригодиться в будущем, если вам нужно будет писать программы для компьютеров, на которых установлены другие версии Python.Соглашения, принятые в этой книге
В этой книге приняты следующие шрифтовые соглашения. Курсив Им обозначаются новые термины и понятия. Шрифт для названий Применяется для отображения URL, адресов электронной почты, а также названий папок и выводимой на экран информации.Моноширинный шрифт
Используется в листингах программного кода, а также для имен и расширений файлов, названий путей, имен функций, команд, баз данных, переменных, операторов и ключевых слов.
Курсивный моноширинный шрифт
Указывает текст, который необходимо заменить пользовательскими значениями или значениями, определяемыми контекстом.
Этот рисунок указывает на предупреждение.
Использование примеров кода
Примеры кода, приведенные в этой книге, — но не упражнения, которые являются заданиями для читателя, — доступны для загрузки по адресу https://github.com/madscheme/introducing-python. Эта книга написана, чтобы помочь вам при работе. В принципе, вы можете использовать код, содержащийся в ней, в ваших программах и документации. Можете не связываться с нами и не спрашивать разрешения, если собираетесь воспользоваться небольшим фрагментом кода. Например, если вы пишете программу и кое-где вставляете в нее код из книги, никакого особого разрешения не требуется. Однако если вы запишете на диск примеры из книги и начнете раздавать или продавать такие диски, то на это необходимо получить разрешение. Если вы цитируете это издание, отвечая на вопрос, или воспроизводите код из него в качестве примера, разрешение не нужно. Если вы включаете значительный фрагмент кода из данной книги в документацию по вашему продукту, необходимо разрешение. Ссылки на источник приветствуются, но не обязательны. В такие ссылки обычно включаются название книги, имя ее автора, название издательства и номер ISBN. Например: Introducing Python, автор Билл Любанович (Bill Lubanovic). Copyright 2015 Bill Lubanovic, 978-1-449-35936-2. При любых сомнениях относительно превышения разрешенного объема использования примеров кода, приведенных в данной книге, можете свободно обращаться к нам по адресу permissions@oreilly.com.Как с нами связаться
Пожалуйста, направляйте комментарии и вопросы, связанные с этой книгой, ее издателю: O’Reilly Media, Inc. 1005, Gravenstein Highway North, Sebastopol, CA 95472. 800-998-9938 (в Соединенных Штатах или Канаде). 707-829-0515 (международный или местный). 707-829-0104 (факс). У нас есть веб-страница, посвященная этой книге, где мы размещаем опечатки, примеры и любую дополнительную информацию. Она располагается по адресу: http://bit.ly/introducing_python. Чтобы оставить комментарий или задать технический вопрос об этой книге, отправляйте электронные письма по адресу bookquestions@oreilly.com. Чтобы получить более подробную информацию о наших книгах, курсах, конференциях и новостях, посетите наш сайт http://www.oreilly.com. Найдите нас на Facebook: http://facebook.com/oreilly. Добавьте нас в свой Twitter: http://twitter.com/oreillymedia. Смотрите нас на YouTube: http://www.youtube.com/oreillymedia.Благодарности
Хочу объявить благодарность множеству людей, прочитавших и прокомментировавших мой черновик. В частности, я хотел бы упомянуть подробные обзоры Эли Бессерт (Eli Bessert), Генри Канивала (Henry Canival), Джереми Эллиота (Jeremy Elliott), Монте Миланука (Monte Milanuk), Лоика Пефферкорна (Loїc Pefferkorn) и Стивена Вейна (Steven Wayne).Об авторе
Билл Любанович программировал в операционной системе Unix с 1977 года, разрабатывал GUI с 1981 года, базы данных с 1990 года, а веб-разработкой занимался с 1993 года. В 1982 году, работая на стартапе Intran, он создал MetaForm — один из первых коммерчески успешных GUI (до Mac или Windows) для использования на одной из первых графических рабочих станций. В 1990 году он написал для компании Northwest Airlines визуальную систему управления доходами, которая дала миллионы долларов выручки. Кроме того, Любанович создал «витрину» компании в Интернете и написал для нее первый тест для анализа маркетинга в Сети. Позже, в 1994 году, он выступил сооснователем интернет-провайдера Tela, а в 1999 году участвовал в создании интернет-компании Mad Scheme. Впоследствии Билл Любанович разрабатывал службы ядра и распределенные системы в составе команды, работающей на стартап с Манхэттена. В настоящее время автор этой книги занимается интеграцией сервисов OpenStack в суперкомпьютерной компании. Билл счастливо живет в штате Миннесота со своей чудесной женой Мэри, сыном Томом и дочерью Карин, ухаживает за кошками Ингой и Люси и котом Честером.Глава 1. Python: с чем его едят
Начнем с одной небольшой тайны и ее разгадки. Что, по-вашему, означают следующие две строки?(Ряд 1): (RS) K18, ssk, k1, turn work.
(Ряд 2): (WS) Sl 1 pwise, p5, p2tog, p1, turn.
Выглядит как какая-то компьютерная программа. На самом деле это схема для вязания, а если точнее, фрагмент, который описывает, как связать пятку носка. Для меня эти строки имеют не больше смысла, чем кроссворд из газеты New York Times — для моего кота, но моя жена понимает их совершенно точно. Если вы вяжете, то тоже их поймете.
Рассмотрим еще один пример. Вы сразу поймете его предназначение, хотя и не сразу сможете определить результат:
½ столовой ложки масла или маргарина;
½ столовой ложки сливок;
2 ½ стакана муки;
1 чайная ложка соли;
1 чайная ложка сахара;
4 стакана картофельного пюре (охлажденного).
Перед тем как добавить муку, убедитесь, что все ингредиенты охлаждены.
Смешайте все ингредиенты.
Тщательно замесите.
Сделайте 20 шариков. Держите их охлажденными до следующего этапа.
Для каждого шарика разровняйте муку на тряпочке.
Раскатайте шарик при помощи рифленой скалки.
Жарьте на сковороде до подрумянивания.
Переверните и обжарьте другую сторону.
Даже если вы не готовите, вы сможете распознать кулинарный рецепт: список продуктов, за которым следуют указания по приготовлению. Но что получится в итоге? Это лефсе, норвежский деликатес, который напоминает тортилью. Полейте блюдо маслом, вареньем или чем-нибудь еще, сверните и наслаждайтесь.
Схема для вязания и рецепт имеют несколько похожих моментов:
• фиксированный словарь, состоящий из слов, аббревиатур и символов. Некоторые могут быть знакомы, другие же покрыты тайной;
• правила, описывающие, что и где можно говорить, — синтаксис;
• последовательность операций, которые должны быть выполнены по порядку;
• в некоторых случаях — повторение определенных операций (цикл), например способ приготовления каждого кусочка лефсе;
• в некоторых случаях — ссылка на другую последовательность операций (говоря компьютерными терминами, функция). Например, когда вы прочтете приведенный выше рецепт, вам может понадобиться рецепт приготовления картофельного пюре;
• предполагаемое знание контекста. Рецепт подразумевает, что вы знаете, что такое вода и как ее кипятить. Схема для вязания подразумевает, что вы умеете держать спицы в руках;
• ожидаемый результат. В наших примерах результатом будет предмет для ног и предмет для желудка. Главное — не перепутать.
Все эти идеи вы можете встретить и в компьютерных программах. Я воспользовался этими «непрограммами», чтобы показать, что программы не так страшны, как может показаться. Нужно всего лишь выучить верные слова и правила.
Теперь оставим этих дублеров и рассмотрим настоящую программу. Что она делает?
for countdown in 5, 4, 3, 2, 1, "hey!":
····print(countdown)
Если вы считаете, что это программа, написанная на языке программирования Python, которая выводит на экран следующее:
5
4
3
2
1
hey!
то вы знаете, что язык программирования Python выучить проще, чем понять рецепт или схему для вязания. К тому же вы можете тренироваться писать на языке программирования Python, сидя за удобным и безопасным столом, избегая опасностей вроде горячей воды и спиц.
Программа, написанная на языке программирования Python, содержит несколько специальных слов и символов: for, in, print, запятые, точки с запятой, скобки и т. д., — которые являются важной частью синтаксиса языка. Хорошая новость заключается в том, что язык программирования Python имеет более доступный и менее объемный синтаксис, чем большинство других языков программирования. Он кажется более понятным — почти как рецепт.
Вот еще одна небольшая программа, написанная на языке программирования Python, которая выбирает новостные клише из списка и выводит их на экран:
cliches = [
····"At the end of the day",
····"Having said that",
····"The fact of the matter is",
····"Be that as it may",
····"The bottom line is",
····"If you will",
····]
print(cliches[3])
Эта программа выведет четвертое клише:
Be that as it may
Списки — вроде cliches — представляют собой последовательность значений, доступ к которым осуществляется с использованием смещения от начала списка. Смещение для первого элемента списка равно 0, а для четвертого — 3.
Списки широко распространены в языке программирования Python. О том, как ими пользоваться, будет рассказано в главе 3. Далее приведена еще одна программа, которая также выводит цитату, но в этот раз цитата выбирается в зависимости от того, кто ее произнес, а не с помощью позиции в списке:
quotes = {
····"Moe": "A wise guy, huh?",
····"Larry": "Ow!",
····"Curly": "Nyuk nyuk!",
····}
stooge = "Curly"
print(stooge, "says: ", quotes[stooge])
Если вы запустите эту небольшую программу, она выведет следующее:
Curly says: Nyuk nyuk!
quotes — это словарь, коллекция уникальных ключей (в этом примере ключом является имя участника Stooge) и связанных с ними значений (в этом примере — значимая цитата участника Stooge). Используя словарь, вы можете сохранять элементы и выполнять их поиск по именам, что часто удобнее, чем работать со списком. Более подробно о словарях можно прочитать в главе 3.
В примере с клише для создания списка используются квадратные скобки ([и]), а в примере со Stooge для создания словаря — фигурные скобки ({ и }). Все это — варианты синтаксиса языка программирования Python, и в нескольких следующих главах вы увидите гораздо больше.
А теперь рассмотрим кое-что совершенно иное: в примере ниже показана программа, написанная на языке программирования Python, которая выполняет несколько более сложных задач. Не ждите, что сразу поймете, как она работает, — для этого и предназначена данная книга. Мы рассматриваем пример для того, чтобы увидеть и прочувствовать обычную нетривиальную программу, написанную на языке Python. Если вы знаете другие языки программирования, то можете сравнить их с Python прямо сейчас.
В примере ниже происходит подключение к сайту YouTube и получение информации о видеороликах, имеющих в данный момент самые высокие оценки. Если бы результатом была обычная веб-страница, заполненная текстом, отформатированным как HTML, было бы трудно получить всю необходимую информацию (я говорю об извлечении данных в разделе «Веб-сервисы и автоматизация» главы 9). Вместо этого пример получает данные, представленные в формате JSON, который предназначен для обработки компьютером. JSON, или JavaScript Object Notation, — это читабельный для человека текстовый формат, который описывает типы и значения, а также выстраивает значения в определенном порядке. Он немного похож на языки программирования и уже стал популярным способом обмена данными между разными языками программирования и системами. Вы можете прочитать о JSON больше в подразделе «JSON» раздела «Структурированные текстовые файлы» главы 8.
Программы, написанные на языке Python, могут преобразовывать текст формата JSON в структуры данных — их вы увидите в следующих двух главах, — как если бы вы написали программу, чтобы создавать их самостоятельно. В полученном от YouTube ответе данных очень много, поэтому в рамках этого примера я выведу названия лишь первых шести видеороликов. И вновь перед вами полноценная программа, которую вы можете запустить самостоятельно.
import json
from urllib.request import urlopen
url = "https://gdata.youtube.com/feeds/api/standardfeeds/top_rated?alt=json"
response = urlopen(url)
contents = response.read()
text = contents.decode('utf8')
data = json.loads(text)
for video in data['feed']['entry'][0:6]:
····print(video['title']['$t'])
Когда я запускал эту программу в последний раз, получил следующий результат:
Evolution of Dance — By Judson Laipply
Linkin Park — Numb
Potter Puppet Pals: The Mysterious Ticking Noise
"Chocolate Rain" Original Song by Tay Zonday
Charlie bit my finger — again!
The Mean Kitty Song
Эта небольшая программа, написанная на языке Python, делает многое с помощью всего лишь девяти строк. Если вы не знаете всех этих терминов, не волнуйтесь — вы познакомитесь с ними в следующих главах.
• Строка 1: импортируем весь код из стандартной библиотеки, которая называется json.
• Строка 2: импортируем только функцию urlopen из стандартной библиотеки urllib.
• Строка 3: присваиваем URL сайта YouTube переменной url.
• Строка 4: соединяемся с веб-сервером, расположенным по этому адресу, и запрашиваем определенный веб-сервис.
• Строка 5: получаем ответ и присваиваем его переменной contents.
• Строка 6: дешифруем содержимое переменной contents в текстовую строку формата JSON и присваиваем ее переменной text.
• Строка 7: преобразуем переменную text в data — структуру данных языка Python, предназначенную для работы с видео.
• Строка 8: получаем информацию для одного видеоролика единовременно в переменную video.
• Строка 9: используем двухуровневый словарь (data['feed']['entry']) и функцию slice([0:6]).
• Строка 10: используем функцию print, чтобы вывести на экран только название видеоролика.
Информация о видеоролике представляет собой различные структуры данных; все они демонстрируются в главе 3.
В предыдущем примере мы задействовали стандартные библиотечные модули (программы, включаемые в Python при установке), но в них нет ничего таинственного. Следующий фрагмент кода показывает переписанный пример, использующий внешний пакет ПО для Python, который называется requests:
import requests
url = "https://gdata.youtube.com/feeds/api/standardfeeds/top_rated?alt=json"
response = requests.get(url)
data = response.json()
for video in data['feed']['entry'][0:6]:
····print(video['title']['$t'])
Новая версия содержит всего шесть строк и, я полагаю, более читабельна для большинства людей. Я расскажу гораздо больше о requests и других авторских программах для Python в главе 5.
Python в реальном мире
Стоит ли тратить на изучение Python время и силы? Может быть, это игра в бирюльки? Язык программирования Python существует примерно с 1991 года (он появился раньше Java) и является одним из десяти самых популярных языков программирования. Людям платят деньги за то, что они пишут программы на Python, которыми мы пользуемся каждый день, — Google, YouTube, Dropbox, Netflix и Hulu. Я использовал Python для создания как поискового устройства для электронной почты, так и интернет-магазина. Python имеет репутацию высокопроизводительного языка программирования, что нравится динамично развивающимся организациям. Вы можете найти множество приложений, написанных на Python, например: • командную строку на мониторе или в окне терминала; • пользовательские интерфейсы, включая сетевые; • веб-приложения, как клиентские, так и серверные; • бэкэнд-серверы, поддерживающие крупные популярные сайты; • облака (серверы, управляемые сторонними организациями); • приложения для мобильных устройств; • приложения для встроенных устройств. Программы, написанные на языке программирования Python, могут быть как одноразовыми сценариями — вы видели их ранее в этой главе, — так и сложными системами, содержащими миллионы строк. Мы рассмотрим применение языка программирования Python для создания сайтов, системного администрирования и манипулирования данными. Рассмотрим также использование Python в искусстве, науке и бизнесе.Python против языка Х
Насколько Python хорош по сравнению с другими языками программирования? Где и когда следует использовать тот или иной язык? В этом разделе я приведу примеры кода, написанные на других языках, чтобы вы могли понять, с чем конкурирует Python. Вы не обязаны понимать каждый из этих фрагментов, если не работали с этими языками. (Когда вы увидите последний фрагмент, написанный на Python, то почувствуете облегчение из-за того, что не работали с некоторыми языками.) Если вам интересен только Python, вы ничего не потеряете, если не будете читать этот раздел. Каждая программа должна вывести число и немного рассказать о языке, на котором она написана. Если вы пользуетесь терминалом или терминальным окном, программа, которая читает то, что вы вводите, выполняет это и отображает результат, называется программой-оболочкой. Оболочка операционной системы Windows называется cmd, она выполняет пакетные файлы, имеющие расширение. bat. Для Linux и других операционных систем семейства Unix (включая Mac OS X) существует множество программ-оболочек, самая популярная из которых называется bash или sh. Оболочка обладает небольшими возможностями вроде выполнения простой логики и разворачивания символа-джокера наподобие * в полноценные имена файлов. Вы можете сохранять команды в файлы, которые называются сценариями оболочки, и выполнять их позже. Эти программы могли быть самыми первыми в вашей карьере программиста. Проблема заключается в том, что со сценариями оболочки трудно работать, если они содержат как минимум несколько сотен строк, а сами сценарии выполняются гораздо медленнее, чем программы, написанные на других языках. В следующем фрагменте кода демонстрируется небольшая программа-оболочка:#!/bin/sh
language=0
echo "Language $language: I am the shell. So there."
Если вы сохраните этот файл под именем meh.sh и запустите его с помощью команды sh meh.sh, то на экране увидите следующее:
Language 0: I am the shell. So there.
Старые добрые С и С++ являются довольно низкоуровневыми языками программирования, которыми пользуются в том случае, когда важна скорость. Их труднее выучить, и вам придется отслеживать множество деталей, что может привести к падениям программы и проблемам, которые трудно диагностировать. Так выглядит небольшая программа на языке С:
#include <stdio.h>
int main(int argc, char *argv[]) {
····int language = 1;
····printf("Language %d: I am C! Behold me and tremble!\n", language);
····return 0;
}
С++ происходит из одного семейства с С, но имеет несколько отличительных особенностей:
#include <iostream>
using namespace std;
int main() {
····int language = 2;
····cout << "Language " << language << \
·······": I am C++!··Pay no attention to that C behind the curtain!" << \
·······endl;
····return(0);
}
Java и C# являются преемниками языков С и С++, избавленными от некоторых проблем предшественников. Однако они немного избыточны и ограничительны. Следующий пример написан на Java:
public class Overlord {
····public static void main (String[] args) {
········int language = 3;
········System.out.format("Language %d: I am Java! Scarier than C!\n", language);
····}
}
Если вы никогда не писали программ ни на одном из этих языков, вам может быть интересно, что все это такое. Некоторые языки нагружены значительным синтаксическим багажом. Их иногда называют статическими языками, поскольку они требуют, чтобы вы указали компьютеру некоторые низкоуровневые детали. Позвольте мне объяснить.
Языки программирования имеют переменные — имена значений, которые вы хотите использовать в программе. Статические языки заставляют вас указывать тип каждой переменной, который определяет, сколько места переменная займет в памяти и что с ней можно сделать. Компьютер использует эту информацию, чтобы скомпилировать программу в очень низкоуровневый машинный язык (характерный для определенного аппаратного обеспечения, машины понимают его лучше, а люди — хуже). Дизайнеры языков программирования часто должны решать, кому их язык должен быть понятнее: людям или компьютерам. Объявление типов переменных помогает компьютеру найти некоторые ошибки и работать быстрее, но это требует предварительного продумывания и набора кода. Бо́льшая часть кода примеров, написанного на языках С, С++ и Java, требует объявления типов переменных. Например, в каждом из примеров объявление типа int было необходимо для того, чтобы переменная language считалась целым числом. (Другие типы включают в себя числа с плавающей точкой, вроде 3.14159, и символьные или текстовые данные, которые хранятся по-разному.)
Почему же они называются статическими языками? Потому что переменные в этих языках не могут изменять свой тип, они статичны. Целое число — это целое число, раз и навсегда.
Динамические языки — полная противоположность статических (они также называются скриптовыми языками). Эти языки программирования не заставляют вас определять тип переменной перед тем, как ее использовать. Если вы напишете что-то вроде x = 5, динамический язык определит, что 5 — это целое число, поэтому переменная x имеет тип int. Эти языки позволяют вам достичь большего, написав меньшее количество строк кода. Вместо того чтобы компилироваться, они интерпретируются программой, которая называется — сюрприз! — интерпретатором. Динамические языки обычно медленнее, чем статические, но их скорость повышается, поскольку интерпретаторы становятся более оптимизированными. Долгое время динамические языки использовались для коротких программ (сценариев), которые часто предназначались для того, чтобы подготовить данные для обработки более длинными программами, написанными на статических языках. Такие программы назывались связующим кодом. Несмотря на то что динамические языки больше годятся для этой цели, в наши дни они могут решать и самые трудные задачи по обработке данных.
Многоцелевым динамическим языком многие годы был Perl. Язык программирования Perl очень мощный и имеет множество библиотек. Однако его синтаксис может быть трудным для понимания, а сам язык теряет в популярности из-за появления языков программирования Python и Ruby. А вот извольте: острый код с привкусом Perl:
my $language = 4;
print "Language $language: I am Perl, the camel of languages.\n";
Язык программирования Ruby (http://www.ruby-lang.org/) появился немного позже. Он отчасти заимствует функционал у языка Perl, а свою популярность приобрел благодаря фреймворку для веб-разработки Ruby on Rails. Он используется примерно в тех же областях, что и Python, и, если выбирать между этими языками, вам придется руководствоваться в большей степени вкусом и доступными библиотеками. Следующий фрагмент кода написан на Ruby:
language = 5
puts "Language #{language}: I am Ruby, ready and aglow."
Язык программирования PHP (http://www.php.net/), который вы можете увидеть в следующем примере, очень популярен в области веб-разработки, поскольку позволяет довольно легко объединить HTML и код. Однако язык PHP имеет несколько подводных камней, и его довольно трудно применить за пределами веб-разработки:
<?PHP
$language = 6;
echo "Language $language: I am PHP. The web is <i>mine</i>, I say.\n";
?>
Следующий пример показывает ответ Python этим языкам программирования:
language = 7
print("Language %s: I am Python. What's for supper?" % language)
Почему же Python?
Python — многоцелевой высокоуровневый язык программирования. Его дизайн позволяет писать хорошо читаемый код, что гораздо важнее на деле, чем на словах. Каждая компьютерная программа пишется всего однажды, но впоследствии к ней обращаются множество раз. Удобочитаемость позволяет легко запомнить программу, а также легко воспроизвести. По сравнению с другими популярными языками программирования кривая обучения для языка Python более гладкая, что позволяет вам быстрее стать продуктивными. Однако есть и сложные моменты, которые вы можете исследовать по мере приобретения опыта. Относительный лаконизм языка Python позволяет создать программу, которая будет гораздо короче своего аналога, написанного на статическом языке. Исследования показали, что программисты пишут примерно одинаковое количество строк кода каждый день независимо от языка, поэтому Python может значительно повысить вашу продуктивность. Язык программирования Python — самое несекретное оружие многих компаний, которым важна продуктивность работы сотрудников. Python является самым популярным языком на курсах программирования для начинающих в лучших американских колледжах (http://bit.ly/popular-py). Он также используется для оценки навыков программирования более чем 2000 работодателей (http://bit.ly/langs-2014). И конечно же, он абсолютно бесплатен. Вы можете написать с помощью Python все, что захотите, и пользоваться этой программой где угодно совершенно бесплатно. Никто не сможет прочитать вашу программу и сказать: «Какая милая программа! Будет жаль, если с ней что-то случится». Python запускается практически везде и имеет «встроенные батарейки» — целую кучу полезного ПО в стандартных библиотеках. Но, возможно, основная причина использования Python покажется вам неожиданной: людям обычно нравится этот язык. Им действительно нравится программировать на нем, а не относиться к нему как к еще одному инструменту. Некоторые разработчики говорят, что им не хватает какой-то особенности Python, когда они вынуждены программировать на другом языке. И это отличает Python от его «коллег».Когда не стоит использовать Python
Python не всегда будет наилучшим выбором. Он не предустановлен по умолчанию. В приложении Г показано, как установить Python, если он еще не установлен на вашем компьютере. Python довольно быстрый для большинства приложений, но его скорости может оказаться недостаточно для наиболее требовательных из них. Если ваша программа проводит бо́льшую часть времени за вычислениями (в технических терминах такое называется «ограничена быстродействием процессора» (CPU-bound)), то языки С, С++ или Java справятся с задачей гораздо лучше, чем Python. Но не всегда! • Иногда более качественный алгоритм (пошаговое решение) для Python превосходит по скорости неэффективный алгоритм для С. Более высокая скорость разработки для Python дает вам больше времени для экспериментов над альтернативными решениями. • Во многих приложениях программа «скрещивает пальцы» в ожидании ответа от сервера. Центральный процессор (компьютерный чип, который делает все расчеты) обычно не задействован, поэтому время выполнения статических и динамических программ будет примерно одинаковым. • Стандартный интерпретатор Python написан на С и может быть улучшен с помощью дополнительного кода. Я рассмотрю этот вопрос в разделе «Оптимизируем ваш код» главы 12. • Интерпретаторы для Python становятся быстрее. Java был ужасно медленным, когда только появился, и для его ускорения было потрачено много времени и денег. Языком программирования Python не владеет ни одна корпорация, поэтому он улучшается более плавно. В подразделе «PyPy» упомянутого раздела главы 12 я расскажу о проекте PyPy и его приложениях. • Вы можете писать очень трудоемкое приложение, и, что бы вы ни делали, Python не будет соответствовать вашим потребностям. Тогда, как сказал Иен Холм в фильме «Чужой», примите мои соболезнования. Обычно альтернативой в таком случае являются языки программирования С, С++ и Java, однако решением может стать и более новый язык программирования — Go (http://golang.org/) (который, по ощущениям, похож на Python, но имеет более высокую производительность, вроде С).Python 2 против Python 3
Самая большая проблема, с которой вы можете столкнуться сейчас, — это выбор одной из двух существующих версий Python. Python 2, кажется, существовал всегда, эта версия предустанавливается на компьютеры с операционными системами семейства Linux. Это был отличный язык, но ничто не идеально. В языках программирования, как и во многих иных областях, одни ошибки поверхностные, и исправить их легко, а другие — трудно. Решения этих трудных проблем несовместимы: новые программы, написанные с помощью исправленного языка, не будут работать на старых системах, а старые программы не будут работать на новых. Создатель языка Python Гвидо ван Россум (Guido van Rossum) (https://www.py-thon.org/~guido) и другие объединили решения трудных проблем и назвали их Python 3. Python 2 — это прошлое, а Python 3 — будущее. Последняя версия Python 2 имеет номер 2.7, она еще долго будет поддерживаться, но на ней род заканчивается; Python 2.8 никогда не выйдет. Новая разработка будет вестись на Python 3. В этой книге описывается Python 3. Если вы раньше использовали Python 2, то практически не заметите разницы. Самое очевидное изменение — это способ вызова функции print. Самое главное изменение — это обработка символов Unicode, она рассматривается в главах 2 и 7. Преобразование популярного ПО, написанного на Python, выполняется постепенно. Но сейчас кажется, что мы наконец достигли переломного момента.Установка Python
Чтобы не занимать много места, я вынес детали установки Python 3 в приложение Г. Если у вас еще не установлен Python 3 или вы не знаете этого точно, обратитесь к приложению и посмотрите, что вам нужно сделать со своим компьютером.Запуск Python
После того как вы установите рабочую копию Python 3, можете использовать ее, чтобы запускать как программы, приведенные в этой книге, так и собственный код. Как же запустить программу, написанную на языке Python? Существует два основных способа. • Интерактивный интерпретатор, который поставляется вместе с Python, дает возможность экспериментировать с небольшими программами. Вы вводите команды строка за строкой и мгновенно видите результат. Благодаря тесному связыванию между печатанием и просмотром можете проводить эксперименты быстрее. Я буду использовать интерактивный интерпретатор, чтобы продемонстрировать возможности языка, а вы можете вводить те же команды в собственной среде Python. • Для всего прочего сохраняйте программы в виде текстовых файлов с расширением. py, а затем запускайте их, введя python и имена этих файлов. Попробуем воспользоваться обоими методами.Интерактивный интерпретатор
Для большинства примеров кода в этой книге используется интерактивный интерпретатор. Когда вы вводите команды, которые видите в примерах, и получаете те же результаты, вы знаете, что идете по правильному пути. Интерпретатор запускается путем ввода имени основной программы Python для вашего компьютера: python, python3 или чего-то похожего. В дальнейшем мы будем предполагать, что она называется python. Если ваша программа называется по-другому, то для ее запуска вам следует ввести именно это имя. Интерактивный интерпретатор работает практически так же, как и интерпретатор для файлов, но с одним исключением: когда вы вводите обычное значение, интерактивный интерпретатор автоматически выведет его на экран. Например, если вы запустите Python и введете в интерпретатор число 61, оно будет продублировано в терминале.
$ python
Python 3.3.0 (v3.3.0:bd8afb90ebf2, Sep 29 2012, 01:25:11)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 61
61
>>>
Автоматическое выведение значения — это экономящая время особенность интерактивного интерпретатора, а не часть языка Python.
Кстати, функция print() также работает внутри интерпретатора, на случай если вам понадобится вывести что-то на экран:
>>> print(61)
61
>>>
Если вы попробовали запустить эти примеры с помощью интерактивного интерпретатора и увидели те же результаты, то у вас появился опыт (пусть и небольшой) запуска кода на Python. В следующих нескольких главах вы перейдете от строковых команд к более длинным программам.
Файлы Python
Если вы запишете в файл число 61 и запустите этот файл с помощью Python, он выполнится, но на экране ничего не появится. В обычных неинтерактивных программах для Python вам нужно вызвать функцию print, чтобы вывести что-то на экран, как показано в следующем фрагменте кода:print(61)
Создадим файл программы Python и запустим его.
1. Откройте текстовый редактор.
2. Введите в него строку print(61), как показано ранее.
3. Сохраните этот файл с именем 61.py. Убедитесь, что вы сохранили его как простой текст, а не в формате вроде RTF или DOC. Вы не обязаны использовать расширение. py для файлов программ Python, но оно поможет вам запомнить предназначение файла.
4. Если вы пользуетесь графическим пользовательским интерфейсом — это касается практически каждого, — откройте окно терминала[1].
5. Запустите программу, введя следующую строку:
$ python 61.py
Вы должны увидеть такую строку:
61
Сработало? Если да, то примите мои поздравления по поводу того, что вы запустили свою первую автономную программу для Python.
Что дальше?
Вы будете вводить команды в работающую систему Python, они должны соответствовать синтаксису языка. Вместо того чтобы вывалить все синтаксические правила сразу, рассмотрим их в нескольких следующих главах. Самый простой способ разработки программы на Python — применение простого текстового редактора и окна терминала. В рамках этой книги я использую именно такие редакторы, иногда показывая интерактивные сессии работы с терминалом, а иногда — фрагменты файлов. Вам следует знать, что существует множество интегрированных сред разработки (Integrated Development Environment, IDE) для Python. Они могут предоставлять вам графические пользовательские интерфейсы, помогающие в редактировании текста, и экраны помощи. Более подробно вы прочитаете о них в главе 12.Момент просветления
Каждый язык программирования имеет свой стиль. Во введении я упомянул, что существует характерный для Python способ выразить себя. В Python встроен небольшой текст, который выражает его философию (насколько я знаю, Python — это единственный язык программирования, содержащий подобное «пасхальное яйцо»). Когда вам захочется ощутить момент просветления, просто введите import this в интерактивный интерпретатор, а затем нажмите клавишу Enter:>>> import this
Красивое лучше, чем уродливое.
Явное лучше, чем неявное.
Простое лучше, чем сложное.
Сложное лучше, чем запутанное.
Одноуровневое лучше, чем вложенное.
Разреженное лучше, чем плотное.
Читаемость имеет значение.
Особые случаи не настолько особые, чтобы нарушать правила.
При этом практичность важнее безупречности.
Ошибки никогда не должны замалчиваться.
Если не замалчиваются явно.
Встретив двусмысленность, отбрось искушение угадать.
Должен существовать один — и желательно только один — очевидный способ сделать это.
Хотя он поначалу может быть и не очевиден, если вы не голландец.
Сейчас лучше, чем никогда.
Хотя никогда зачастую лучше, чем прямо сейчас.
Если реализацию сложно объяснить — идея плоха.
Если реализацию легко объяснить — идея, возможно, хороша.
Пространства имен — отличная штука! Будем делать их побольше!
На протяжении книги я буду приводить примеры, иллюстрирующие эти утверждения.
Упражнения
Эта глава является введением в язык программирования Python. Здесь было показано, что он делает, как выглядит и где его можно применить. В конце каждой главы я буду предлагать выполнить небольшие проекты, которые помогут вам запомнить то, что вы только что прочитали, и подготовят к следующим урокам. 1. Если вы еще не установили Python 3, сделайте это сейчас. Прочтите приложение Г, чтобы узнать детали. 2. Запустите интерактивный интерпретатор Python 3. И вновь детали вы найдете в приложении Г. Интерпретатор должен вывести несколько строк о себе, а затем строку, начинающуюся с символов >>>. Перед вами приглашение для ввода команд Python. 3. Немного поэкспериментируйте с интерпретатором. Используйте его как калькулятор и наберите текст 8 * 9. Нажмите клавишу Enter, чтобы увидеть результат. Python должен вывести 72. 4. Теперь введите число 47 и нажмите клавишу Enter. Появилось ли число 47 в следующей строке? 5. Теперь введите print(47) и нажмите клавишу Enter. Появилось ли снова число 47 в следующей строке?Глава 2. Ингредиенты Python: числа, строки и переменные
В этой главе мы рассмотрим простейшие встроенные в Python типы данных: • булевы значения (которые имеют значение True или False); • целые числа (вроде 42 и 100 000 000); • числа с плавающей точкой (числа с десятичной запятой, вроде 3,14159 или экспоненты, вроде 1,0е8, что означает «один умножить на десять в восьмой степени», или 100 000 000,0); • строки (последовательности текстовых символов). Можно сказать, что они являются атомами. В этой главе мы будем использовать их обособленно. В главе 3 будет показано, как объединить их в молекулы. Каждый тип имеет специфические правила использования, они по-разному обрабатываются компьютером. Мы также познакомимся с переменными (имена, которые ссылаются на данные; чуть подробнее мы поговорим о них совсем скоро). Примеры кода, приведенные в этой главе, корректны с точки зрения Python, но они являются лишь фрагментами кода. Мы будем использовать интерактивный интерпретатор Python, вводя в него эти фрагменты и немедленно получая результат. Попробуйте запустить их самостоятельно. Вы распознаете эти примеры по приглашению >>>. В главе 4 мы начнем писать программы, которые могут работать самостоятельно.Переменные, имена и объекты
В Python все — булевы значения, целые числа, числа с плавающей точкой, строки и даже крупные структуры данных, функции и программы — реализовано как объект. Это позволяет языку быть стабильным (и дает полезные особенности), чего не хватает некоторым другим языкам. Объект похож на прозрачный пластиковый ящик, который содержит фрагмент данных (рис. 2.1). Объект имеет тип вроде булевых значений или целых чисел, который определяет, что можно сделать с этими данными. В реальном мире ящик с надписью «Керамика» может сообщить некоторую информацию (скорее всего, он тяжелый и лучше не ронять его на пол). Точно так же и в Python — если объект имеет тип int, вы знаете, что сможете сложить его с другим объектом типа int.
Рис. 2.1. Объект похож на коробку
Тип также определяет, можно ли изменить значение, которое хранится в ящике (изменяемое значение), или оно константно (неизменяемое значение). Неизменяемый объект можно сравнить с закрытым ящиком с окошком: вы можете увидеть значение, но не можете изменить его. В рамках той же аналогии изменяемый объект похож на открытую коробку: вы не только можете увидеть хранящееся там значение, но и изменить его, однако не можете изменить его тип. Python является строго типизированным языком, а это означает, что тип объекта не изменится, даже если можно поменять его значение (рис. 2.2).
Рис. 2.2. Строгая типизация не означает, что нужно нажимать клавиши со строгим выражением лица
Языки программирования также позволяют вам определять переменные. Переменные являются именами, которые ссылаются на значения в памяти компьютера. Вы можете определить их для использования в своей программе. В Python символ = применяется для присваивания значения переменной.
В следующей программе целое число 7 присваивается переменной с именем a, затем на экран выводится значение, связанное в текущий момент с этой переменной:
>>> a = 7
>>> print(a)
7
Сейчас пришло время сделать очень важное заявление о переменных в Python: переменные — это просто имена. Присваивание не копирует значение, оно прикрепляет имя к объекту, который содержит данные. Имя — это ссылка на какой-то объект, а не сам объект. Имя можно рассматривать как стикер (рис. 2.3).
Рис. 2.3. Имена прикрепляются к объектам
Попробуйте сделать следующее с помощью интерактивного интерпретатора. 1. Как и раньше, присвойте значение 7 имени a. Это создаст объект-«ящик», содержащий целочисленное значение 7. 2. Выведите на экран значение а. 3. Присвойте а переменной b, заставив b прикрепиться к объекту-«ящику», содержащему значение 7. 4. Выведите значение b.
>>> a = 7
>>> print(a)
7
>>> b = a
>>> print(b)
7
В Python, если вы хотите узнать тип какого-то объекта (переменной или значения), вам следует использовать конструкцию type(объект). Попробуем сделать это для разных значений (58, 99.9, abc) и переменных (a, b):
>>> type(a)
<class 'int'>
>>> type(b)
<class 'int'>
>>> type(58)
<class 'int'>
>>> type(99.9)
<class 'float'>
>>> type('abc')
<class 'str'>
Класс — это определение объекта; классы детально рассматриваются в главе 6. В Python значения терминов «класс» и «тип» примерно одинаковы.
Имена переменных могут содержать только следующие символы:
• буквы в нижнем регистре (от «a» до «z»);
• буквы в верхнем регистре (от «A» до «Z»);
• цифры (от 0 до 9);
• нижнее подчеркивание (_).
Имена не могут начинаться с цифры. Python также особо обрабатывает имена, которые начинаются с нижнего подчеркивания (об этом вы можете прочесть в главе 4). Корректными являются следующие имена:
• a;
• a1;
• a_b_c___95;
• _abc;
• _1a.
Следующие имена, однако, некорректны:
• 1;
• 1a;
• 1_.
Наконец, не следует использовать следующие слова для имен переменных, поскольку они являются зарезервированными словами Python:
| false | class | finally | is | return |
| none | continue | for | lambda | try |
| true | def | from | nonlocal | while |
| and | del | global | not | with |
| as | elif | if | or | yield |
| assert | else | import | pass | |
| break | except | in | raise |
Эти слова и некоторые знаки препинания используются в синтаксисе Python. Вы познакомитесь с ними всеми по мере чтения этой книги.
Числа
Python имеет встроенную поддержку целых чисел (наподобие 5 и 1 000 000 000) и чисел с плавающей точкой (вроде 3,1416, 14,99 и 1,87е4). Вы можете вычислять комбинации чисел с помощью простых математических операторов, приведенных в таблице.| Оператор | Описание | Пример | Результат |
|---|---|---|---|
| + | Сложение | 5 + 8 | 13 |
| – | Вычитание | 90–10 | 80 |
| * | Умножение | 4 * 7 | 28 |
| / | Деление с плавающей точкой | 7/2 | 3,5 |
| // | Целочисленное (Truncating) деление | 7//2 | 3 |
| % | Modulus (вычисление остатка) | 7%3 | 1 |
| ** | Возведение в степень | 34 | 81 |
Целые числа
Любая последовательность цифр в Python считается целым числом:>>> 5
5
Можно использовать и простой ноль (0):
>>> 0
0
Но не ставьте его перед другими цифрами:
>>> 05
··File "<stdin>", line 1
····05
·····^
SyntaxError: invalid token
Последовательность цифр указывает на целое число. Если вы поместите знак + перед цифрами, число останется прежним:
>>> 123
123
>>> +123
123
Чтобы указать на отрицательное число, вставьте перед цифрами знак —:
>>> -123
-123
С помощью Python вы можете выполнять обычные арифметические действия, как и с обычным калькулятором, используя операторы, показанные в предыдущей таблице. Сложение и вычитание будут работать, полностью соответствуя вашим ожиданиям:
>>> 5 + 9
14
>>> 100–7
93
>>> 4–10
-6
Вы можете работать с любым количеством чисел и операторов:
>>> 5 + 9 + 3
17
>>> 4 + 3–2 — 1 + 6
10
Замечание по стилю: не обязательно вставлять пробел между каждым числом и оператором:
>>> 5+9···+······3
17
Такой формат выглядит лучше, и его проще прочесть.
Умножение тоже довольно привычно:
>>> 6 * 7
42
>>> 7 * 6
42
>>> 6 * 7 * 2 * 3
252
Операция деления чуть более интересна, поскольку существует два ее вида:
• с помощью оператора / выполняется деление с плавающей точкой (десятичное деление);
• с помощью оператора // выполняется целочисленное деление (деление с остатком).
Даже если вы делите целое число на целое число, оператор / даст результат с плавающей точкой:
>>> 9 / 5
1.8
Целочисленное деление даст вам целочисленный ответ, отбрасывая остаток:
>>> 9 // 5
1
Деление на ноль с помощью любого оператора сгенерирует исключение:
>>> 5 / 0
Traceback (most recent call last):
··File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 7 // 0
Traceback (most recent call last):
··File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by z
Во всех предыдущих примерах используются непосредственно целочисленные значения. Вы можете смешивать целочисленные значения и переменные, которым было присвоено целочисленное значение:
>>> a = 95
>>> a
95
>>> a — 3
92
Ранее, когда мы выполнили операцию a — 3, мы не присвоили результат переменной a, поэтому ее значение не изменилось:
>>> a
95
Если вы хотите изменить значение переменной а, придется сделать следующее:
>>> a = a — 3
>>> a
92
Это обычно сбивает с толку начинающих программистов, потому что благодаря изучению математики в школе мы видим знак = и думаем, что он указывает на равенство. В Python выражение, стоящее справа от знака =, вычисляется первым и только затем присваивается переменной с левой стороны.
Проще думать об этом так.
1. Вычитаем 3 из а.
2. Присваиваем результат этого вычитания временной переменной.
3. Присваиваем значение временной переменной а:
>>> a = 95
>>> temp = a — 3
>>> a = temp
Поэтому, когда вы говорите:
>>> a = a — 3
Python рассчитывает результат операции вычитания с правой стороны от знака =, запоминает результат, а затем присваивает его переменной а, которая находится с левой стороны. Это гораздо быстрее и приятнее глазу, чем использование временной переменной.
Вы можете совместить арифметические операторы с присваиванием, размещая оператор перед знаком =. В этом примере выражение а — = 3 аналогично выражению а = а — 3:
>>> a = 95
>>> a — = 3
>>> a
92
Это выражение аналогично выражению а = а + 8:
>>> a += 8
>>> a
100
А это — выражению а = а * 2:
>>> a *= 2
>>> a
200
Здесь представлен пример деления с плавающей точкой, а = а / 3:
>>> a /= 3
>>> a
66.66666666666667
Присвоим значение 13 переменной а, а затем попробуем использовать сокращенный вариант а = а // 4 (целочисленное деление):
>>> a = 13
>>> a //= 4
>>> a
3
Символ % имеет несколько разных применений в Python. Когда он находится между двух чисел, с его помощью вычисляется остаток от деления первого числа на второе:
>>> 9 % 5
4
Вот так можно получить частное и остаток одновременно:
>>> divmod(9,5)
(1, 4)
В противном случае вам пришлось бы считать их по отдельности:
>>> 9 // 5
1
>>> 9 % 5
4
Только что вы увидели кое-что новое: функцию с именем divmod, в которую передаются целые числа 9 и 5, возвращающую двухэлементный результат, называемый кортежем. С кортежами вы познакомитесь в главе 3, а с функциями — в главе 4.
Приоритет операций
Рассмотрим, что получится, если ввести следующее:>>> 2 + 3 * 4
Если выполнить сложение первым, 2 + 3 равно 5, а 5 * 4 равно 20. Но если выполнить первым умножение, 3 * 4 равно 12, а 2 + 12 равно 14. В Python, как и в большинстве других языков, умножение имеет больший приоритет, нежели сложение, поэтому вы увидите ответ, совпадающий со второй версией:
>>> 2 + 3 * 4
14
Как узнать приоритет той или иной операции? В приложении Е приводится огромная таблица, в которой перечислены все приоритеты, но я обнаружил, что на практике никогда не смотрю в эти правила. Гораздо проще добавить пару скобок, чтобы сгруппировать код и вычисления так, как нужно:
>>> 2 + (3 * 4)
14
Это поможет любому человеку, читающему код, точно определить его предназначение.
Системы счисления
Предполагается, что целые числа указываются в десятичной системе счисления, если только вы не укажете какую-либо другую. Вам может никогда не понадобиться использовать другие системы счисления, но иногда они будут встречаться в коде. Как правило, у нас десять пальцев на руках и ногах (у одного из моих котов их немного больше, но он редко использует их для счета), поэтому мы считаем: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. После этого у нас заканчиваются цифры и мы переносим единицу на место десятки и ноль — на место единицы: 10 означает «одна десятка и ноль единиц». У нас нет одной цифры, которая представляла бы собой 10. Далее мы считаем: 11, 12… 19, переносим единицу, чтобы сделать 20 (две десятки и ноль единиц), и т. д. Система счисления указывает, сколько цифр вы можете использовать до того, как перенести единицу. В двоичной (бинарной) системе счисления единственными цифрами являются 0 и 1. Двоичные 0 и 1 точно такие же, как и десятичные. Однако, если в этой системе сложить 1 и 1, вы получите 10 (одна десятичная двойка плюс ноль десятичных единиц). В Python вы можете выразить числа в трех системах счисления помимо десятичной: • 0b или 0B для двоичной системы (основание 2); • 0o или 0O для восьмеричной системы (основание 8); • 0x или 0X для шестнадцатеричной системы (основание 16). Интерпретатор выведет эти числа как десятичные. Попробуем воспользоваться каждой из систем счисления. Первой выберем старое доброе десятичное число 10, которое означает «одна десятка и ноль единиц»:>>> 10
10
Теперь возьмем двоичную (основание 2), что означает «одна (десятичная) двойка и ноль единиц»:
>>> 0b10
2
Восьмеричная (основание 8) означает «одна (десятичная) восьмерка и ноль единиц»:
>>> 0°10
8
Шестнадцатеричная (основание 16) означает «одна (десятичное) 16 и ноль единиц»:
>>> 0x10
16
Если вам интересно, какие «цифры» использует шестнадцатеричная система счисления, взгляните на них: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e и f. 0ха равно десятичной 10, а 0xf — десятичному 15. Добавьте 1 к 0xf, и вы получите 0х10 (десятичное 16).
Зачем использовать другие системы счисления, отличные от десятичной? Это полезно для битовых операций, которые описаны в главе 7 наряду с детальной информацией о преобразовании чисел из одной системы счисления в другую.
Преобразования типов
Для того чтобы изменить другие типы данных на целочисленный тип, следует использовать функцию int(). Она сохраняет целую часть числа и отбрасывает любой остаток. Простейший тип данных в Python — булевы переменные, значениями этого типа могут быть только True или False. При преобразовании в целые числа они представляют собой значения 1 и 0:>>> int(True)
1
>>> int(False)
0
Преобразование числа с плавающей точкой в целое число просто отсекает все, что находится после десятичной запятой[2]:
>>> int(98.6)
98
>>> int(1.0e4)
10000
Наконец, рассмотрим пример преобразования текстовой строки (со строками вы познакомитесь через несколько страниц), которая содержит только цифры и, возможно, знаки + и —:
>>> int('99')
99
>>> int('-23')
-23
>>> int('+12')
12
Преобразование целого числа в целое число ничего не меняет и совсем не вредит:
>>> int(12345)
12345
Если вы попробуете преобразовать что-то непохожее на число, сгенерируется исключение:
>>> int('99 bottles of beer on the wall')
Traceback (most recent call last):
··File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '99 bottles of beer on the wall'
>>> int('')
Traceback (most recent call last):
··File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: ''
Текстовая строка в предыдущем примере начинается с корректных символов-цифр (99), но продолжается теми символами, которые функция int() обработать не может.
Функция int() будет создавать целые числа из чисел с плавающей точкой или строк, состоящих из цифр, но она не будет обрабатывать строки, содержащие десятичные точки или экспоненты:
>>> int('98.6')
Traceback (most recent call last):
··File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '98.6'
>>> int('1.0e4')
Traceback (most recent call last):
··File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '1.0e4'
Если вы смешаете численные значения, Python будет пытаться автоматически преобразовать их:
>>> 4 + 7.0
11.0
Булево значение False рассматривается как 0 или 0.0, когда оно смешивается с целыми числами или числами с плавающей точкой, а True — как 1 или 1.0:
>>> True + 2
3
>>> False + 5.0
5.0
Насколько объемен тип int?
В Python 2 размер переменной типа int был ограничен 32 битами. Этого было достаточно для того, чтобы сохранить любое целое число в диапазоне от –2 147 483 648 до 2 147 483 647. Для переменных типа long выделялось еще больше места — 64 бита, что позволяло хранить значения в диапазоне от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807. В Python 3 тип long отсутствует, а переменная типа int может быть любого размера — даже больше 64 бит. Поэтому вы можете выполнить арифметические действия наподобие следующих (10**100 называется гугол (googol), компания Google называлась так до того, как решила сменить свое название на более простое):>>>
>>> googol = 10**100
>>> googol
100000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000
>>> googol * googol
100000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000
Во многих языках программирования этот пример вызовет так называемое переполнение целочисленного значения, когда числу нужно больше места, чем компьютер может предоставить, что приведет к разным нежелательным эффектам. Python обрабатывает огромные целые числа без всяких проблем. Одно очко для Python.
Числа с плавающей точкой
Значениями целочисленного типа являются целые числа, но числа с плавающей точкой (в Python они называются float) имеют десятичную запятую. Числа с плавающей точкой обрабатываются так же, как и целые: вы можете использовать операторы +, —, *, /, //, **, % и функцию divmod(). Для того чтобы преобразовать другие типы в тип float, следует использовать функцию float(). Как и ранее, булевы значения обрабатываются как небольшие числа:>>> float(True)
1.0
>>> float(False)
0.0
Преобразование значения типа int в тип float лишь создаст счастливого обладателя десятичной запятой:
>>> float(98)
98.0
>>> float('99')
99.0
Вы также можете преобразовывать строки, содержащие символы, которые являются корректным числом с плавающей точкой (цифры, знаки, десятичная запятая или е, за которой следует экспонента):
>>> float('98.6')
98.6
>>> float('-1.5')
-1.5
>>> float('1.0e4')
10000.0
Математические функции
Python имеет привычный набор математических функций вроде квадратного корня, косинуса и т. д. Мы рассмотрим их в приложении В, где также обсудим применение Python в науке.Строки
Непрограммисты думают, что программисты хорошо разбираются в математике, потому что работают с числами. На самом деле большинство программистов работают с текстовыми строками гораздо чаще, чем с числами. Логическое (и креативное!) мышление для них зачастую гораздо важнее математических навыков. Благодаря поддержке стандарта Unicode Python 3 может содержать символы любого языка мира, а также многие другие символы. Необходимость работы с этим стандартом была одной из причин изменения Python 2. Это хорошая причина использовать версию 3. Я буду применять стандарт Unicode лишь иногда, поскольку это может показаться сложным. В следующих примерах я буду использовать строки формата ASCII. Строки являются первым примером последовательностей в Python. В частности, они представляют собой последовательности символов. В отличие от других языков, в Python строки являются неизменяемыми. Вы не можете изменить саму строку, но можете скопировать части строк в другую строку, чтобы получить тот же эффект. Скоро вы узнаете, как это делается.Создаем строки с помощью кавычек
Строка в Python создается заключением символов в одинарные или двойные кавычки, как показано в следующем примере:>>> 'Snap'
'Snap'
>>> "Crackle"
'Crackle'
Интерактивный интерпретатор выводит на экран строки в одинарных кавычках, но все они обрабатываются одинаково.
Зачем иметь два вида кавычек? Основная идея заключается в том, что вы можете создавать строки, содержащие кавычки. Внутри одинарных кавычек можно расположить двойные и наоборот:
>>> "'Nay,' said the naysayer."
"'Nay,' said the naysayer."
>>> 'The rare double quote in captivity: ".'
'The rare double quote in captivity: ".'
>>> 'A "two by four" is actually 1 1/2" × 3 1/2".'
'A "two by four is" actually 1 1/2" × 3 1/2".'
>>> "'There's the man that shot my paw!' cried the limping hound."
"'There's the man that shot my paw!' cried the limping hound."
Можно также использовать три одинарные (''') или три двойные кавычки ("""):
>>> '''Boom!'''
'Boom'
>>> """Eek!"""
'Eek!'
Тройные кавычки не очень полезны для таких коротких строк. Они обычно используются для того, чтобы создать многострочные строки, наподобие следующего классического стихотворения Эдварда Леара (Edward Lear):
>>> poem =··'''There was a Young Lady of Norway,
… Who casually sat in a doorway;
… When the door squeezed her flat,
… She exclaimed, "What of that?"
… This courageous Young Lady of Norway.'''
>>>
(Это стихотворение было введено в интерактивный интерпретатор, который поприветствовал нас символами >>> в первой строке и выводил символы … до тех пор, пока мы не ввели последние тройные кавычки и не перешли к следующей строке.)
Если бы вы попробовали создать стихотворение с помощью одинарных кавычек, Python начал бы волноваться, когда бы вы перешли к следующей строке:
>>> poem = 'There was a young lady of Norway,
··File "<stdin>", line 1
····poem = 'There was a young lady of Norway,
············································^
SyntaxError: EOL while scanning string literal
>>>
Если внутри тройных кавычек располагается несколько строк, символы конца строки будут сохранены внутри нее. Если перед строкой или после нее находятся пробелы, они также будут сохранены:
>>> poem2 = '''I do not like thee, Doctor Fell.
…·····The reason why, I cannot tell.
…·····But this I know, and know full well:
…·····I do not like thee, Doctor Fell.
… '''
>>> print(poem2)
I do not like thee, Doctor Fell.
····The reason why, I cannot tell.
····But this I know, and know full well:
····I do not like thee, Doctor Fell.
>>>
Кстати, существует разница между выводом на экран с помощью функции print() и автоматическим выводом на экран с помощью интерактивного интерпретатора:
>>> poem2
'I do not like thee, Doctor Fell.\n····The reason why, I cannot tell.\n····But
this I know, and know full well: \n····I do not like thee, Doctor Fell.\n'
Функция print() извлекает кавычки из строк и выводит на экран их содержимое. Она предназначена для удобства пользователя. Эта функция любезно добавляет пробел между каждым выводимым объектом, а также символ новой строки в конце:
>>> print(99, 'bottles', 'would be enough.')
99 bottles would be enough.
Если вам не нужны пробелы или переход на новую строку, вскоре вы узнаете, как избежать их появления.
Интерпретатор выводит строку с одинарными кавычками и управляющими символами вроде \n, что объясняется в подразделе «Создаем управляющие символы с помощью символа \» далее в текущем разделе.
Наконец, вам может понадобиться работать с пустой строкой. В ней нет символов, но она совершенно корректна. Вы можете создать пустую строку с помощью любых упомянутых ранее кавычек:
>>> ''
''
>>> ""
''
>>> ''''''
''
>>> """"""
''
>>>
Зачем может понадобиться пустая строка? Иногда приходится компоновать строку из других строк и для этого нужно начать с чистого листа, то есть с пустой строки.
>>> bottles = 99
>>> base = ''
>>> base += 'current inventory: '
>>> base += str(bottles)
>>> base
'current inventory: 99'
Преобразование типов данных с помощью функции str()
Вы можете преобразовывать другие типы данных Python в строки с помощью функции str():>>> str(98.6)
'98.6'
>>> str(1.0e4)
'10000.0'
>>> str(True)
'True'
В Python функция str() также используется для внутренних нужд, когда вы вызываете функцию print() для объектов, которые не являются строками, и при выполнении интерполяции строк, с которой вы познакомитесь в главе 7.
Создаем управляющие символы с помощью символа \
Python позволяет вам создавать управляющие последовательности внутри строк, чтобы добиться эффекта, который по-другому было бы трудно выразить. Размещая перед символом обратный слеш (\), вы наделяете этот символ особым значением. Наиболее распространена последовательность \n, которая означает переход на новую строку. С ее помощью вы можете создать многострочные строки из однострочных:>>> palindrome = 'A man,\nA plan,\nA canal: \nPanama.'
>>> print(palindrome)
A man,
A plan,
A canal:
Panama.
Вы также увидите последовательность \t (табуляция), которая используется для выравнивания текста:
>>> print('\tabc')
····abc
>>> print('a\tbc')
a····bc
>>> print('ab\tc')
ab······c
>>> print('abc\t')
abc
В последней строке табуляция стоит в конце, ее вы, конечно, увидеть не можете.
Кроме того, вам могут понадобиться последовательности \' или \", чтобы поместить в строку одинарные или двойные кавычки, которые окружены таким же символом:
>>> print('\tabc')
····abc
>>> print('a\tbc')
a····bc
>>> print('ab\tc')
ab······c
>>> print('abc\t')
abc
А если вам нужен обратный слеш, просто напечатайте два:
>>> speech = 'Today we honor our friend, the backslash: \\.'
>>> print(speech)
Today we honor our friend, the backslash: \.
Объединяем строки с помощью символа +
Вы можете объединить строки или строковые переменные в Python с помощью оператора +, как показано далее:>>> 'Release the kraken! ' + 'At once!'
'Release the kraken! At once!'
Можно также объединять строки (не переменные), просто расположив одну перед другой:
>>> "My word! " "A gentleman caller!"
'My word! A gentleman caller!'
Python не добавляет пробелы за вас при конкатенации строк, поэтому в предыдущем примере нужно явно добавить пробелы. Далее мы добавляем пробелы между каждым аргументом выражения print(), а также символ новой строки в конце:
>>> a = 'Duck.'
>>> b = a
>>> c = 'Grey Duck!'
>>> a + b + c
'Duck.Duck.Grey Duck!'
Размножаем строки с помощью символа *
Оператор * можно использовать для того, чтобы размножить строку. Попробуйте ввести в интерактивный интерпретатор следующие строки и посмотреть, что получится:>>> start = 'Na ' * 4 + '\n'
>>> middle = 'Hey ' * 3 + '\n'
>>> end = 'Goodbye.'
>>> print(start + start + middle + end)
Извлекаем символ с помощью символов []
Для того чтобы получить один символ строки, задайте смещение внутри квадратных скобок после имени строки. Смещение первого (крайнего слева) символа равно 0, следующего — 1 и т. д. Смещение последнего (крайнего справа) символа может быть выражено как –1, поэтому вам не придется считать, в таком случае смещение последующих символов будет равно –2, –3 и т. д.:>>> letters = 'abcdefghijklmnopqrstuvwxyz'
>>> letters[0]
'a'
>>> letters[1]
'b'
>>> letters[-1]
'z'
>>> letters[-2]
'y'
>>> letters[25]
'z'
>>> letters[5]
'f'
Если вы укажете смещение, равное длине строки или больше (помните, смещения лежат в диапазоне от 0 до длины строки –1), сгенерируется исключение:
>>> letters[100]
Traceback (most recent call last):
··File "<stdin>", line 1, in <module>
IndexError: string index out of range
Индексирование работает и для других типов последовательностей (списков и кортежей), которые мы рассмотрим в главе 3.
Поскольку строки неизменяемы, вы не можете вставить символ непосредственно в строку или изменить символ по заданному индексу. Попробуем изменить слово Henny на слово Penny и посмотрим, что произойдет:
>>> name = 'Henny'
>>> name[0] = 'P'
Traceback (most recent call last):
··File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
Вместо этого вам придется использовать комбинацию строковых функций вроде replace() или slice (ее вы увидите совсем скоро):
>>> name = 'Henny'
>>> name.replace('H', 'P')
'Penny'
>>> 'P' + name[1:]
'Penny'
Извлекаем подстроки с помощью оператора [start: end: step]
Из строки можно извлечь подстроку (часть строки) с помощью функции slice. Вы определяете slice с помощью квадратных скобок, смещения начала подстроки start и конца подстроки end, а также опционального размера шага step. Некоторые из этих параметров могут быть исключены. В подстроку будут включены символы, расположенные начиная с точки, на которую указывает смещение start, и заканчивая точкой, на которую указывает смещение end. • Оператор [: ] извлекает всю последовательность от начала до конца. • Оператор [start: ] извлекает последовательность с точки, на которую указывает смещение start, до конца. • Оператор [: end] извлекает последовательность от начала до точки, на которую указывает смещение end минус 1. • Оператор [start: end] извлекает последовательность с точки, на которую указывает смещение start, до точки, на которую указывает смещение end минус 1. • Оператор [start: end: step] извлекает последовательность с точки, на которую указывает смещение start, до точки, на которую указывает смещение end минус 1, опуская символы, чье смещение внутри подстроки кратно step. Как и ранее, смещение слева направо определяется как 0, 1 и т. д., а справа налево — как -1, -2 и т. д. Если вы не укажете смещение start, функция будет использовать в качестве его значения 0 (начало строки). Если вы не укажете смещение end, функция будет использовать конец строки. Создадим строку, содержащую английские буквы в нижнем регистре:>>> letters = 'abcdefghijklmnopqrstuvwxyz'
Использование простого двоеточия аналогично использованию последовательности 0: (целая строка):
>>> letters[: ]
'abcdefghijklmnopqrstuvwxyz'
Вот так можно получить все символы, начиная с 20-го и заканчивая последним:
>>> letters[20:]
'uvwxyz'
А теперь — начиная с 10-го и заканчивая последним:
>>> letters[10:]
'klmnopqrstuvwxyz'
А теперь получим символы с 12-го по 14-й (Python не включает символ, расположенный под номером, который указан последним):
>>> letters[12:15]
'mno'
Последние три символа:
>>> letters[-3:]
'xyz'
В следующем примере мы начинаем со смещения 18 и идем до четвертого с конца символа. Обратите внимание на разницу с предыдущим примером, где старт с позиции -3 получал символ х. В этом примере конец диапазона -3 означает, что последним будет символ по адресу -4 — w:
>>> letters[18:-3]
'stuvw'
В следующем примере мы получаем символы, начиная с шестого с конца и заканчивая третьим с конца:
>>> letters[-6:-2]
'uvwx'
Если вы хотите увеличить шаг, укажите его после второго двоеточия, как показано в нескольких следующих примерах.
Каждый седьмой символ с начала до конца:
>>> letters[::7]
'ahov'
Каждый третий символ, начиная со смещения 4 и заканчивая 19-м символом:
>>> letters[4:20:3]
'ehknqt'
Каждый четвертый символ, начиная с 19-го:
>>> letters[19::4]
'tx'
Каждый пятый символ от начала до 20-го:
>>> letters[:21:5]
'afkpu'
Опять же значение end должно быть на единицу больше, чем реальное смещение.
И это еще не все! Если задать отрицательный шаг, любезный Python будет двигаться в обратную сторону. В следующем примере движение начинается с конца и заканчивается в начале, ни один символ не пропущен:
>>> letters[-1::-1]
'zyxwvutsrqponmlkjihgfedcba'
Оказывается, можно добиться того же результата, использовав такой пример:
>>> letters[::-1]
'zyxwvutsrqponmlkjihgfedcba'
Операция slice более мягко относится к неправильным смещениям, чем поиск по индексу. Если указать смещение меньшее, чем начало строки, оно будет обрабатываться как 0, а если указать смещение большее, чем конец строки, оно будет обработано как –1. Это показано в следующих примерах.
Начиная с –50-го символа и до конца:
>>> letters[-50:]
'abcdefghijklmnopqrstuvwxyz'
Начиная с –51-го символа и заканчивая –50-м:
>>> letters[-51:-50]
''
От начала до 69-го символа:
>>> letters[:70]
'abcdefghijklmnopqrstuvwxyz'
Начиная с 70-го символа и заканчивая 70-м:
>>> letters[70:71]
''
Получаем длину строки с помощью функции len()
До этого момента мы использовали специальные знаки препинания вроде +, чтобы манипулировать строками. Но существует не так уж много подобных функций. Теперь мы начнем использовать некоторые встроенные функции Python: именованные фрагменты кода, которые выполняют определенные операции. Функция len() подсчитывает символы в строке:>>> len(letters)
26
>>> empty = "" ... Все права на текст принадлежат автору: Билл Любанович.
Это короткий фрагмент для ознакомления с книгой.