Linuxformat - Вклад участника [ru]

LXF120:Python

2010-09-13T00:43:52Z

Newacct:

: '''''Python''''' Заставим Web доставлять нужное содержимое вам на блюдечке

==''Python'': Сеть на ваш вкус==

{{Цикл/Python}}

: '''Часть 1''': Недовольны, что контент раскидан где попало и как попало? '''Ник Вейч''' приступает к объяснению, как подчинить сеть вашим целям.

Что бы вам ни захотелось узнать, оно, вероятно, найдется в Сети. Это загадочное облако – иногда белое и пушистое, а иногда и полное грязных инсинуаций – содержит знания любого сорта, хотя до них надо еще докопаться. Готовы поспорить, что отыщется даже точная дата крещения «Наболиона Буонапарте», если порыться старательно.

Но не вся информация в сети статична, соединена разумным образом или вообще настолько хороша, насколько должно быть. Вот почему одним из заметных шагов пост-web 2.0 является мэшап ['''мэшап, mashup – технология построения web-сайта с объединением возможностей группы сторонних web-приложений, см. http://ru.wikipedia.org/wiki/Мэшап_(веб), – прим. пер.'''] – преобразование web-содержимого в новые удивительные формы. Добро пожаловать в мир панк-данных.

===Куда дует ветер===

Для начала нашего путешествия сделаем что-нибудь попроще, типа изменения фона рабочего стола в зависимости от погоды. Приложения и виджеты, предоставляющие такой сервис, уже имеются, а значит, данные должно быть легко добыть в Интернете. Быстрый поиск по словосочетанию «weather API data» непременно выдаст множество ссылок. Наши критерии: API должны быть понятны, охватывать как можно большую часть мира и иметь приличную документацию. Под них подпадает лишь пара из предложенных источников, в основном в связи с документацией – ну да, можно потратить время на распутывание данных или работы API, но зачем, если есть кому предоставить и данные, и руководство по их использованию?

{{Врезка|Содержание=[[Изображение:LXF120_66_1.jpg|300px]] Получить идентификатор вашей местности можно прямо у онлайн-службы Yahoo, просто скопировав открытый ею URL.|Ширина=300px}}

Пошарив там и сям, мы решили, что нас устраивает служба погоды Yahoo. Она проста и обладает достаточной документацией, чтобы начать без особых усилий. Еще чуток порывшись, мы обнаружили http://develoPer.yahoo.com/weather, где предоставлено множество деталей и пара примеров использования службы. Очко в пользу Yahoo!

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

«St. Petersburg» даст нам http://weather.yahoo.com/forecast/RSXX0091.html – значит, код нашей местности RSXX0091. Теперь у нас есть информация о местоположении. Инструкция также говорит, что можно добавить параметр для выбора температуры по Фаренгейту или по Цельсию, и мы добавили к URL опцию по Цельсию '''u=c'''. Теперь протестируем URL, чтобы увидеть как он работает (о написании кода речи все еще нет).

Приличный браузер, вроде ''Firefox'', способен отобразить RSS-ленту в удобной форме – надо всего лишь ввести ее URL: http://weather.yahooapis.com/forecastrss?p=RSXX0091&u=c.

===Обработчик ленты===

Теперь, зная, что нужная нам информация доступна в виде RSS-ленты, как заполучить ее в скрипт ''Python'' и декодировать? Скопировав указанный выше URL в ''Firefox'' и выбрав в меню '''Вид > Исходный код''', вы увидите кучу информации плюс всякие заголовки и прочее. Можно создать обработчик, который возьмет эти сырые данные и выудит из них соответствующие куски – но, как обычно и бывает, кто-то его уже создал. Для ''Python'' имеется библиотечный модуль под названием ''Feedparser'', создающий объект ''Python'' из RSS-потока. Проще всего установить его через менеджер пакетов: другие способы малость утомительны.

После установки ''Feedparser'' наконец-то настает время кодирования. Сначала запустите ''Python'' из командной строки, чтобы понимать, с чем мы имеем дело. Вы окажетесь в интерактивной оболочке ''Python'', где мы и введем:

{{Врезка|left|Заголовок=Скорая помощь|Содержание=''Python'' требователен к синтаксису. Он требует выделять отступами блоки многострочных выражений, функций и условных операторов. Количество пробелов в отступе роли не играет: главное, чтобы оно сохранялось внутри блока.|Ширина=200px}}

<source lang=Python>
>>> import feedparser
>>> url = “http://weather.yahooapis.com/forecastrss?p=RSXX0091&u=c”
>>> data = feedparser.parse(url)
>>> data
</source>

{{Врезка|Содержание=[[Изображение:LXF120_67_1.jpg|300px]] Убедитесь, что передаваемый URL выдает RSS-ленту, через ''Firefox'', который ее тут же отобразит|Ширина=300px}}

Результатом действия последней строки будет выдача вереницы символов, которая представляет собой ленту. К счастью, хотя она и похожа на набор случайных данных, пронизанных частоколом скобок, на деле это хорошо структурированный объект. Чтобы убедиться в этом, попробуйте ввести в оболочке ''Python'' следующее:

<source lang=Python>
>>>for x in data:
... print x
...
feed
status
version
encoding
bozo
headers
etag
href
namespaces
entries
</source>

Это цикл, пробегающий по всем объектам внутри '''data'''. Одно из замечательных свойств ''Python'' – легкость работы с объектами, и даже возможность заставить их рассказать о себе. Например, пусть мы хотим точно знать, с каким типом объектов работаем:

<source lang=Python>
>>>type(data)
<class 'feedparser.FeedParserDict'>
</source>

Ну, отчасти нам это помогло. Если вы уже сталкивались с ''Python'', то, вероятно, слышали про объекты-словари (ассоциативные массивы) – они просто хранят данные в виде пар ключ = значение. Объекты, список которых мы только что выводили, являются в данном случае ключами. Обратившись к документации ''Feedparser'', мы получим несколько более внятное представление, что хранят такие ключи, поскольку они стандартны для объектов ''Feedparser''. Из них для нас важен ключ entries. Он хранит объект-список отдельных записей RSS-ленты, которые и составляют ее реальное содержимое.

Списки ''Python'' нумеруются с индекса '''0''', поэтому, чтобы сослаться на объект первой записи, следует использовать:

<source lang=Python>
>>> data.entries[0]
{'updated': u'Thu, 28 May 2009 2:00 am MSD', 'yweather_condition': u'', 'updated_parsed': ...
>>> for x in data.entries[0]
... print x
...
updated
yweather_condition
updated_parsed
links
title
summary_detail
geo_lat
summary
guidislink
title_detail
link
geo_long
yweather_forecast
id
</source>

И вновь мы имеем объект-словарь с парами ключей и значений. На сей раз они определяются самой XML-структурой ленты, поэтому для данного объекта нет модуля с голубой каемочкой; зато его элементы документированы на сайте Yahoo. После недолгого изучения становится ясно, что полезна нам будет сводка ('''summary''') текущих погодных условий, включая температуру.

Налицо небольшая проблема: необходимые данные отнюдь не сосредоточены в одном поле нам на радость. Эта часть ленты – HTML-код для отображения на web-странице, а нам нужен только текст.

===Регулярные выражения===

{{Врезка|Заголовок=Регулярные выражения|Содержание=Регулярные выражения заполонили все вокруг. Они бывают и простенькими, и дьявольски сложными. Вкратце, регулярное выражение – это группа знаков, определяющая некую конфигурацию символов в строке. Имеются также специальные знаки, типа местозаполнителей, которые подразумевают любой символ. Кроме того, есть еще списки, группы и даже операторы для объединения соответствий – можно, например, создать регулярное выражение, полностью описывающее все базы для поиска.

При создании шаблона лучше всего воспользоваться инструментом, который поможет вам проверить его корректность – даже один неверный символ чреват катастрофой! Среди лучших подобных инструментов – онлайн-построитель регулярных выражений http://gskInner.com/RegExr/. Вставьте в него пример текста и протестируйте свои навыки создания шаблонов. Не помешает и обратиться к документации: http://docs.python.org/library/re.html.

[[Изображение:LXF120_69_1.jpg|300px]] Регулярные выражения не всякому по плечу; нам поможет служба http://gskinner.com/RegExr/|Ширина=300px}}

От регулярных выражений (также известных как «регекспы» [regex]) никуда не денешься – они будут все чаще встречаться на вашем пути переустройства мира. Регулярные выражения – это просто способ выполнения поиска и замены, и хотя они смахивают на криптограммы, разобраться в них не так уж трудно. В данном случае нам надо всего лишь избавиться от нудных HTML-тэгов. Мы, вероятно, и без того извлекли бы нужные данные, но подобный опыт пригодится нам в будущем, если мы захотим приспособить наш скрипт к работе с различными источниками.

Мы импортируем ''Python''-модуль '''re''' (он включен в качестве одной из стандартных библиотек, так что ничего загружать и устанавливать не придется) и привлечем его к работе с этим текстом. На нашем уроке нет места на детальное объяснение работы регулярных выражений, а за краткими сведениями обратитесь ко врезке '''Регулярные выражения''' или статье из [[LXF80:Регулярные_выражения.|LXF80]].

Выражением мы хотим охватить все, что обрамлено знаками «больше» и «меньше», используемыми для обозначения HTML-тэгов. Это очень легко; выражение будет выглядеть как <, за которым следует шаблон любого символа, повторенный любое количество раз, то есть .'''+?''' и в конце '''>'''. '''+?''' – то же, что и '''+''', но это «ленивое» соответствие: оно отвечает наикратчайшей корректной строке. А нам того и надо – все, что находится между '''<>'''; других вариантов нет.

<source lang=Python>
>>>summary = data.entries[0].summary
>>>import re
>>>pattern = '<.+?>'
>>>temp = re.sub(pattern,'',summary)
>>>temp
u'\nCurrent Conditions:\nLight Rain Shower, 12 C\nForecast:\nThu – Partly Cloudy. High: 25 Low:12\nFri – Mostly Sunny. High: 19 Low:
9\n\nFull Forecast at Yahoo! Weather\n(provided by The Weather Channel)’
</source>

Теперь текст очищен от тэгов HTML; но в нем остались переводы строк. Вообще-то есть стандартный модуль для преобразования такой строки в список, но у нас уже загружен модуль re, и мы вполне можем им обойтись. Для поиска символов новой строки надо объяснить ''Python'', что мы хотим использовать чистое (raw) значение строки – поместив перед ней символ '''r'''.

{{Врезка|Заголовок=Почему ''Python''?|Содержание=Можно, естественно, писать скрипты и приложения для обработки web-данных на любом другом языке; так почему же мы выбрали ''Python'', а не ''C#'', например? На то есть веские причины. ''Python'' – язык простой и понятный, код на нем легко пишется и (что, вероятно, еще важнее) легко читается. Он обладает прекрасными возможностями для работы с текстом (которым по большей части и являются наши данные), он кросс-платформенный и снабжен бездной полезных библиотек для web-служб и протоколов. Используя ''Python'' и пару библиотек, можно мигом создать рабочее приложение или скрипт.|Ширина=200px}}

<source lang=Python>
>>> temp = re.split(r'\n',temp)
>>> temp
[u'', u'Current Conditions:', u'Light Rain Shower, 12 C', u'Forecast:', u'Thu – Partly Cloudy. High: 25 Low: 12', u'Fri – Mostly Sunny. High:
19 Low: 9', u'', u'Full Forecast at Yahoo! Weather', u'(provided by The Weather Channel)']
>>>temp[2]
u'Light Rain Shower, 12 C'
</source>

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

<source lang=Python>
>>>temp = re.findall(u'[0‑9]+',temp[2])[0]
>>>temp
u'12'
>>>>>> temp = int(temp)
>>> temp
12
</source>

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

===Перемена погоды===

{{Врезка|Содержание=[[Изображение:LXF120_68_2.jpg|300px]] Сберегите свой рассудок — для написания кода ''Python'' пользуйтесь IDE; это сильно упрощает обнаружение ошибок.|Ширина=300px}}

Как переделать обои? А для этого в ''Python'' есть вызов внешних команд. В Gnome можно изменить заставку командой ''gconftool-2'', устанавливающей переменную окружения, в которой хранится размещение и имя файла обоев. Оно бы и достаточно. Но поскольку у нас возможны варианты, лучше оформить это в виде функции.

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

<source lang=Python>
>>> def change_wallpaper(filename):
... cmd = 'gconftool-2 -s /desktop/gnome/background/picture_filename -t string "' + filename + '"'
... os.system(cmd)
...
>>> change_wallpaper('plop.jpg')
</source>

Первая строка функции создает команду оболочки, а вызов '''os.system'' выполняет ее. Вызов функции меняет переменную окружения, и загружается новое изображение. Подставленное нами имя файла '''filename''' – просто параметр; в реальности, хорошо бы хранить ваши изображения где-нибудь внутри вашего домашнего каталога, допустим, в подкаталоге с именем '''weather''', и называть их согласно погодным условиям.

Сейчас Gnome допускает в качестве обоев SVG-изображения, и вы можете создать этакую изысканную масштабируемую картину для вашего рабочего стола.
Не знаем, как по-вашему, но мы думаем, что здесь должно быть пять изображений: freezing [мороз], cold [холод], mild [средне], warmish [тепло] и hot [жарко]. Диапазоны температур выбирайте в соответствии с вашим климатом, а мы присвоим следующие: ниже 0°C – мороз, 0–8 – холод, 9–15 – средне, 16–25 – тепло, выше – жарко. В некоторых языках для реализации проверки предусмотрена конструкция '''case/switch'''. В ''Python'' ее нет, и мы нагородим огород из конструкций '''if/elif/else''', вот так:

{{Врезка|Содержание=[[Изображение:LXF120_68_1.jpg|300px]] Кого же не согреет милый снегопад на SVG-обоях рабочего стола? Они могут быть вашими.|Ширина=300px}}

<source lang=Python>
>>> if (temp <0):
.. change_wallpaper('/home/evilnick/weather/freezing.svg')
... elif (temp<9):
.. change_wallpaper('/home/evilnick/weather/snow.svg')
... elif (temp<16):
.. change_wallpaper('/home/evilnick/weather/mild.svg')
... elif (temp<26):
.. change_wallpaper('/home/evilnick/weather/warm.svg')
... else:
.. change_wallpaper('/home/evilnick/weather/hot.svg')
...
</source>

Объединив все это в один скрипт, мы получим нечто подобное следующему (остается только разжиться изображениями):

<source lang=Python>
#!/usr/bin/python
# -*- coding: utf-8 -*-
import feedparser,re,os,string
def change_wallpaper(filename):
cmd = 'gconftool-2 -s /desktop/gnome/ background/picture_filename -t string "'+filename+'"'
os.system(cmd)
url = “http://weather.yahooapis.com/
forecastrss?p=RSXX0091&u=c”
data = feedparser.parse(url)
# extract the summary from the data
summary = data.entries[0].summary
temp = re.split(r'\n',re.sub('<.+?>','',summary))
temp = int(re.search('\d+',temp[2]).group())
if temp <0:
change_wallpaper('/home/evilnick/weather/freezing.svg')
elif temp<9:
change_wallpaper('/home/evilnick/weather/snow.svg')
elif temp<16:
change_wallpaper('/home/evilnick/weather/mild.svg')
elif temp<26:
change_wallpaper('/home/evilnick/weather/warm.svg')
else:
change_wallpaper('/home/evilnick/weather/hot.svg')
</source>

{{Врезка|Заголовок=Форматы web-данных|Содержание=Мы осознали, что есть масса web-приложений, способных доставить нам данные. Но вы ведь не ждали, что все будет просто, не так ли? Протоколов или способов предоставления данных немало, и некоторые сайты (например, Flickr) даже предусматривают более одного варианта. Еще одно неудобство – разнобой в их использовании на сайтах. В нашей серии уроков мы постепенно все это рассмотрим.|Ширина=200px}}

Конечно, даже при буйном воображении это не полноценное приложение, а небольшой сценарий, но его вполне можно взять за основу. На данном уроке мы взяли данные из сети и автоматически совместили их с контекстом рабочего стола. Мы увидели, как просто выглядят RSS-ленты и как работать с объектами в ''Python''; постигли ужасы регулярных выражений; и рассмотрели совершение из ''Python'' системных вызовов для выполнения внешних команд. Вот так мы и можем, исследуя сервисы всемирной паутины, брать что угодно и ставить себе на службу.

Скрипт легко расширить (например, позволив пользователям выбирать местоположение) или преобразовать его в апплет. Покамест он завершился бы с ошибкой при отсутствии подключения к Интернету, что не есть хорошо, но на следующих уроках мы изучим, как с этим справиться. Оставайтесь с нами! '''LXF'''

LXF121:Python

2010-07-10T20:40:28Z

Newacct:

: '''''Python''''' Заставим Web доставлять нужное содержимое вам на блюдечке

==''Python'': Создаем говорящего бота==

{{Цикл/Python}}

: '''Часть 2:''' Думаете, жизнь может быть лучше? Она и станет лучше, если вы, следуя '''Нику Вейчу''', создадите себе бота – чтоб вкалывал за вас.

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

Нечасто используемым, но удобным способом общения с подобными существами является чат. Стоит ли связываться с хитроумными ''SSH''-туннелями или нудными сервисами на базе web, если можно легко общаться с помощью средства, из которого вы и так не вылезаете? В свете вышесказанного, наш маленький
подручный будет чат-ботом: пусть сидит на канале чата и ждет, когда хозяин подаст голос; или, допустим, при случае проявляется и сообщает вам о чем-нибудь.

===Я ''Xmpppy''===

Протокол Jabber/XMPP отлично поддерживается ''Python''. Он реализован в рамках всеобъемлющего сетевого модуля ''Twisted'', но есть и более легковесная версия, подходящая для наших нужд, по имени ''Xmpppy''. В вашем дистрибутиве наверняка имеется этот пакет, но можно скачать код ''Python'' с сайта http://xmpppy.sourceforge.net.

Чтобы разобраться в ''Xmpppy'', начнем с примеров командной строки. Но сперва обзаведемся тестовой учетной записью: разве ваш бот не заслужил собственного имени пользователя в Google? Для тестирования вам понадобятся как минимум два идентификатора '''Jabber ID'''. Итак, мы зарегистрировали учетную запись Gmail специально для бота, вошли через web-браузер и пригласили другого пользователя Gmail в чат. Можно было бы настроить все это
в самом ''Xmpppy'', но так будет сложнее: для первичного тестирования лучше иметь две учетных записи, которые могут общаться друг с другом. После этого наберите в оболочке ''python'' для доступа к интерактивной командной строке ''Python'':

<source lang=python>
>>> import xmpp
>>> jid=xmpp.protocol.JID(“botaddress@gmail.com”)
</source>

Это мы установили '''ID Jabber'''. Он сильно смахивает на адрес электронной почты, потому что мы для целей нашего урока взяли учетную запись Google; однако любой другой '''Jabber ID''' тоже подойдет. Он состоит из двух частей (а может и из трех, но об этом потом): имя пользователя и домен. Домен – это место, где ''Xmpppy'' будет искать сервер.

Создав пользователя, надо создать и экземпляр клиента. Клиент в ''Xmpppy'' – это объект, который контролирует соединение, обрабатывает сообщения и вообще взаимодействует с сервером. Клиент и его подключение создаются за несколько шагов: сначала нужно создать экземпляр клиента (в качестве аргумента потребуется '''Jabber ID'''), а затем мы попробуем соединиться с сервером. Установив соединение, нужно аутентифицироваться для выполнение дальнейших действий.

{{Врезка|Заголовок=Скорая попомщь|Содержание=Безопасность вашего бота легко укрепить, ограничив ему прием команд только одним конкретным ID.|Ширина=200px}}

<source lang=python>
>>> myclient=xmpp.Client(jid.getDomain(),debug=[])
>>> myclient.connect()
‘tls’
>>> myclient.auth(jid.getNode(),’botpasswd’)
‘sasl’
</source>

Здесь нужно обратить внимание на пару моментов. Сперва мы создали экземпляр клиента и вызвали метод '''jid.getDomain''' для получения имени сервера из созданного нами объекта '''jid'''. Далее, вас просят еще указать уровень отладки, определяющий качество обратной связи, которую вы получаете. Мы установили свой на пустой список, но если вам охота завалить себе экран сообщениями, добавьте в него строку '''always'''. Впрочем, при наличии проблем сообщения могут и пригодиться.

===Даешь ''Disco''===

''XMPP'' включает структуру модулей расширения под названием ''Disco''. Они обогащают протокол другими типами сообщений, включая SIP (голосовые) и передачу файлов, и всеми мыслимыми возможностями, для которых применяется сеть «точка–точка». Так почему бы не прибавить функциональности и нашему боту – например, превратить его в хранилище файлов или чтеца новостей?

К счастью, Google расширил свою реализацию ''XMPP'' некоторыми дополнительными функциями, подробную информацию о которых вы найдете на сайте http://code.google.com/apis/talk/jep_extensions/extensions.html.

===Создание соединения===

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

При малой прыткости ваших пальцев и в зависимости от вашего сервера, следующий шаг может не сработать: серверы Google ожидают от вас быстрой аутентификации соединения, в противном случае оно оборвется, оставив вас скрести в затылке и раздумывать, что за беда тут стряслась. Вам дается всего несколько секунд, и вы, возможно, захотите объединить следующие строки вместе:
<source lang=python>
>>> myclient.connect() ; myclient.auth(jid.getNode(),’botpasswd’)
‘tls’
‘sasl’
</source>

Результат '''sasl''' говорито том, что соединение аутентифицировано с использованием SASL (Simple Authentification and Security Layer, Простая аутентификация и слой безопасности) посредством вашего пароля. Последний шаг установки соединения – объявление вашего статуса. Как вы знаете, в Google Chat и других сервисах ''Jabber'' существует несколько различных уровней статусов клиентов (например, Доступен или Занят). Кроме всего прочего, они используются сервером для составления списков доступных контактов, а в ''Xmpppy ''для этого существует специальный метод:

<source lang=python>
myclient.sendInitPresence()
</source>

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

Послание в бутылке
Ура, есть контакт! Теперь, прежде чем заняться скучными вещами, давайте составим и отправим сообщение нашему оппоненту (хороший кандидат – ваш собственный адрес Google). Однако сначала нужно обзавестись адресом, куда требуется доставить сообщение, и его текстом. После этого создадим сообщение и отправим его
<source lang=python>
mymsg=xmpp.protocol.Message(“evilbot.1@gmail.com”,”hello”, “chat”)
myclient.send(mymsg)
</source>
Если вы справились с приглашением и разрешением на чат от учетной записи вашего бота, вы должны получить приятный сюрприз.
Одна штука может вас озадачить: а как установить свое статусное сообщение? Сервер отображает только статус и соответ-ствующее сообщение, переданные клиентом.

На сервере Google это означает, что вы можете иметь статус Не на месте, Невидим, Отсутствую, Не беспокоить или На месте, а также в форме текстового сообщения. А вот и разгадка: ваш статус задается отправкой специального сообщения ''XMPP'', которое идет прямо на сервер. Оно включает ваш статус и текст статусного сообщения. Не зная этого, самому догадаться сложно, но смысл тут есть: ''XMPP'' как раз предназначен для отправки сообщений, так зачем же заводить отдельные протоколы только для отправки сообщений про статус? Сервер отвечает за обновление статуса для всех, кто соединен с вами. Кстати говоря, протокол ''XMPP'' позволяет отправлять контактам явные сообщения о статусе, но, хотя тут и есть с чем порезвиться, обычно мы перекладываем эту заботу на сервер:

<source lang=python>
>>> presence = xmpp.Presence(status = “Ready!”, show = “chat”, priority = ‘1’)
>>> myclient.send(presence)
</source>

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

{{Врезка|Заголовок=Почему ''Python''?|Содержание=Можно, естественно, писать скрипты и приложения для обработки web-данных на любом другом языке; так почему же мы выбрали ''Python'', а не ''C#'', например? На то есть веские причины. ''Python'' – язык простой и понятный, код на нем легко пишется и (что, вероятно, еще важнее) легко читается.

Он обладает прекрасными возможностями для работы с текстом (которым по большей части и являются наши данные), он кросс-платформенный и снабжен бездной полезных библиотек для web-служб и протоколов. Используя ''Python'' и пару библиотек, можно мигом создать рабочее приложение или скрипт.|Ширина=300px}}

===Прослушивание===

От хорошего бота также нужно получать входящие сообщения. Среда ''Xmpppy'' принимает весточки, отправленные на созданный вами клиентский объект, и сохраняет их в стеке для обработки. А какой? ''Xmpppy'' использует концепцию обработчиков [handler]: сперва вы определяете функцию или метод, который будет действовать как получатель информации. Затем, при готовности обработать сообщения из стека, вы просто вызываете метод '''Process()''' объекта клиента. Звучит это сложнее, чем есть на самом деле – другими словами, вы сообщаете клиенту, где нарыть сообщений, затем велите ему пропустить их через функцию. Конечно, это можно сделать и через командную строку ''Python'', но тогда будет сложнее: нужно написать функцию обработчика, а затем, обычным порядком, запустить бесконечный цикл для обработки сообщений по мере их прибытия.

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

<source lang=python>
>>> def msgparser(instance, message):
... print “new message!”
... print “from: “ + str(message.getFrom())
... print “msg: “ + str(message.getBody())
...
>>> myclient.RegisterHandler(‘message’, msgparser)
>>> mymsg=xmpp.protocol.Message(“evilbot@gmail.com”,”hello”, “chat”)
>>> myclient.send(mymsg)
‘5’
>>> myclient.Process(1)
new message!
from: evilbot@gmail.com
msg: hello
1493
>>>
</source>

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

===Помощь по ''Python''===

{{Врезка|Заголовок=Версии ''Python''|Содержание=''Python 3.0'' уже доступен, но поскольку его код несовместим с прежними версиями, многие дистрибутивы по умолчанию все еще используют (и будут использовать в обозримом будущем) версии 2.х. Поэтому весь наш код в этой серии уроков совместим с 2.x, для удобства большинства читателей.|Ширина=200px}}

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

===Командный голос===

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

Добавление обработчика команд сделало бы код громоздким. Ради экономии места и умственных усилий применим трюк: используя конструкцию '''eval''' языка ''Python'', мы создадим функцию, вызывающую метод в нашем классе с тем же именем, что и команда, которая была нам передана. Это, конечно, отчасти халтура, но экономит место и облегчает добавление команд – вам останется только определить новый метод. Для бота более продвинутого вы, возможно, захотите вставить механизм обработчиков, чтобы к экземплярам класса можно было добавлять свои команды, но ниже показано, как работает метод попроще (заметим, что данный код – это метод класса)

{{Врезка|Заголовок=Редакторы ''Python''|Содержание=''Python'' строг насчет синтаксиса. Это не так плохо, но чревато проблемами, если вы пишете код в неподходящем редакторе. Мы использовали ''Vim'' и ''Kate'' – оба имеют выделение синтаксиса и другие функции для облегчения задачи создания работающего скрипта на ''Python''. Годится также ''Eric'', IDE на базе ''Python'', куда включено много других возможностей, специфичных для этого языка. Она доступна в большинстве дистрибутивов, и ее можно скачать с сайта http://eric-ide.python-projects.org/eric4-download.html.|Ширина=200px}}

<source lang=python>
def messageparse(self, instance, message):
m = message.getBody()
sender=message.getFrom()
if m[0]==’#’:
self.log(‘command received’)
#специальный случай
#просто команда – подразумеваем, что метод существует, как и id отправителя
try:
getattr(self, m[1:])(sender)
except:
self.client.send((xmpp.protocol.Message(sender, ‘Sorry Dave, I can\’t do that...’)))
else:
#полагаю, надо сказать что-нибудь, из вежливости
self.client.send((xmpp.protocol.Message(sender, random.choice(self.responses))))
</source>

Как видите, сообщение проверяется на наличие символа '''#''', и если он есть, мы создаем вызов метода по остатку строки, включая ID отправителя, и пытаемся выполнить его. Конструкции '''try''' и '''execept''' отлавливают исключения – например, несуществующий метод. Если команды нет, мы просто отправляем случайный ответ, выбрав его из списка '''responses'''. На самом деле, для этого нужно импортировать модуль '''random; random.choice''' случайным образом выбирает элемент из тех, что ему подсунули.

Обработчик команд может быть таким:

<source lang=python>
def uptime(self, sender):
import subprocess
p=subprocess.Popen([“uptime”], stdout=subprocess.PIPE)
r=p.communicate()[0]
self.client.send((xmpp.protocol.Message(sender,r)))
</source>

Объясним его, потому что он работает с запуском команд локально, на компьютере, где выполняется бот. Сначала идет определение, которое принимает экземпляр объекта '''self''' (это требование ''Python'') и информацию об отправителе сообщения, добытую обработчиком. А потом мы импортируем '''subprocess''' из стандартных библиотек ''Python'', для запуска локальной команды.

Кроме того, мы использовали метод под названием '''Popen''' (см. строку, начинающуюся с '''p=subprocess.Popen'''), который задокументирован и объяснен по адресу http://docs.python.org/library/subprocess.html. Вкратце, мы передаем команду для выполнения и требуем, чтобы стандартный вывод отсылался в определенное место. Тогда мы можем связаться с этим выводом, используя метод communicate экземпляра '''Popen''', и получить результат команды. Последняя строка запаковывает его и отправляет в виде чат-сообщения. Теперь вы можете делать запросы к вашему серверу через чат-клиент и заставлять его злодействовать!

===Идем дальше===

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

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

Чат-бот – всего лишь перевалочный пункт: легкий в использовании интерфейс, позволяющий обращаться к скрипту. Как вы трудоустроите своего чат-бота, зависит от вас, от того, на что вы его запрограммируете. Если придумаете другие способы его применения, пожалуйста, напишите нам; а если вы чего-то недопоняли – не забудьте просмотреть полный код на DVD. '''LXF'''

LXF85:Java

2010-04-30T06:26:38Z

Newacct:

{{Цикл/Java}}
=== Считалочки ===
''ЧАСТЬ 2: Мало сыграть свадьбу — надо еще научиться вести семейный бюджет, выполнять одну и ту же работу каждый день и принимать судьбоносные решения. '''Антон Черноусов''' продолжает учить монархическую чету премудростям Java.''

В предыдущей статье были рассмотрены основы объектно-ориентированного языка программирования Java: инкапсуляция,
наследование, полиморфизм. Мы создали простое приложение, в котором женили короля на царевне Несмеяне.

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

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

Для реализации арифметических операций в Java существует семь арифметических операторов, которые работают с любыми числовыми типами: сложение +, вычитание -, умножение *, деление /, остаток %, унарный минус -val и унарный плюс +val, а также шесть примитивных типов переменных для выполнения арифметических операций:
{| border = "1" cellpadding="2"
!Тип переменной
!Разрядность
!Описание
|-
|Byte||align="center"|8||Целое со знаком
|-
|Short||align="center"|16||Целое со знаком
|-
|Int||align="center"|32||Целое со знаком
|-
|Long||align="center"|64||Целое со знаком
|-
|Float||align="center"|32||Число с плавающей точкой
|-
|Double||align="center"|64||Число с плавающей точкой
|}

Значение типов byte и short при выполнении вычислений переопределяется int, поэтому использование этих типов целесообразно для
хранения небольших значений для уменьшения объема используемой оперативной памяти.
<source lang = "java">
int iA = 10;
byte bB = 12;
int iC = iA + bB;
System.out.println("Сумма А и B = " + iC);
</source>
Выше приведен пример выполнения арифметической операции с использованием переменных различных типов. Результат — целое число типа int. Для преобразования типа переменной, например, в тип с более низкой разрядностью, необходимо воспользоваться специальными языковыми конструкциями:
<source lang = "java">
double dD = 10.2;
double dE = 12.23;
float fF = (float) (dD + dE);
System.out.println(fF);
</source>

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

Для представления логических значений в Java присутствует простой тип boolean, который принимает значения true или false. Для проведения различных логических операций можно использовать ниже перечисленные операторы:

{| border = "1" cellpadding="2"
!Тип операторов
!Операторы
|-
|операторы отношений
|align = "center"| <     >     >=     <=     instanceof
|-
|операторы равенства||align = "center"|==     !=
|-
|поразрядное И||align = "center"|&
|-
|поразрядное исключающее ИЛИ||align = "center"|^
|-
|поразрядное включающее ИЛИ||align = "center"|ǀ
|-
|логическое И||align = "center"|&&
|-
|логическое ИЛИ||align = "center"|ǁ
|}

Пока Несмеяна разбирается в дебрях налогового кодекса, мы для иллюстрации работы с логическими выражениями обратимся к методу
primeNumberCheckUp(int numberForCheck), который выясняет, является ли переданное ему число простым.
<source lang = "java">
private boolean primeNumberCheckUp(int numberForCheck) {
boolean result = true;
if (numberForCheck != 1 || numberForCheck != 2 || numberForCheck != 3) {
for (int currentNumber = 2; currentNumber < numberForCheck; currentNumber++) {
if (numberForCheck % currentNumber == 0) {
result = false;
}
}
}
return result;
}
</source>
В primeNumberCheckUp использованы две замечательные конструкции: оператор выбора по условию или условный оператор, и цикл.
Условный оператор if имеет следующий синтаксис:
<source lang = "java">
if (логическое выражение) {
операторы группы 1;
}
else {
операторы группы 2;
}
</source>

В вышеописанном методе использована упрощенная конструкция (без else), а для вычисления логического выражения использованы
операторы: != (не равно) и || (логическое «или»). В полной конструкции в случае истинности логического выражения выполняются операторы группы 1, иначе — группы 2.

Вместо if для управления выполнением кода может быть использована специальная конструкция switch. В рамках этой конструкции
вычисляется целочисленное выражение, и в соответствии с полученным результатом ведется поиск соответствующего значения блока
case.
<source lang = "java">
int flag = 6;
switch (flag) {
case 1: {
System.out.println("Царевна в спальне №1");
break;
}
case 5: {
System.out.println("Царевна в спальне №5");
break;
}
default: {
System.out.println("Кто тут знает, где царевна?");
break;
}
}
</source>
Обратите внимание на оператор break, который обеспечивает немедленный выход из любого блока, а в примере выше прекращает дальнейшую обработку операторов конструкции switch, а также на блок операторов default — этот блок необязательный, он выполняется в случае, если выражение, удовлетворяющие условию, не было найдено среди case.

=== Циклы ===
Разобравшись, как все устроено в королевстве, Несмеяна поняла, что все подчиняется принципу «Украл, выпил, в тюрьму» — точнее, во Дворец до следующего месяца. По кругу.

Для реализации «кругового» процесса в Java существует три вида циклов: for, while и do-while. С циклом for мы уже вы встречались в методе primeNumberCheckUp, продемонстрированном ранее, синтаксис этой конструкции следующий:
<source lang = "java">
for (инициализация; логическое выражение; приращение) {
операторы;
}
</source>
В рамках инициализации производится объявление и установка значений временных переменных. Цикл выполняется до тех пор, пока
логическое выражение истинно. На каждой итерации цикла производится приращение временных переменных.

Две другие конструкции циклов можно назвать однояйцевыми близнецами, если бы не маленькое отличие в их использовании. При
использования цикла while проверка условия осуществляется до выполнения блока операторов, а в конструкции do-while — после него, то есть действия внутри цикла отрабатывают хотя бы раз. Например, процесс одиночной попойки короля от счастья, что он женат, на языке Java можно описать так:
<source lang = "java">
int i = 100;
while (i > 0) {
System.out.println(i + " бутылок пива стояло на столе, одну уговорил");
i--;
}
System.out.println("Все выпил, да!");
int tankard = 1;
int allTankards = 10;
do {
System.out.println(tankard + " стакан помыт");
tankard++;
}
while (tankard <= allTankards);
System.out.println("Ну вот и все стаканы помыл");
</source>

=== Массивы ===
Для организации хранения однотипных данных в Java можно использовать массивы. Массивом называется структура данных, которая
позволяет хранить несколько значений в одной переменной (определение расплывчатое, но суть передает верно). Объявить массив можно несколькими способами, но я предпочитаю следующий как наиболее логичный:
<source lang = "java">
int[] arrayName = new int[length]
</source>
При этом int — это тип переменных массива, а length — его размерность (число элементов). После того, как массив создан,
значения всех переменных равны null.

Многомерный массив — это обыкновенный массив, элементами которого являются массивы, причем совсем не требуется, чтобы они
имели одинаковую размерность, например:
<source lang = "java">
int[][] arrayName = new int[2][];
arrayName[0] = new int[5];
arrayName[1] = new int[2];
</source>
В некоторых задачах требуется создать массив, состоящий из произвольных чисел. Генерация произвольных чисел возможна благодаря
классу Random, который входит в пакет java.util. К слову, пакеты — это иерархически именованные контейнеры, применяемые для изолирования имен классов в некотором пространстве имен, то есть пакеты применяются во избежание конфликтов с именами классов.

Подключение класса Random к программе происходит при использовании зарезервированного слова import и команды import java.util.Random; традиционно объявляемой в начале файла, содержащего разрабатываемый класс.
<source lang = "java">
import java.util.Random;
public class RandomGenerator {
private static Random random = new Random();
private int base;
public RandomGenerator(int base) {
this.base = base;
};
public RandomGenerator() {
this.base = Math.abs(random.nextInt());
};
public int getInt(){
return random.nextInt(this.base);
};
}
</source>
Далее, приведенный код позволяет сгенерировать массив псевдослучайных чисел с использованием класса RandomGenerator, код
которого приведен выше:
<source lang = "java">
int[] newArray = new int[100];
RandomGenerator currentRG = new RandomGenerator(500);
for (int currentNumber = 0; currentNumber < 100; currentNumber++) {
newArray[currentNumber] = currentRG.getInt();
System.out.println("newArray[" + currentNumber + "] = " + newArray[currentNumber]);
}
</source>
Иногда невозможно установить точное количество элементов в массиве, в таком случае на помощь приходят динамические массивы ArrayList. ArrayList — это класс, который входит в Collection API. Объекты, созданные на основе ArrayList, более ресурсоемки. Давайте посмотрим на работу динамических массивов на примере задачи по поиску всех простых чисел в диапазоне от 1 до N:
<source lang = "java">
private Integer[] getAllPrimeNumbers (int numberForCheck){
ArrayList primeNumbers = new ArrayList();
for (int currentNumber = 1; currentNumber <= numberForCheck; currentNumber++) {
if (this.primeNumberCheckUp(currentNumber)) {
primeNumbers.add(currentNumber);
}
}
Integer[] result = (Integer[]) primeNumbers.toArray(new Integer[0]);
return result;
}

public int[] getIntArray(){
Integer[] arrayOfPrimeNumbers = (Integer[]) GetAllPrimeNumder(this.number);
int[] result = new int[arrayOfPrimeNumbers.length];
for (int currentNumber = 0; currentNumber<resault.length; currentNumber++){
result[currentNumber] = arrayOfPrimeNumbers[currentNumber].intValue();
}
return resault;
};

public Integer[] getIntegerArray(){
return this.GetAllPrimeNumder(this.number);
};
</source>
В getAllPrimeNumder формируется динамический массив primeNumbers — объект класса ArrayList (для его использования необходимо подключить пакет java.util.ArrayList). Добавление нового объекта в динамический массив производится методом add(Object). После того, как динамический массив сформирован, из него извлекается простой массив методом toArray(Object[]). Обратите внимание, что из ArrayList извлекается массив объектов типа Integer, несмотря на то, что в него помещаются переменные типа int. Для получения массива состоящего из переменных типа int используется метод getIntArray().

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

Для логического завершения работы с простыми числами включим ранее описанные методы (primeNumberCheckUp, getAllPrimeNumder,
getIntArray(), getIntegerArray()) в представленный далее класс ArrayOfPrimeNumbers.
<source lang = "java">
import java.util.ArrayList;
public class ArrayOfPrimeNumbers {
private int number;

public ArrayOfPrimeNumber(int number) {
this.number = number;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
</source>
Класс, в зависимости от вызываемого метода, возвращает массив, состоящий из элементов int или Integer.

=== Куча хлама ===
Вернемся к нашей Несмеяне. Так как королевство ей досталось, прямо скажем, маленькое, пришлось ей еще и за порядком следить, что значит знать, где и что. Здесь ей помог HashMap — такая интересная структура для хранения данных, класс который входит в '''java.util.''' Экземпляры класса HashMap позволяют хранить различные именованные объекты, которые хранятся в виде пар «ключ — значение». Снаружи объекта типа HashMap нельзя узнать (как в хорошем бардаке), что же там лежит, однако, зная ключ, можно получить то, что ищешь, ну а если ключ неизвестен, то необходимо начать разбирать бардак до тех пор, пока не будет найдено то, что требуется. HashMap часто используется для хранения параметров системы. Как царевна разбирала бардак
мужа с помощью HashMap, можно посмотреть ниже.
<source lang = "java">
HashMap sameHeap = new HashMap();
sameHeap.put("Key1", "Левый носок");
sameHeap.put("Key2", "Грязная футболка");
sameHeap.put("Key3", "Правый носок");
String sameObj = (String) sameHeap.get("Key1");
System.out.println("Key1 = " + sameObj);
Map.Entry entry = null;
Iterator it = sameHeap.entrySet().iterator();
while (it.hasNext()) {
entry = (Map.Entry) it.next();
System.out.println("For key = " + entry.getKey() + " value = " + entry.getValue());
}
</source>
Для компиляции понадобится подключить java.util.HashMap, java.util.Iterator, java.util.Map — это можно сделать с помощью всего одной строкой вместо трех — import java.util.*;.

Как вы можете убедиться, для помещения объекта в HashMap необходимо использовать метод put, где первым параметром будет ключ, а
вторым — ассоциируемый с ним объект. Извлечение объекта возможно с помощью метода get при передаче ключа или с помощью последовательного перебора записей в HashMap.

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

=== Пятый угол ===
В хорошо написанной программе, как и в сказочном королевстве, все должно идти своим чередом, но непредвиденные ситуации все равно бывают, так как программа соприкасается с внешним миром (другими программами, файлами, пользователями). Для решения непредвиденных ситуаций в Java существуют исключения и специальные операторы позволяющие отловить и обработать их.
<source lang = "java">
try{
// небезопасный код
} catch(Exception e) {
// обработка исключительной ситуации
} finally {
// гарантированно выполняющийся блок
}
</source>
Выше представлена структура, с помощью которой производится обработка исключительных ситуаций: в блоке try производятся
потенциально опасные операции, а в блоке catch производится обработка возникшего исключения (блоков catch может быть несколько). Под блоком подразумевается последовательность операторов, объявлений локальных классов или локальных переменных, заключенных в фигурные скобки. Область видимости локальных переменных и классов ограничена блоком, в котором они определены.

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

Исключительная ситуация может быть сгенерирована виртуальной машиной Java, а также программистом. Исключение «выбрасывается»
с помощью оператора throw.
<source lang = "java">
public float calculate(int sameA, int sameB) throws Exception {
float result;
if (sameB != 0) {
result = sameA / sameB;
} else
throw new Exception("Параметр для вычисления не должен быть равным нулю");
return result;
}
</source>
Предложенный метод обеспечивает деление, а так как Царевна и король никогда не делят на ноль, они все делят поровну, то с помощью оператора throw порождается исключение в случае неправильно введенных данных. Это исключение можно «отловить» с помощью catch по месту использования метода.

Жизнь царевны и короля изменилась: пришлось осваивать азы науки и знакомиться с простыми типами (чисел), разбираться в ветвлениях налогового кодекса, использовать все три типа циклов, а также усвоить исключения. Оставим их осмыслять все это до [[LXF86:Java|следующего номера…]]

LXF102:Flash-карточки

2010-03-09T06:33:09Z

Newacct:

{{Цикл/Программирование}}
== Кодируем: Flash-карточки ==
: ''ЧАСТЬ 2 Улучшите навыки программиста и выучите иностранный язык – помогут '''Майк Сондерс''' и ваш собственный инструмент для показа всплывающих карточек...''

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

Однако здесь, в царстве людей, мы постоянно боремся с недочетами и изворотами нашей мысли. Мы вечно все забываем, меняем свое
мнение – короче, лучше бы наш мозг походил на ОЗУ, а не на серые
комки органики. Всего очевиднее это при изучении иностранного языка: компьютер хранит миллионы слов и никогда их не «забывает», а мы
с трудом припоминаем, как по-английски «встреча», даже если использовали это слово вчера. Спасибо, мозг.

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

=== Новый опыт Python ===
На LXFDVD прошлого месяца была опубликована подшивка LXF за
2005–2007 года; помимо прочего, в ней можно найти и учебник по
языку Python (выпуски [[LXF74-75:Python|74/75]]–[[LXF83:Python|83]]). Не пугайтесь, если вы пропустили
прошлый номер или никогда не писали на Python: в нем очень легко
разобраться. Если вы знакомы хоть с одним языком программирования, то не встретите проблем при работе с этим кодом.

Наше приложение flash-карт должно будет читать текстовые файлы
и генерировать случайные числа. Открытие файлов в Python – плевое
дело: создайте новый текстовый файл с именем foo.txt, вбейте в него
несколько слов (по одному в строке) и сохраните в домашнем каталоге.
Теперь создайте файл с именем test.py, также в домашнем каталоге, со
следующим содержимым:
<source lang="python">file = open(‘foo.txt’, ‘r’)
print file.readlines()</source>
Для запуска этого Python-скрипта откройте терминал и введите:
python test.py
Этот код открывает foo.txt (‘r’ означает «только для чтения») и связывает его содержимое с новым объектом по имени file.

Во второй строке кода мы вызываем readlines() нашего объекта file,
который сканирует foo.txt и сохраняет его строки как элементы массива.
При его печати на экране мы увидим:
<source lang="python">[‘hello\n’, ‘banana\n’, ‘cupcake\n’]</source>
Понятно, слова будут те, которые вы ввели в foo.txt. Но отсюда видно, как Python получает текст из файла и выводит элементы массива
через запятую. Ну, хорошо; а если мы хотим нормально отобразить
текст файла?
<source lang="python">file = open(‘foo.txt’, ‘r’)
for line in file:
print line</source>
Этот код выводит все строки из foo.txt. Заметьте, что отступы в
Python важны – табуляция перед print line говорит о том, что этот код
выполняется внутри цикла for. Конкретно этот цикл for говорит: для
(for) каждой строки открытого нами файла, напечатать ее, и так до
конца файла.

Итак, мы теперь можем получать текст из файлов и использовать
списки слов для наших flash-карточек. Но надо сделать еще кое-что:
наша программа должна отобразить список возможных ответов при
выводе слова. Кроме того, было бы крайне бесполезно, если бы верным ответом был всегда первый! Поэтому в нашей программе мы собираемся отображать три возможных ответа, один из которых правильный. Вот как получить случайные числа:
<source lang="python">import random
a = random.randint(1, 5)
b = random.randint(30, 100)
print a, b</source>
Первая строка говорит Python, что мы хотим использовать его генератор случайных чисел. После этого мы создаем две переменные: a и
b, и присваиваем им случайные значения стандартной подпрограммой
Python random.randint(). Мы указываем диапазон значений – для переменной a это будет число от 1 до 5 (включительно). Для b – число между 30 и 100. Легко!

=== Создаем flashcard.py 1.0 ===
[[Изображение:LXF102 69 1.png|thumb|Первая инкарнация нашей программы flash-карт – простой текстовый вариант.]]
Давайте поработаем с программой. Нам понадобятся два текстовых
файла: в одном – английские слова, в другом – соответствующие
русские. (Или, например, в одном файле могут быть названия стран,
а во втором – названия их столиц.) Важно, чтобы оба файла имели
одинаковое число строк и соответствие слов для каждой их пары.
Если вы используете названия столиц и седьмая строка первого файла – это «Япония», то седьмая строка второго файла должна содержать
«Токио». Иначе ответы не подойдут!

Итак, создадим два текстовых файла в домашнем каталоге и введем по десять слов в каждый из них, по одному в строке. В нашем примере, первый файл называется english.txt и содержит слова ‘Thanks,
word, job’ и т.д.; второй файл называется russian.txt и содержит ‘спасибо, слово, работа’ и т.д. Теперь нам необходим код на Python, чтобы
работать с этими текстовыми файлами в домашнем каталоге – и вот
вам листинг. Он есть на нашем DVD (flashcard.py в разделе Magazine/CodeProject), но пока просто пробегитесь по нему...
<source lang="python"># -*- coding: utf_8 -*-
import os, random
count = 0
score = 0
file1 = open(‘english.txt’, ‘r’)
file2 = open(‘russian.txt’, ‘r’)
f1content = file1.readlines()
f2content = file2.readlines()
while count < 10:
os.system(‘clear’)
wordnum = random.randrange(len(f1content))
print ‘Слово:’, f1content[wordnum], ‘’
options = [random.randrange(len(f2content)),
random.randrange(len(f2content)),
random.randrange(len(f2content))]
options[random.randrange(3)] = wordnum
print ‘1 -’, f2content[options[0]],
print ‘2 -’, f2content[options[1]],
print ‘3 -’, f2content[options[2]],
answer = input(‘\n Ваш выбор:’)
if options[answer-1] == wordnum:
raw_input(‘\n Верно! Нажмите enter...’)
score += 1
else:
raw_input(‘\n Неверно! Нажмите enter...’)
count += 1
print ‘\n Набрано очков:’, score</source>
При наличии flashcard.py, russian.txt и english.txt в вашем домашнем
каталоге откройте терминал и введите python flashcard.py. Вы увидите,
что программа отображает английское слово, а ниже – три возможных
русских эквивалента. Эти эквиваленты пронумерованы, и если вы считаете, что верный ответ – это 3, просто нажмите 3, а затем Enter. После
этого программа скажет вам, правы вы или ошибаетесь – всего будет
задано десять вопросов.

Давайте рассмотрим код более детально. Мы начали строкой с
import [Русская версия скрипта начинается с указания используемой
в системе кодировки, в противном случае программа не будет выполняться, – прим. пер.], которая говорит Python, какие возможности
мы собираемся использовать. В нашем случае необходимо вызывать
функцию ОС (для очистки экрана) и генерировать случайные числа.
Затем мы описываем две переменные, count и score – первая используется для отображения десяти вопросов, а вторая запоминает число
верных ответов. Далее идет:
<source lang="python">file1 = open(‘english.txt’, ‘r’)
file2 = open(‘russian.txt’, ‘r’)
f1content = file1.readlines()
f2content = file2.readlines()</source>
Здесь мы открываем два файла и связываем их с двумя переменными с именами file1 и file2. Эти переменные – вроде дескрипторов
этих файлов: они представляют файлы, сохраненные в памяти. Но нам
не нужны просто сами файлы; нам необходимо их содержимое, поэтому следующие две строки кода по кусочкам переносят реальный текст
в два массива с именами f1content и f2content. Теперь у нас есть список
английских слов в f1content и список русских слов в f2content. Затем
начинается основной цикл программы:
<source lang="python">while count < 10:
os.system(‘clear’)
wordnum = random.randrange(len(f1content))
print ‘Слово:’, f1content[wordnum], ‘’</source>
{{Врезка
|Заголовок=Скорая помощь
|Содержание=Если при ваших
экспериментах
с кодом Python
программа
зациклилась,
ее можно снять
из терминала, нажав
Ctrl+C. Вам может
понадобиться сделать
это пару раз,
особенно если
ваша программа
ждет ввода
от пользователя.
Если ваша
программа все-таки
не останавливается,
наберите в терминале
ps ax, найдите номер
процесс Python
вашего скрипта
и введите kill -9
<number>. Это
команда абсолютного
останова программы
|Ширина=200px}}
Мы хотим задать десять вопросов, то есть выполнить весь код с
отступом десять раз (переменная-счетчик каждый раз увеличивается). Первая строка этого цикла очищает экран, вызывая стандартную
утилиту /usr/bin/clear, а затем мы отображаем случайное слово. Мы
говорим: wordnum должно принять случайное значение, представляющее строку в файле слов, так что дай мне число между нулем и
размером файла (в строках). Хотя файл слов может иметь строки от
первой до десятой, массивы нумеруются с нуля, вот почему мы берем
случайное число от нуля до числа строк в файле минус один. То есть
строка один в f1content (english.txt) – на самом деле нулевой элемент
массива, а строка десять – девятый. Затем мы отображаем слово из
файла english.txt.
<source lang="python">options = [random.randrange(len(f2content)),
random.randrange(len(f2content)),
random.randrange(len(f2content))]
options[random.randrange(3)] = wordnum</source>
Далее создается массив трех возможных ответов с именем
options. Мы задаем для каждого ответа случайное число, ограниченное сверху числом строк в f2content (russian.txt). Теперь у нас есть
три случайных русских слова – но стойте, одно из них должно быть
верным, ведь так? Иначе получится три неверных ответа! Так что
положим один из ответов в options равным wordnum – то есть верному. И вместо того, чтобы верный ответ всегда был, скажем, первым,
мы размещаем его в случайное место в списке из трех возможных
ответов.

Оставшийся код понять очень просто. Он печатает на экране три
возможных ответа затем запрашивает ответ у пользователя – то
есть ввод 1, 2 или 3. Когда пользователь вводит ответ, мы проверяем, соответствует ли
он верному слову. То
есть, если русское слово – «спасибо» и номер
варианта thanks – «2»,
когда пользователь вводит 2, наша программа
говорит: «Ах! Вариант
два является седьмым
в файле русских слов. И истинный номер ответа wordnum также
равен семи, так что все верно! Слова совпадают.» В точку.

=== Версия с картинками ===
{{Врезка
|Заголовок=PyGame умеет больше
|Содержание=Наша вторая программа для flash-карт лишь поверхностно
очертила то, что можно сделать с PyGame (http://www.pygame.org).
Данная библиотека предоставляет множество инструментов
для загрузки изображений, перемещения спрайтов, работы
с клавиатурой/мышью и воспроизведения звуковых эффектов.
Это популярный выбор программистов игр с открытым кодом;
примеры того, что можно сделать, см. на http://www.pygame.org/tags/arcade.

А главное, PyGame имеет обширную документацию, включая
учебники для абсолютных новичков и детальный справочник API.
По адресу http://www.pygame.org/docs вы найдете учебники,
описывающие с нуля, как инициализировать PyGame,
перемещать спрайты и использовать пиксельные эффекты.
[[Изображение:LXF102 71 1.png|thumb|300px|PyGame не ограничивается видеоиграми – вы можете использовать ее и для создания медиа-проигрывателя.]]
|Ширина=400px}}
Теперь у нас есть текстовый инструмент flash-карт, превосходный для
множества применений, а как насчет графической версии? Допустим,
картинка с животным и три возможных названия – идеально для детей.
А может, вы захотите нарисовать национальные флаги – кстати, именно это мы и собираемся сделать. Как и прежде, программу можно преобразовать во что угодно, использующее слова и картинки: блюда и их
названия на испанском, фотографии звезд и их имена...

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

Наша первая версия flashcard.py использовала два текстовых файла с соответствиями слов, а эта графическая инкарнация будет использовать соответствия слов и картинок. То есть file1.txt может содержать
«Непал, Канада, Финляндия...», а file2.txt – ‘nepalflag.png, canadaflag.png,
finlandflag.png...’ и так далее. Слова будем получать из file1, а картинки
для отображения – из file2.

Код для этого выйдет более длинный, и чтобы зря не тратить место,
мы приведем здесь лишь основную часть. Но это большая часть, и она
вам покажет, как работает графическая версия. На нашем DVD в разделе Magazine/CodeProject/Graphical имеется полный листинг кода со
множеством комментариев (обозначенных символом #).

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

Вот наш основной кусок кода. Здесь есть несколько новых элементов, но, в типичной манере Python, по большей части все самодокументировано – открываем файл изображения, рисуем его на экране в
указанной позиции, и все.
<source lang="python">init()
screen = display.set_mode((640, 480))
display.set_caption(‘Flashcard’)
font = font.Font(None, 48)
while count < 10:
screen.fill(0)
wordnum = random.randrange(len(f2content))
mainpic = image.load(f2content[wordnum].rstrip(‘\n’))
screen.blit(mainpic, (255, 50))
options = [random.randrange(len(f1content)),
random.randrange(len(f1content)),
random.randrange(len(f1content))]
options[random.randrange(3)] = wordnum
text1 = font.render(‘1 - ‘ + f1content[options[0]].rstrip(‘\n’),
True, (255, 255, 255))
text2 = font.render(‘2 - ‘ + f1content[options[1]].rstrip(‘\n’),
True, (255, 255, 255))
text3 = font.render(‘3 - ‘ + f1content[options[2]].rstrip(‘\n’),
True, (255, 255, 255))
screen.blit(text1, (30, 200))
screen.blit(text2, (30, 300))
screen.blit(text3, (30, 400))
display.update()</source>
Первые четыре строки кода говорят PyGame настроить экран. Мы
инициализируем PyGame, а затем велим ему создать новое окно размером 640 x 480 пикселей, поместив в заголовок окна соответствующий текст. Затем создаем новый шрифт: создадим объект с именем
font, используя собственную систему шрифтов PyGame, и скажем
‘None’, что означает: нам неважно, какой шрифт использовать – пусть
будет стандартный системный. А размер шрифта установим 48 пунктов.

Затем запускается главный цикл, выдавая десять вопросов. screen.
fill(0) просто заполняет экран нулевым цветом, то есть черным – это
очищает окно для каждого вопроса. Затем мы выбираем строку для
случайного слова, которое будет ответом, так же, как и в текстовой
версии, а затем у нас идет:
<source lang="python">mainpic = image.load(f2content[wordnum].rstrip(‘\n’))</source>
Это довольно большая инструкция, так что давайте разберем ее.
Мы создаем новый объект PyGame: картинку с именем mainpic, для
отрисовки на экране. Однако картинку необходимо откуда-то загрузить,
и это должна быть картинка для верного ответа – а мы здесь сказали,
чтоб Python выбрал ее случайным образом.

Как и до этого, в полном коде мы загружаем два текстовых файла
в f1content и f2content. f1content содержит список слов – в нашем случае, «Непал, Канада, Финляндия...». f2content содержит список имен
соответствующих файлов изображений: ‘nepalflag.png, canadaflag.png,
finlandflag.png...’. Наша переменная wordnum указывает на слово в
f1content, а также на имя файла связанного изображения в f2content.
Если wordnum равно 2, то она может указывать на «Непал» в f1content
и ‘nepal.png’ в f2content – вот почему записи в файлах должны попарно соответствовать друг другу!

Итак, загружаем нашу картинку в соответствии с именем файла из
f2content, удалив символ перевода строки при помощи rstrip – не то
PyGame нас не поймет! Далее, делаем один из трех вариантов правильным, как и ранее. Затем создаем три отрывка текста для отображения
на экране. Вот первый:
<source lang="python">text1 = font.render(‘1 - ‘ + f1content[options[0]].rstrip(‘\n’),True, (255, 255, 255))</source>
[[Изображение:LXF102 71 2.png|thumb|При помощи Python и PyGame, мы теперь можем создать графический тест вроде этого.]]
Здесь создается новое изображение с именем text1, содержащее
первый случайный вариант из нашего списка слов f1content. True означает, что текст должен быть сглаженным, а (255, 255, 255) – цвет текста
в формате красный, зеленый, синий: белый, стало быть. Делаем то же
для других вариантов, затем отрисуем (blit) текст на экране и обновим
его, чтобы все отобразилось.

Оставшийся код с комментариями, который вы можете просмотреть
на нашем DVD, обрабатывает ввод пользователя. Мы проверяем, что
нажал пользователь – 1, 2 или 3 – и реагируем соответственно: выводим «Верно!» и обновляем счетчик очков, или выводим «Неверно!».
Затем ждем нажатия Enter и вновь запускаем цикл.

=== Завершаем ===
Надеемся, что это вдохновило вас покопаться глубже в вашем проекте
flash-карт – возможно, расширить его, включив пять вариантов вместо
трех. А может быть, вы хотите записывать системное время в начале
теста и сравнить его со временем по завершении теста, чтобы выставлять оценку за быстроту!

С этой программой можно еще много чего сделать, и если у вас
получится что-то классное, пожалуйста, сообщите нам, и мы, возможно,
разместим это на нашем DVD. Если у вас возникли вопросы по данному
уроку, обратитесь к разделу Программирование на http://www.linuxforum.ru.
Наслаждайтесь!