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

LXF82:Python

2008-06-18T17:04:22Z

Говно: «LXF82:Python» переименована в «LXF82: Говно»

{{цикл/Python}}

== РАЗРАБОТКА клиент-серверных приложений ==
''ЧАСТЬ 2 Вознамерились написать открытую альтернативу Skype или собственный клиент BitTorrent? '''Сергей Супрунов''' научит всему необходимому – от основ архитектуры «клиент-сервер» до готовых библиотек для работы с существующими интернет-протоколами.''

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

=== Клиент всегда прав ===
{{Врезка
|Заголовок=UDP-CLIENT.PY
|Содержание=
<source lang="python" line="GESHI_NORMAL_LINE_NUMBERS">
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
from socket import *
hostname = sys.argv[1]
HEADER = ‘\x00\x01\x00\x00\x00\x01’
HEADER += ‘\x00\x00\x00\x00\x00\x00’
QUESTION = ‘’
parts = hostname.split(‘.’)
for p in parts:
QUESTION += ‘%c%s’ % (chr(len(p)), p)
QUESTION += ‘\x00\x00\x01\x00\x01’
QUERY = HEADER + QUESTION
cs = socket(AF_INET, SOCK_DGRAM)
cs.sendto(QUERY, (‘127.0.0.1’, 53))
rsp = cs.recv(1024)
start = len(QUERY) + 12
print ‘%s.%s.%s.%s’ % (ord(rsp[start]),
ord(rsp[start+1]),
ord(rsp[start+2]),
ord(rsp[start+3]))
</source>
|Ширина=310px}}
Наиболее распространенным способом взаимодействия двух приложений через сеть являются уже знакомые нам сокеты. Модуль
socket, входящий в стандартную поставку Python, помимо рассмотренных в прошлый раз Unix-сокетов поддерживает также сокеты
домена Internet. Методология использования мало чем отличается от
Unix-сокетов, за исключением того, что вместо параметра AF_UNIX
используется AF_INET, а вместо имени файла указываются имя хоста
и номер порта, которые будут обслуживаться создаваемым сокетом.

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

Как пример, рассмотрим работу приложения, выполняющего роль
примитивного (и весьма ограниченного функционально) клиента DNS,
работающего по протоколу UDP (см. листинг udp-client.py).

Некоторую сложность здесь представляет то, что DNS относится к
так называемым «двоичным» протоколам, в отличие от «текстовых»,
таких как HTTP или SMTP, где обмен идет обычными текстовыми строками. В случае с DNS оперировать приходится «сырыми» байтами.
Сведения по формату сообщений можно почерпнуть из RFC 1035, раздел «4. MESSAGES».

В 6-й и 7-й строках рассматриваемого кода формируется заголовок
(12 байт). Пренебрегая всем богатством возможностей протокола DNS,
мы ограничиваемся простым запросом (OPCODE=0) одного доменного
имени (QDCOUNT=1). Конструкции вида «\x00» позволяют задать в
строке произвольный шестнадцатиричный код.

В строках 8–12 формируется поле запроса. Оно состоит из частей
доменного имени (в оригинале разделенных точками), перед которыми
указывается число символов в этой части. Например, имя mail.ru состоит из двух частей (mail – 4 символа, ru – 2 символа) и в запросе должно выглядеть так: \x04mail\x02ru\x00. Завершающий ноль, а также
два двухбайтовых поля (QTYPE и QCLASS) добавляются к переменной
QUESTION в строке 12.

Наконец, строки 14 и 15 – создание сокета (обратите внимание на
второй параметр, SOCK_DGRAM, указывающий тип транспортного протокола UDP) и отправка запроса. Поскольку UDP работает без установки
соединения, то вместо знакомой нам пары методов «connect – send» мы
используем один «sendto», в котором указывается сразу и отправляемая информация, и адрес получателя. В данном примере предполагается, что DNS-сервер работает на локальной машине. Вы можете указать
здесь свой DNS-сервер или передавать его имя в качестве параметра.

И в строках 17–21 из всей полезной информации, возвращаемой
сервером, мы, игнорируя любые возможные ошибки, выбираем только
IP-адрес, размещаемый по смещению, которое формируется в переменной start. Результат работы:
serg$ ./udp-client.py donpac.ru
80.254.111.2

=== Всегда к вашим услугам ===
{{Врезка
|Заголовок=IAMOK.PY
|Содержание=
<source lang="python" line="GESHI_NORMAL_LINE_NUMBERS">
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os, re
from socket import *
class IamOK:
def __init__(self, host=’localhost’, port=12345):
self.socket = socket(AF_INET, SOCK_STREAM)
self.socket.bind((host, port))
self.socket.listen(5)
def process(self):
while 1:
csocket, caddress = self.socket.accept()
csocket.send(‘IamOK server v.0.0. Ready to serve.\n’)
csocket.send(‘You are from %s, port %s...\n’ % caddress)
while 1:
request = csocket.recv(64)
if re.match(‘get\s+uptime’, request, re.IGNORECASE):
csocket.send(os.popen(‘/usr/bin/uptime’).read())
elif re.match(‘quit|bye|exit’, request, re.IGNORECASE):
break
else:
csocket.send(‘Unknown command.\n’)
csocket.close()
if __name__ == ‘__main__’:
serv = IamOK()
serv.process()
</source>
|Ширина=310px}}
В качестве примера сервера, на этот раз работающего по протоколу TCP,
рассмотрим такой код (см Листинг iamok.py).

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

Здесь все должно быть понятно по прошлому уроку. Два отличия – в конструкторе socket.socket() указывается второй параметр –
SOCK_STREAM (в данном случае его можно было бы и опустить, т.к.
для Internet-домена и так по умолчанию используется протокол TCP).
И метод bind() осуществляет привязку сокета не к файлу, а к имени
хоста и номеру порта, на котором будут ожидаться входящие соединения. Кстати, выбирая номер порта, не забывайте, что порты до 1024-го
относятся к привилегированным и могут быть задействованы только
пользователем root.

Наш сервер понимает две команды: «get uptime», по которой возвращается информация о времени работы сервера, и «quit» (с двумя
синонимами – «bye» и «exit»), по которой сеанс завершается.

Проверить работу сервера можно с помощью обычной
telnet-сессии:
<source lang="text">
admin@dom:~/lxf/propy/l2$ telnet localhost 12345
Trying 127.0.0.1...
Connected to localhost.localdomain.
Escape character is ‘^]’.
IamOK server v.0.0. Ready to serve.
You are from 127.0.0.1, port 2650...
helo
Unknown command.
get uptime
23:09:26 up 58 min, 3 users, load average: 0.04, 0.15, 0.63
quit
Connection closed by foreign host.
</source>
Какая от этого может быть польза – решайте сами.

=== «Гуртом и батьку бить веселей» ===
{{Врезка
|Заголовок=THREAD-TEST.PY
|Содержание=
<source lang="python" line="GESHI_NORMAL_LINE_NUMBERS">
#!/usr/bin/python
# -*- coding: utf8 -*-
import threading as t
import time, re
diskbusy = t.Lock()
def parseit(lognum):
global errors, total
diskbusy.acquire()
log = open(‘logs/syslog.%d’ % lognum)
lines = log.readlines()
diskbusy.release()
for line in lines:
if re.search(‘failed|error’, line):
errors += 1
total += 1
class ParseLog(t.Thread):
def __init__(self, num):
self.lognum = num
t.Thread.__init__(self)

def run(self):
parseit(self.lognum)
#------------------ 1
def test1():
global errors, total
errors = total = 0
for i in range(10):
parseit(i)
print errors, total,
#------------------ 2
def test2():
global errors, total
errors = total = 0
running = []
for i in range(10):
tr = ParseLog(i)
tr.start()
running.append(tr)
for tr in running:
tr.join()

print errors, total,
start = time.time()
test1()
print ‘Послед.: %f’ % (time.time() - start)
start = time.time()
test2()
print ‘Потоки: %f’ % (time.time() - start)
</source>
|Ширина=310px}}
Потоки, наряду с рассмотренными ранее процессами, являются эффективным способом параллельного выполнения различных задач. В
ряде случаев этим можно воспользоваться не только для одновременного обслуживания нескольких подключений в клиент-серверных
приложениях, но и для повышения производительности «автономных»
программ.

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

В стандартной поставке Python для работы с потоками есть два
модуля – thread и threading. Первый позволяет управлять потоками на
достаточно низком уровне, второй – использует средства первого для
предоставления более удобного объектно-ориентированного интерфейса. Класс threading.Thread предоставляет «шаблон» потока. Для его
использования в своей программе вам нужно переопределить метод
run(), описав в нем действия, которые должны выполняться этим потоком. Ниже приведен пример, из которого все должно стать понятно.

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

Вот если бы нам удалось организовать работу потоков таким образом, чтобы, пока один из них выполняет чтение файла, другие не обращались к диску... Для решения этой задачи в языке Python доступно
несколько средств синхронизации работы потоков.
Простейшее из них – использование обычных переменных-флагов.
Как вы помните, потоки разделяют оперативную память, принадлежащую процессу, в рамках которого они исполняются, так что изменения
переменных будут «видны» всем процессам. Идея здесь проста:
<source lang="python">
if DISKBUSY:
# ожидание
else:
DISKBUSY = 1
# чтение файла
DISKBUSY = 0
</source>
То есть первый поток выставит истинное значение глобальной переменной DISKBUSY и приступит к чтению файла. «Опоздавшие» потоки
будут ждать, пока переменная вновь не примет значение «ложь».

В такой реализации программисту предстоит решить не такую уж
простую, как может показаться на первый взгляд, задачу – грамотно
обеспечить ожидание. Бесконечный цикл проверки значения переменной слишком сильно нагружает процессор (не даром такие циклы
называют напряженными). Напрашивающееся time.sleep(1) очень
не эффективно – если ресурс освободится до того, как истечет время «спячки», то он будет простаивать. [Кроме того, подобный метод
синхронизации сам по себе не атомарен – подробности ищите в статье
«[[LXF82:Unix API|Очереди сообщений и семафоры]]»]

Однако в модуле threading есть готовая реализация описанной
выше идеи – класс Lock, который предоставляет программисту так
называемые блокировки, иногда именуемые «мьютексами» (mutex).
Идя проста – создается объект данного класса (threading.Lock()),
который имеет два метода: acquire() позволяет захватить объект,
release() – освободить его. Метод aquire() является блокирующим:
очередной поток, вызвавший его, будет ждать до тех пор, пока мьютекс
не освободится.

Дальнейшим развитием идеи блокировок являются семафоры.
Фактически, семафор – это тот же мьютекс, но позволяющий захватить себя несколько раз. Если вы создадите семафор командой
semaphore = threading.Semaphore(3), то его смогут захватить (тем
же методом semaphore.acquire()) одновременно три потока (каждый раз отнимая по единице из указанного при инициализации числа).
Четвертый поток сможет захватить семафор только после того, как он
будет высвобожден (semaphore.release()) одним из тех, которые
удерживают его в настоящее время.

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

Здесь мы проводим два теста – последовательная обработка (1) и
использование потоков с эксклюзивным доступом к диску (2). В строках
16–22 мы создаем подкласс класса Thread, в котором переопределяем
метод run(). Запуск потока выполняется в строке 37. Обратите внимание
на список running (строки 34, 38, 39–40). С его помощью мы отслеживаем активность потоков – метод join() заставляет ждать, пока поток не
завершит свою работу. Дальнейшая работа основного сценария продолжится только после того, как отработают все порожденные потоки.

В строке 5 мы создаем мьютекс, с помощью которого в строках 8 и 11
будет регулироваться доступ потоков к диску. В глобальной переменной
errors ведется подсчет числа строк, в которых есть подстрока «failed» или
«error», в total – общее число обработанных строк. Результат работы:
21931 2302755 Послед.: 33.271387
21931 2302755 Потоки: 22.867245
Как видите, мы получили выигрыш по времени более чем на 30%.
Но нужно заметить, что распараллеливание подобных скриптов даст
заметный эффект только в том случае, если нагрузка на дисковую систему сопоставима с нагрузкой на процессор. Если какой-то из ресурсов
будет востребован намного больше второго, то потокам все равно придется ждать его высвобождения, а с учетом дополнительных затрат на
обслуживание самих потоков, суммарный результат может оказаться
даже хуже, чем при последовательной обработке.

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

=== HTTP ===
{{Врезка
|Заголовок=HTTP-SERVER.PY
|Содержание=
<source lang="python" line="GESHI_NORMAL_LINE_NUMBERS">
#!/usr/bin/python
# -*- coding: utf8 -*-
import SimpleHTTPServer as http
handler = http.SimpleHTTPRequestHandler
server = http.BaseHTTPServer.HTTPServer((‘localhost’, 8080), handler)
server.serve_forever()
</source>
|Ширина=310px}}
{{Врезка
|Заголовок=HTTP-CLIENT.PY
|Содержание=
<source lang="python" line="GESHI_NORMAL_LINE_NUMBERS">
#!/usr/bin/python
# -*- coding: utf8 -*-
import httplib
host = httplib.HTTP(‘localhost:8080’)
host.putrequest(‘GET’, ‘/testpage.html’)
host.putheader(‘accept’, ‘text/html’)
host.endheaders()
code, msg, headers = host.getreply()
print code, msg
if code == 200:
print host.getfile().read()
</source>
|Ширина=310px}}
Для работы с HTTP Python предоставляет четыре основных модуля:
BaseHTTPServer, SimpleHTTPServer, CGIHTTPServer и httplib.
Первые три реализуют простейшие серверы, причем второй и третий
модули используют возможности первого, предоставляя программисту
более высокоуровневый интерфейс к его методам. Модуль httplib служит для разработки HTTP-клиентов.

Например, простейший HTTP-сервер может выглядеть таким образом (см. листинг http-server.py).

Как видите – всего четыре «рабочих» строчки, и то строка под номером 4 служит лишь для присвоения столь длинного имени метода-обработчика более короткой и удобной переменной. Вести себя этот сервер
будет как «самый настоящий»: он будет возвращаться запрошенные
html-страницы или файлы из текущего и вложенных в него каталогов,
при наличии файлов index.html или index.htm в каталоге, из которого сервер запущен, клиенту по умолчанию (когда указано только имя
каталога) будут отдаваться они. Если индексные файлы отсутствуют,
автоматически будет строиться страница-содержание каталога (аналогично работает Apache с включенным модулем mod_autoindex). В
ответ на запрос несуществующего ресурса будут возвращаться сообщения об ошибке, и т.д.

Клиентское приложение будет не намного сложнее (см Листинг
http-client.py).

В строках 4–7 формируется нужный HTTP-заголовок, затем получаем и распечатываем ответ сервера:
<source lang="html4strict">
admin@dom:~/lxf/propy/l2$ ./http-client.py
200 OK
<HTML><HEAD>
<TITLE>Test page</TITLE>
</HEAD><BASE>
<H2>It is a test page</H2>
</BASE></HTML>
</source>
Конечно, чтобы представить эту страницу в графическом отформатированном виде, придется приложить еще немало усилий. Но это, как
говорится, уже дело техники.

=== Электронная почта ===
Модули smtplib, poplib, imaplib предоставляют клиентские интерфейсы к соответствующим протоколам. Их использование не намного
сложнее рассмотренного выше httplib, и, думаю, вы без труда в них
разберетесь. Для более тонкой обработки содержимого почтовых сообщений (выделения заголовков, вложений и т.д.) вам помогут модули
rfc822, mimetools, multifile, base64, mailbox и другие. Все они
очень хорошо прокомментированы и снабжены достаточно подробной
документацией. Простейший способ получить к ней доступ – функция
help(). Например:
<source lang="python">
>>> import mailbox
>>> help(mailbox)
</source>
Этот код выведет встроенную справку по работе с модулем mailbox
прямо в окне интерактивного терминала.

=== FTP ===
{{Врезка
|Заголовок=FTP-CLIENT.PY
|Содержание=
<source lang="python" line="GESHI_NORMAL_LINE_NUMBERS">
#!/usr/bin/python
# -*- coding: uft-8 -*-
import ftplib
ftp = ftplib.FTP(‘ftp.freebsd.org’)
ftp.login(‘ftp’, ‘my@mail.ru’)
ftp.cwd(‘pub/FreeBSD’)
retfile = ‘README.TXT’
ftp.retrbinary(‘RETR %s’ % retfile,
open(retfile, ‘w+’).write, 1024)
ftp.quit()
</source>
|Ширина=310px}}
Для работы с протоколом FTP к вашим услугам модуль ftplib. Работа с
ним ведется на достаточно низком уровне, и порой напоминает обычный
сеанс FTP, выполняемый вручную (см. листинг ftp-client.py).

В итоге выполнения этого скрипта в текущем каталоге должен появиться файл README.TXT, скачанный с ftp-сервера ftp://ftp.freebsd.org.

=== Заключение ===
Итак, на этом мы завершим знакомство с основными сетевыми возможностями языка Python. Хочу заметить, что они выходят далеко за рамки
простейших сценариев, пригодных для тестирования «больших» серверов или встраивания некоторых сетевых возможностей в ваши приложения. Приведу лишь несколько примеров. Так, в 90-х годах большой популярностью пользовался web-браузер Grail, разработанный на Python и
предоставляющий весьма широкие для того времени возможности по
обработке интернет-страниц – полная поддержка стандарта HTML 2.0
и, в значительной мере, HTML 3.2, поддержка различных форматов
изображений и звука, способность работать с языком разметки SGML,
поддержка FTP, и т.д.

Менеджер почтовых рассылок Mailman обеспечивает широкие возможности по управлению списками рассылок, включая web-интерфейс. Интернет-сервер Medusa обладает достаточно хорошими
характеристиками, позволяя использовать его как для тестовых
целей, так и для промышленной эксплуатации. Популярный
сервер web-приложений Zope также полностью разработан
на языке Python.

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

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

LXF78:Python

2008-06-18T17:03:41Z

Говно: «LXF78:Python» переименована в «Говно:Python»

{{цикл/Python}}
''Часть 4. Мы вплотную подошли к наиболее интересной теме – реализации объектно-ориентированного подхода в языке Python. Репортаж с места событий ведет '''Сергей Супрунов.''' ''

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

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

Для ООП характерны следующие принципы:<br />
* инкапсуляция: экземпляр класса рассматривается как «чёрный ящик», когда его внутреннее устройство скрыто, а всё взаимодействие с объектом выполняется через предусмотренный для этого интерфейс, т.е. набор методов. Нужно заметить, что в Python программист, в принципе, имеет возможность непосредственно воздействовать на свойства объекта, минуя интерфейс – здесь инкапсуляция реализована не на уровне ограничений языка, а на уровне соглашений.
* наследование: вы можете создавать новые классы на базе существующих, при этом они будут получать все атрибуты и методы, описанные для родительских классов. Наследование – это наиболее естественный путь разработки классов, подобных родительским, но с дополнительным набором свойств.

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

===Реализация ООП в Python===

В отличие от Perl, в Python объектный подход заложен в основу этого языка. Здесь почти всё является объектами, даже строки и числа. Не верите? Смотрите сами:

<source lang="python">
>>> print 1.0.__add__(5)
6.0
</source>

То есть мы применили к числу 1.0 (объекту) метод __add__(), который является «внутренней» реализацией операции сложения. Нужно заметить, что здесь из-за ограничений синтаксиса мы вынуждены использовать число с плавающей запятой, поскольку первая точка воспринимается интерпретатором именно как разделитель целой и дробной частей, а вот вторая уже отделяет объект от имени метода. Уже известная нам функция dir(3) вернёт ещё 52 метода, которые вы можете применять к числу.

Для определения класса используется специальный оператор class:
<source lang="python">
#!/usr/bin/python
# file: сtest.py
class
comment = 'User'
def __init__(self, username):
self.username = username
self.password = ''
def setpass(self, value=''):
self.password = value
def checkpass(self, typed):
if typed == self.password:
return 1
else:
return 0
</source>

Здесь мы определили класс, экземпляры которого будут хранить информацию о пользователях (имя и пароль). Специальный метод '''__init__()''', играющий роль конструктора, автоматически исполняется при создании нового объекта. В нём мы присваиваем атрибуту username значение, переданное конструктору как параметр, и создаём атрибут password с пустым значением.

Обратите внимание на обязательность использования параметра '''self''', который должен быть первым в описании любого метода. При работе с конкретным объектом здесь будет указываться его идентификатор, чтобы интерпретатор мог определить, с каким же объектом он имеет дело.

Описанные далее методы setpass() и checkpass() служат для того, чтобы установить значение атрибута password и сравнить с ним значение, введённое пользователем. На практике работа с нашим классом может выглядеть таким образом:

<source lang="python">
u1 = User('Vasya')
u1.setpass('qwerty')
userpass = raw_input('Enter your password:')
if u1.checkpass(userpass):
print 'Password is OK'
else:
print 'Password is wrong'
u1.password = 'sasdf'
</source>

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

Последняя строка демонстрирует, что пароль можно изменить и непосредственно. Это является нарушением принципа инкапсуляции. Язык Python предусматривает два соглашения для решения этой проблемы: во-первых, если имя атрибута или метода начинается с символа подчёркивания, это является признаком того, что они предназначены для «внутреннего потребления» и не должны использоваться непосредственно. Однако сам Python никак не ограничивает это. Если вы желаете получить более жёсткий контроль, используйте имена, начинающиеся двумя символами подчёркивания. Такое имя уже не будет доступно через пространство имён объекта (хотя обходной путь всё же есть).

Особое место занимают специальные методы (такие как показанный выше метод '''__init__()'''). Эти методы реализуют ряд «сервисных» функций (например, конструктор '''__init__()''', '''деструктор __del__()''', отвечающий за корректное удаление объекта, и т.п.), а также позволяют переопределить поведение, заложенное в интерпретаторе. Например, метод '''__add__()''' исполняется при обработке оператора сложения «+».
Определим его для некоторого класса:
<source lang="python">
#!/usr/bin/python
# file: stest.py
class Test:
def __init__(self, value):
self.value = value
def __add__(self, other):
return self.value – other
</source>

И теперь, вместо ожидаемого сложения, мы увидим вычитание:

<source lang="python">
>>> from stest import Test
>>> a = Test(5)
>>> print a + 3
2
</source>

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

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

<source lang="python">
>>> a.description = 'Описание'
>>> print a.description
Описание
</source>

Хотя атрибут '''description''' отсутствует в классе Test, мы можем работать с ним, как с обычным. Таким образом можно задать и атрибуты, имена которых начинаются с двух подчёркиваний. Это создаёт видимость того, что никаких ограничений на эти имена нет, но на самом деле получится совершенно иной атрибут, нежели определённый в описании класса. Так что не увлекайтесь подчёркиваниями.

===Наследование===

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

<source lang="python">
#!/usr/bin/python
# file: ntest.py
from ctest import User
class ShellUser(User):
def __init__(self, username):
User.__init__(self, username)
self.shell = '/bin/sh'
def setshell(self, newshell):
self.shell = newshell
u2 = ShellUser('Petya')
u2.setpass('12345')
print u2.password, u2.shell
</source>

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

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

===Классы в стандартных модулях===
Классы очень широко используются в стандартных модулях Python. В качестве примера рассмотрим один достаточно полезный модуль –'''StringIO'''. С его помощью вы можете применять к строкам методы работы с файлами ('''read()''', '''write()''' и т.д.). Это может быть необходимо в тех случаях, когда другой метод или функция может обрабатывать только файлы. Например, класс Message модуля '''rfc822''', с помощью которого, в частности, можно разбирать сообщения электронной почты, умеет работать только с файлом, содержащим текст сообщения.

Рассмотрим пример:
<source lang="python">
#!/usr/bin/python
import rfc822, StringIO
mailstr = """\
From: user@domain.ru
To: me@mysite.ru
Subject: Test Message
Hello!
It is a test message.
"""
fileobj = StringIO.StringIO(mailstr)
message = rfc822.Message(fileobj)
print "%s wrote:\n" % message.getheader('From')
bodyfrom = message.startofbody
fileobj.seek(bodyfrom)
body = fileobj.read()
print body
</source>

Итак, что здесь происходит? Переменная mailstr содержит текст в формате почтового сообщения. Поскольку модуль '''rfc822''' умеет работать только с файловыми объектами, мы создаём экземпляр класса '''StringIO''' под именем '''fileobj'''. На его основе уже создаётся объект message класса Message, описанного в модуле rfc822.

С помощью метода getheader() мы распечатываем значение поля «From», а узнав из атрибута startofbody объекта message, где начинается тело сообщения (отделённое от заголовка пустой строкой), мы видим, что нашему объекту fileobj не чужды никакие методы настоящих файлов – можно позиционировать указатель (метод '''seek()'''), считывать содержимое от текущей позиции до конца файла ('''read()'''), и т.д.

===Документируй это!===

Хотя в языке Python инкапсуляция, т.е. сокрытие внутреннего устройства класса, не реализована в чистом виде (вы можете обращаться напрямую к любому атрибуту, за небольшим исключением), но всё же хорошим тоном считается работать с объектами классов только через предоставляемый ими интерфейс. И в этих условиях особое значение приобретает документация. В Python реализован очень удобный способ, скажем так, «онлайновой» документации – первая текстовая строка класса (или функции) воспринимается как его описание, которое может быть в любое время получено с помощью атрибута '''__doc__''':
<source lang="python">
>>> class Cla:
... "Документация класса"
... pass
...
>>> print Cla.__doc__
Документация класса
</source>

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

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

LXF70:Perl. Переменные и операторы

2008-06-18T17:03:07Z

Говно: «LXF70:Perl. Переменные и операторы» переименована в «Говно и операторы»

{{Цикл/Perl}}

__TOC__

= Perl. Переменные и операторы =
Часть 1. ''В «эпизоде 1» нашей серии '''Марко Фиоретти''' ('''Marco Fioretti''') объясняет основные компоненты языка Perl.''

{{Врезка |
Заголовок=Подсказка |
Содержание='''Руководства по Perl'''<br />
Perl — зрелый язык, и его пользователи имеют доступ к большому количеству различной документации. Книга Тома Кристиансена, Джона Орванта, Ларри Уолла «Программирование на Perl» (Programming Perl by Larry Wall, Jon Orwant and tom Christiansen, O'Reilly) является прекрасным началом, если вам нужна более подробная информация — к вашим услугам http://perl.oreilly.com. Для доступа к онлайновой документации, полной коллекции модулей, руководств и примеров посетите Comprehensive Perl Archive Network (http://www.cpan.org). Отдельные вопросы можно задавать в новостной группе [http://groups.google.com/group/comp.lang.perl.misc comp.lang.perl.misc].|
Ширина=250px}}

Языки сценариев стали так популярны потому, что ценой небольшого падения производительности они берут на себя такую скучную работу, как определение переменных, выделение памяти, возвращение её операционной системе и так далее. Придуманный в конце восьмидесятых Practical extraction and Report Language или Perl исходно предназначался для работы с большими объёмами текста. И хотя он не является самым популярным языком сценариев двадцать первого века, он остаётся лучшим инструментом для решения многих задач. Знаете ли вы, например, что Perl спас проект «Геном человека» (Human Genome Project)? Целиком эту историю можно прочитать по адресу: http://bioperl.org/GetStarted/tpj_ls_bio.html.

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

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

=== Используй переменные, Люк! ===
Почти все основные правила синтаксиса Perl (такие как правила обрамления строк кавычками) очень напоминают или даже идентичны правилам оболочек Unix. Документации по оболочкам существует огромное количество, она не ограничивается учебником из предыдущих выпусков Linux Format. Поэтому, так как общую информацию можно найти в других местах, в эта серия сосредоточена на специфических особенностях языка, начиная с неудобочитаемых переменных. Я нежно люблю Perl, и использую его изо дня в день для решения самых разных задач. Но я должен предупредить вас: критики говорят, что это единственный язык, код на котором выглядит одинаково до и после
зашифровки. и если вы не знаете структуры программы на Perl, то так для вас и будет. Давайте рассмотрим компоненты этого языка. Первая вещь, которая раздражает новичков, когда они смотря на Perl-код — это тот факт, что все переменные имеют неалфавитный префикс. Клевещут, что из-за этого экран заполняется нечитаемым мусором. Но мне эти маркеры кажутся очень полезными, так как они сразу же сообщают о структуре соответствующей переменной и о том, что я могу сделать с нею. Вот пример:
<source lang="perl">$NAMe = 'Johnny';
$AGE = 33;
@BOOK = ('Introduction', 'First Chapter', 'Second Chapter');
%STAR_WARS_FAMILY = ('Father', 'Anakin',
'Mother', 'Padme',
'Male twin', 'Luke',
'Female twin', 'Leia');
</source>
Первые две переменные — это скаляры. Скаляр Perl способен содержать один кусочек информации, будь то строка, число или ссылка. Их имена всегда начинаются с символа доллара ($). Строковые скаляры всегда заключаются в единичные('), двойные(") или обратные кавычки(`), так же как и их эквиваленты из оболочек Unix, а числа, по аналогии, обходятся без кавычек.
<source lang="perl">
$A = 'Hello';
$B = '$A Johnny!';
$C = "$A Johnny!";
$D = `ls /usr/bin`;
</source>
Здесь переменная $b содержит именно то, что мы указали в коде, $C (благодаря двойным кавычкам) равняется «Hello Johnny!», а $D, поскольку для его значения использовались обратные кавычки, содержит результат выполнения команды ls /usr/bin/.

Упорядоченный список скаляров, проиндексированный номерами, называется массивом и начинается с символа @. Он полезен для хранения чего-либо в последовательном порядке. Один элемент массива обозначается так: символ $, имя массива и номер элемента (начиная с 0) в квадратных скобках. В приведенном выше примере, второй элемент массива @book — это $book[1] и он равен «First Chapter».

Ассоциативные массивы, или коротко говоря хэши (hash) — это последняя из основных категорий переменных языка Perl. Хэш — это группа скаляров, которые проиндексированы, или другими словам к которым можно обратиться не по номерам, а при помощи других скаляров, так называемых ключей. Другими словами, Perl позволяет сказать нам без излишних синтаксических конструкций, что в «семье звёздных войн»(STAR_WARS_FAMILY) отцом (Father) является Энакин (Anakin):$sTar_Wars_FamiLy{'Father'} = 'anakin'. Каждый ключ или значение хэша могут быть скаляром любого типа.

Итак, даже самый короткий скрипт на Perl может быть заполнен символами $, @ и %. Но при этом мы можем создавать очень сложные структуры данных, используя минимальное количество префиксов, почти не заботясь об именовании, и при этом всегда понимая, каков смысл каждого кусочка. Это возможно благодаря мощной и немного опасной возможности вкладывать массивы и хэши друг в друга:
<source lang="perl">%STAR_WARS_FAMILY = (
'Father', {'Name', 'Anakin',
'Height (cm)', 210,
'jobs', ['Slave', 'Podracer pilot', 'Jedi Knight', 'Darth Vader']},
'Mother', {} # другие такие же данные...
);
print "$STAR_WARS_FAMILY{'Father'}{'jobs'}[2]\n";
</source>
Это хэш, в котором каждый из элементов первого уровня является в свою очередь хэшем, содержащим элементы name (имя), Height (рост) and jobs (занятия), причём значением элемента jobs является массив. Обратите внимание, как мы различаем массивы и хэши при помощи квадратных и фигурных скобок, даже если они вложены друг в друга. В результате у нас получится, что оператор print в последней строке отобразит строчку Jedi knight (Джедай).

Существует одна встроенная скалярная переменная, о которой вам надо знать. иногда программисты на Perl забывают указать, какую переменную они имели ввиду, например:
print if условие
Эта инструкция указывает, что надо выполнять оператор print при некотором условии, но не говорит, что именно надо напечатать — значение какой переменной? В этом случае интерпретатор Perl использует текущее значение переменной по умолчанию, $_. Её значение определяются предыдущими выражениями, или она может выступать в качестве переменной цикла. Если вы помните об этой особенности, большое количество кода на Perl покажется вам гораздо понятнее.

=== Помоги мне, Падме ===
Perl понимает большое число разных операторов. Некоторые из них применимы только к какому-то одному классу переменных, будь то скаляры, массивы или хэши, тогда как другие изменяют свой смысл в зависимости от того, к какой переменной они относятся. В этой статье осталось место только для нескольких вариантов. Основные числовые операторы имеют тот же смысл, что и в языке C.
<source lang="Perl">
$A =10 * 7.5 - 16;
$B = $A % 4; # деление по модулю 4
</source>
и номера, и строки можно увеличивать при помощи оператора инкремента
<source lang="Perl">
$A = 4;
$B = 'ab';
$A++; # теперь $A равен 5...
$B++; # а $B равен 'ac'!!
</source>
Не правда ли это здорово, что буквы тоже можно инкрементировать? Вы также можете соединять строки из нескольких частей:
<source lang="Perl">
$FIRST_NAME = 'Luke';
$LAST_NAME = 'Skywalker';
$COMPLETE_NAME = $FIRST_NAME.' '.$LAST_NAME;
$REPEATED_NAME = $FIRST_NAME x 3;
</source>
Теперь $COMPLETE_NAME равняется «Luke Skywalker», a $REPEATED_NAME содержит «LukeLukeLuke».

Скаляры можно сравнивать между собой многими разными способами. Давайте попробуем некоторые из них и посмотрим, что получится:
<source lang="Perl">
$A < $B; # число $A больше, чем число $B?
$A lt $B; # строка $A располагается в словаре до $B?
$A <=> $B; # какое число меньше, $A или $B?
$A cmp $B; # какая строка располагается раньше, $A или $B?
</source>
Некоторые сравнения имеют смысл, только если обе переменные являются или строками, или числами. Например, оператор 'Эта строка в алфавитном порядка стоит перед другой', всегда используется для сортировки в алфавитном порядке. Даже если одна или обе сравниваемые переменные содержат только числа, использование строковых операторов сравнения приведёт к сортировке в алфавитном порядке. Чтобы увидеть это в действии, введите следующую команду в командной строке и проверьте, какие из операторов сравнения вернут истину?.
perl -e 'if ("dude" lt "hello") {print "dude!\n";} if ("dude" < "hello") {print "Hello!\n";}'
Фактически только первый тест должен завершиться успешно. Его смысл таков: «Верно ли, что строки переданы в алфавитном порядке?». Во втором операторе, используя < вместо lt, мы спрашиваем Perl, правда ли что число «dude» меньше числа «hello»? Конечно, это абсурдный вопрос, и ответ на него предсказуемо непредсказуемый.

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

Я думаю, что на этом достаточно разговоров про скалярные операторы. Когда речь заходит об операторах, работающих с массивами, Perl может сделать многое. Приведённый ниже пример показывает, как отдельный элемент может быть добавлен к массиву, а затем удалён оттуда:
<source lang="Perl">
@Jedi = ("Yoda", "Obi Wan"); # несколько рыцарей-джедаев
push(@Jedi, "Anakin"); # юный Энакин встаёт в строй
$gone_to_the_dark_side = pop(@Jedi); # Энакин уже не джедай
</source>
Существуют специальные операторы для работы с хэшами. Инструкции, подобные следующим, встречаются в коде на Perl очень часто:
<source lang="Perl">
while (($Actor, $Character) = each(%STAR_WARS_CAST));
# или даже
@ACTORS_ONLY = keys(%STAR_WARS_CAST);
</source>
Первая строка будет циклически перебирать элементы хэша %STAR_WARS_CAST, каждый раз присваивая ключ очередного элемента и его значение паре скаляров $Actor и $Character, которые вы затем можете обработать, как вам захочется. Оператор key используется в том случае, когда нужно сохранить только ключи хэша в отдельном массиве и работать с ними независимо от значений.

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

[[Категория:Учебники]]
[[Категория:Первые шаги]]
[[Категория:Perl]]

Обсуждение участника:Lockal

2008-06-18T17:02:55Z

Говно: «Обсуждение участника:Lockal» переименована в «Обсуждение участника:Говно»

Сэр, я хоть и с опозданием (не было нета), но приступил к работе.
Спасибо, конечно, за помощь, но этот номер зарегистрирован за мной.
: Без проблем, хотя я начал[http://wiki.linuxformat.ru/index.php?title=LXF85&action=history] работать над номером, когда он был ещё свободен[http://wiki.linuxformat.ru/?oldid=623]. А пока я займусь другими номерами. --[[Участник:Lockal|Lockal]] 19:16, 16 марта 2008 (MSK)

Не хочу показаться интервентом - могу переслать письмо от Валентина Синицына от 6 марта, где за мной утвердили 85-ый номер. --[[Участник:flagist0|flagist0]]

'''LXF84''' Спасибо за статью по LaTeX, но этот номер (LXF 84) занят, и я хотел бы завершить работу над ним самостоятельно
[[Участник:Skryabin yuri|Skryabin yuri]]

Участник:Lockal

2008-06-18T17:02:55Z

Говно: «Участник:Lockal» переименована в «Участник:Говно»

=== Учебники ===
* [[LXF70:Gnome 2.10]]

{{Цикл/Perl}}
* [[LXF70:Perl. Переменные и операторы]]
* [[LXF70:Perl. Сортируем наш код]]
* [[LXF72:Perl]]

* [[LXF70:Subversion1]]
* [[LXF70:Subversion2]]

* [[LXF70:PHP. Загадка Монти Холла]]
* [[LXF73:PHP I]]
* [[LXF73:PHP II]]
* [[LXF76:Учебник PHP]]
* [[PHP]]
* [[LXF78:Учебник PHP: MySQL 5.0 Special]]
* [[LXF79:PHP]]
* [[LXF80:PHP]]
* [[LXF81:PHP]]

{{Цикл/Gambas}}
* [[LXF71:Gambas]]
* [[LXF72:Gambas]]
* [[LXF73:Gambas]]

* [[LXF70:GIMP. Коррекция улыбки]]
* [[LXF72:GIMP]]
* [[LXF73:GIMP]]
* [[LXF76:Учебник Gimp, часть 1]]
* [[LXF76:Учебник Gimp, часть 2]]
* [[LXF78:Gimp: Блики на стекле]]

* [[LXF73:Автомонтирование USB]]

* [[LXF73:Русификация Debian 3.1]]

* [[LXF73:Локализация ПО]]

* [[LXF72:Первые шаги]]
* [[LXF73:Первые шаги]]
* [[LXF76:Первые шаги: Writer]]
* [[LXF76:Первые шаги: Impress]]
* [[LXF80:первые шаги]]
* [[LXF81:Firefox]]
* [[LXF82:Первые шаги]]
* [[LXF83:Ubuntu_for_children]]
* [[LXF84:Первые шаги]]
* [[LXF89:Первые шаги]]
* [[LXF92:Первые шаги]]
* [[LXF96:Первые шаги]]
* [[LXF97:Первые шаги]]
* [[LXF98:Первые_шаги]]
* [[LXF99:Первые шаги]]

* [[LXF76:Азбука записи]]

* [[LXF76:Учебник Fuse]]

* [[LXF76:Ubuntu по-русски]]
* [[LXF76:Учебник Ubuntu, часть 2]]

{{Цикл/Inkscape}}
* [[LXF76:Учебник Inkscape, часть 1]]
* [[LXF76:Учебник Inkscape, часть 2]]
* [[LXF78:Inkscape. Работа с текстом]]
* [[LXF79:Inkscape]]
* [[LXF81:Inkscape]]
* [[LXF82:Inkscape]]
* [[LXF83:InkScape]]
* [[LXF84:Inkscape]]
* [[LXF85:Inkscape]]
* [[LXF86:Inkscape]]

{{Цикл/MetaPost}}
* [[LXF76:MetaPost]]
* [[LXF77:MetaPost]]
* [[LXF78:MetaPost]]
* [[LXF79:MetaPost]]
* [[LXF80:MetaPost]]

{{Цикл/Python}}
* [[LXF76:Уроки Python, часть 2]]
* [[LXF76:Разработка расширений Pyhton]]
* [[LXF78:Уроки Python]]
* [[LXF79:Python]]
* [[LXF80:Python]]
* [[LXF81:Python]]
* [[LXF82:Python]]
* [[LXF83:Python]]
* [[LXF84:Python]]
* [[LXF97:Python]]

* [[LXF76:Hardcore Linux, часть 1]]
* [[LXF76:Hardcore Linux, часть 2]]
* [[LXF78:Мощные инструменты командной строки]] ?
* [[LXF79:Hardcore Linux]]
* [[LXF80:Hardcore Linux]]
* [[LXF82:Hardcore Linux]]
* [[LXF83:Hardcore_Linux]]
* [[LXF84:Hardcore Linux]]
* [[LXF89:Hardcore Linux]]
* [[LXF92:Hardcore Linux]]
* [[LXF94:Графическое web-приложение]]
* [[LXF96:Hardcore linux:APT]]
* [[LXF97:Hardcore Linux]]
* [[LXF98:Hardcore Linux]]

* [[LXF78:Evolution: Управляйте своей почтой]]

{{Цикл/Qt/KDE}}
* [[LXF78:Знакомство с Qt: первые шаги]]
* [[LXF79:Qt/KDE]]
* [[LXF80:Qt/KDE]]
* [[LXF81:KDE]]
* [[LXF82:Qt/KDE]]
* [[LXF83:Qt_KDE]]
* [[LXF84:Qt/KDE]]
* [[LXF85:Qt/KDE]]

* [[LXF78:Почему – Vim?]]

* [[LXF79:Audacity]]

* [[LXF79:Чистим записи]]

* [[LXF79:DCOP]]

{{Цикл/OOo Basic}}
* [[LXF80:OOo Basic]]
* [[LXF81:OOo]]
* [[LXF82:OpenOffice.org]]
* [[LXF83:OOo_Basic]]

* [[LXF84:OpenOffice.org]]
* [[LXF85:OpenOffice.org Base]]

* [[LXF82:Безопасность]]
* [[LXF84:Безопасность]]
* [[LXF85:Безопасность]]
* [[LXF86:Безопасность]]
* [[LXF89:Безопасность]] 5

* [[LXF80:загрузка]]

{{Цикл/Unix API}}
* [[LXF80:Программирование для Linux]]
* [[LXF81:IPC]]
* [[LXF82:Unix API]]
* [[LXF83:Unix_API]]
* [[LXF84:Unix API]]
* [[LXF85:Unix API]]
* [[LXF86:Unix]]
* [[LXF89:Unix API]] 8
* [[LXF90:Unix API]]
* [[LXF91:Unix API]]
* [[LXF92:Unix API]] 12

* [[LXF80:шифрование]]

* [[LXF81:WordPress]]

* [[LXF81:DansGuardian]]

* [[LXF81:Open-Xchange]]

{{Цикл/Maxima}}
* [[LXF81:Maxima]]
* [[LXF82:Maxima]]
* [[LXF83:MAXIMA]]
* [[LXF84:Maxima]]
* [[LXF85:Maxima]]
* [[LXF86:Maxima]]

* [[LXF81:PAW]]
* [[LXF83:ROOT]]

* [[LXF82:Разработка 3D-игры]]
* [[LXF83:3D_Game]]
* [[LXF84:Разработка 3D-игры]]
* [[LXF85:Ogre]]
* [[LXF86:Ogre]]

{{Цикл/LaTeX}}
* [[LXF82:LaTeX]]
* [[LXF83:LaTex]]
* [[LXF84:LaTeX]]
* [[LXF85:LaTeX]]
* [[LXF86:LaTeX]]
* [[LXF89:LaTeX]] 6
* [[LXF90:LaTeX]]
* [[LXF91:LaTeX]]
* [[LXF92:TeX]] 9
* [[LXF94:LaTeX Программирование]]
* [[LXF97:TeX]]

{{Цикл/Java}}
* [[LXF82:Java]]
* [[LXF84:Java]]
* [[LXF85:Java]]
* [[LXF86:Java]]
* [[LXF87/88:Java]]

{{Цикл/Java EE}}
* [[LXF89:Java EE]] 1
* [[LXF90:JavaEE]]
* [[LXF91:Java EE]]
* [[LXF92:Java EE]] 4
* [[LXF94:Команды и фабрики]] (серия «Java Enterprise Edition»)
* [[LXF95:Java EE]]
* [[LXF96:Java EE]] 8
* [[LXF97:Java]]
* [[LXF98:Java EE10]] 10
* [[LXF99:Java EE EJB3]]

* [[LXF83:HDD]]

* [[LXF83:XDMCP]]

* [[LXF83:WINK]]

* [[LXF85:Compiz]]

{{Цикл/PostgreSQL}}
* [[LXF85:PostgreSQL]]
* [[LXF86:Учебники:PostgreSQL]]
* [[LXF89:PostgreSQL]] 4
* [[LXF90:PostgreSQL]]
* [[LXF91:PostgreSQL]]

* [[LXF86:Wine]]

* [[LXF86:Kamaelia]]

{{Цикл/GTK+}}
* [[LXF86:GTK]]
* [[LXF89:GTK+]] 3
* [[LXF90:GTK+]]
* [[LXF91:GTK]]
* [[LXF92:GTK+]] 6
* [[LXF94:GTK+: Буфер обмена и VFS]]
* [[LXF95:GTK+]]

{{Цикл/Blender}}
* [[LXF89:Blender]] 2
* [[LXF90:Blender]]
* [[LXF91:Blender]]

* [[LXF90:RPM]]

* [[LXF90:SugarCRM]]
* [[LXF91:SugarCRM]]
* [[LXF92:SugarCRM]] 3

* [[LXF90:Grub]]

* [[LXF91:Система]]

* [[LXF91:XSLT]]

{{Цикл/Mono}}
* [[LXF89:Mono]]
* [[LXF90:Mono]]
* [[LXF91:Mono]]
* [[LXF92:Mono-Мания]]
* [[LXF94:Программирование для Mono]]
* [[LXF95:Mono]]
* [[LXF96:Mono-мания]]
* [[LXF97:Mono]]
* [[LXF98:Mono]]

* [[LXF91:Deb]]

* [[LXF92:Lm-sensors HOWTO]]

{{Цикл/Cinelerra}}
* [[LXF92:Cinelerra]] 1
* [[LXF93:Cinelerra]]
* [[LXF94:Cinelerra]]
* [[LXF95:Cinelerra]]
* [[LXF96:Cinelerra]] 5

* [[LXF94:Обмен файлами]] (серия «Linux для новичков»)

* [[LXF94:Макрос, загружающий данные]]

* [[LXF94:Следим за сетью]]

* [[LXF95:F-Spot]]

* [[LXF95:Akelos]]

* [[LXF95:Cron]]

* [[LXF95:DCOP]]

{{Цикл/Препринт}}
* [[LXF95:Препринт]]
* [[LXF96:Препринт]]
* [[LXF97:Препринт]]

* [[LXF96:Bash]] 1
* [[LXF97:Bash]]
* [[LXF98:Bash3]] 3

* [[LXF96:Evolution]]

* [[LXF96:Vim]]

* [[LXF97:Командная строка]]

* [[LXF97:GtkSourceView]]

* [[LXF97:Новая серия!]]

* [[LXF97:Hibernate]]

* [[LXF98:KDE]]

* [[LXF98:Диагностика]]

* [[LXF98:Ананас3]] 2

* [[LXF98:wxWidgets1]] 1
* [[LXF99:wxWidgets]]

* [[LXF98:Perl и C++]]

* [[LXF98:Чистка DVD видео]]

* [[LXF99:D-Bus]]

* [[LXF99:WavPack]]

LXF76:GIMP1

2008-06-18T17:02:40Z

Говно: «LXF76:Gimp1» переименована в «Говно 1»

=== Gimp Инструменты выделения ===
'''''Майкл Хэммел''' (Michael J Hammel) сравнивает новейшее средство Foreground Selection с достопочтенным Quick Mask.
''

[[Изображение:Img_76_78_1.jpg|left|thumb|From a wormhole in deep space (well, LXF73), I showed you how to create animated fractals. If you missed the issue, call 0870 8374773 or +44 1858 438795.]]

В мире свободного ПО свой отсчет времени; проект Gimp - не исключение. Недавно разнесся слух о скором выходе
новейшей версии, Gimp 2.4. Действительно ли грядет это событие, пока не ясно. Несомненно одно - в арсенале Gimp, среди прочих новинок, появится любопытный инструмент Foreground Selection - интегрированная версия сравнительно нового модуля SIOX для Gimp
2.2.

Проект SIOX (Simple Interactive Object eXtraction - Простая интерактивная выемка объектов) предусматривает создание ПО для упрощения процесса отделения объектов на рисунках от их окружения (графической выборки). Gimp уже обладает средствами для решения этой весьма востребованной задачи - именно для нее был создан инструмент Scissors, Ножницы. Действует он сравнительно неплохо, но
быстрым его не назовешь: выборка сложных графических объектов
требует назначения большого количества контрольных точек, а редактировать эти точки не так-то просто. Зато, вооружившись терпением
и временем, вы получите отменно точную вырезку.

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

Итак, инструментов для графической выборки хватает. Почему тогда мы говорим о появлении новых? Да потому, что разработчики Gimp
постоянно ищут способы усовершенствования программы. Вы спросите, не станет ли Foreground Selection одним из таких улучшений?
В процессе урока я как раз и собираюсь ответить на этот вопрос. Я буду сравнивать простоту использования Foreground Selection
и Quick Mask и доступную для них точность вырезки при работе в комбинации с другими средствами Gimp. Объектами послужат
несколько образцовых изображений. Следуя за мной, шаг за шагом, вы незаметно для себя освоите ценные технологии графической
выборки!

==== Часть 1 - простое выделение на однотонном фоне ====

Чтобы сравнить инструменты Foreground Select и Fuzzy Select из инструментария Gimp 2.2, поработаем с изображением розы на белом фоне.

===== Как работает Fuzzy Select =====
{{Врезка|right|
|Заголовок=ПОДСКАЗКА
|Содержание=* Пользуясь Quick Mask, можно сколько угодно раз переключаться между маской и вырезкой для подчистки. Ни один известный инструмент не дает такой простоты и свободы для этой операции, даже новейший Foreground Select.
* Для отмены сделанной вами выборки воспользуйтесь стандартным откатом [Ctrl]+[Z], попробуйте изменить настройку инструмента, затем начните сначала. Такая возможность есть у любого средства выборки, исключая Quick Mask (которому для подчистки просто не нужна настройка параметров).
* Когда вы отпустите кнопку мыши, Foreground Select немедленно обновит вашу вырезку. Поэтому не отпускайте кнопку, пока не закрасите большую часть нужного вам объекта. Для подчистки можно неоднократно возобновлять закрашивание.
* Когда вы закрасите вырезку, поместите курсор в окно изображения и нажмите клавишу ввода. Синее пространство превратится в реальную выборку.
|Ширина=150px}}

Инструмент Fuzzy Select (по виду напоминающий волшебную палочку) выделяет смежные точки, попадающие в определенный диапазон.
Превосходный способ отделить от рисунка практически монотонный фон!
[[Image:Img_76_79_1.PNG|center]]

===== Параметры Fuzzy Select =====

Параметр Threshold - Порог - в диалоговом окне настройки определяет предварительный контур. Чем выше порог, тем точнее вырезка.
В нашем примере было установлено значение порога 25,0. После щелчка мышью на фоновом участке получилась приличная, хотя и не идеальная, вырезка.
[[Image:Img_76_79_2.PNG|center]]

===== Повышение порога =====

Решив подобраться к розе поближе, я отменил выделение (Ctrl+Z) и повысил порог до 75,0. Затем оценил результат. Последняя попытка с порогом 105,0 дала отличную вырезку - вот уж поистине метод проб и ошибок! Чтобы вместо фона выделить розу, я инвертировал выделение (Select > Invert - Выделение > Инвертировать).
[[Image:Img_76_79_3.jpg|center]]

===== Как работает Foreground Selection =====

Значок Foreground Selection на панели инструментов Gimp имеет вид человеческой фигурки, окаймленной контуром из точек. В диалоговом
окне Tool Options - Параметры инструмента - есть два интересующих нас элемента управления: кнопки смены выделения объекта/фона
(Mark Foreground/Background) и ползунок изменения размера кисти.
[[Image:Img_76_79_4.PNG|center]]

===== Делаем приблизительное выделение =====

При выборке с помощью Foreground Selection нужно предварительно очертить мышью выбираемый объект в окне программы. Указатель
мыши будет выглядеть точно так же, как в инструменте Free Select - Свободное выделение. Щелкаем и обводим рукой контур вокруг нужного нам объекта - разрешается выходить за пределы окна изображения, чтобы руке было удобнее.
[[Image:Img_76_79_5.jpg|center]]

===== Уточнение выделения =====

По умолчанию кнопка смены выделения объекта/фона стоит в положении Mark Foreground - Выделение объекта, я не стал его менять.
Кисть не должна быть толще стебелька розы внизу изображения. Цвет кисти я выбрал зеленым, для большей наглядности следующего шага.
Теперь закрасим кистью розу вместе со стеблем.
[[Image:Img_76_80_1.PNG|center]]

===== Вторая попытка с Mark Background =====

Я не сумел захватить весь стебель розы! Однако я попробовал выбрать розу непосредственно с помощью Foreground Select, выделив фон
инструментом Fuzzy Select. Во второй попытке после проведения Free Select (Свободной выборки) я включил выделение фона (Mark Background), потом закрашивал только белые участки.
[[Image:Img_76_80_2.PNG|center]]

===== Настройка чувствительности =====

Понятно, что результат обязан быть значительно лучше, поэтому я пробовал снова и снова, при помощи ручной выборки и выделения фона
(Mark Background). Затем я включил параметр Feather - Сглаживание - и сдвинул все три ползунка регулировки чувствительности (Sensitivity) до отказа вправо. Как видите, качество вырезки значительно повысилось, но можно улучшить и этот результат, сузив
выделение на 1-2 пикселя перед вырезанием и вставкой.
[[Image:Img_76_80_3.PNG|center]]

Результат для этого конкретного изображения нельзя признать хорошим. Быстрая и грубая работа с Foreground Select давала некачественное выделение, пока я не взялся за настройку чувствительности. Для такого простого случая Fuzzy Select следует признать более быстрым и точным средством.

==== Часть 2 - выделение изображения на сложном фоне ====

С простой задачей Fuzzy Select справился лучше. Теперь посмотрим, кто победит при работе с более сложным изображением.

===== Берем Quick Mask =====

Картинка здесь посложнее, зато мячи проще вырезать. На успех Fuzzy Select рассчитывать не приходится: мячи лежат чересчур близко друг
к другу. Вдобавок они не очень-то отличаются по цвету от фона и от ракетки. Вероятно, Quick Mask из набора инструментов версии 2.2 будет лучшим выбором.
[[Image:Img_76_80_4.jpg|center]]

===== Закрашиваем вырезку =====

Нажмите кнопку Quick Mask. Ваше изображение примет красный оттенок, кнопка тоже покраснеет. Красное пространство в выделение не
попадет. Перекрасьте кистью (Paintbrush) участок, который хотите
выделить, предварительно сделав цвет краски (Foreground) белым - нажмите [D] (цвета по умолчанию) и [X] (инвертировать цвета).
[[Image:Img_76_80_5.PNG|center]]

===== Вставляем в другой слой =====

Оценим выделение, скопировав объект и вставив его в новый слой. На контрастном черном фоне виднее контур мяча. Для редактирования
выделения вернем маску на место (Layer > Alpha To Selection - Слой > Прозрачность в выделение), возвратимся в первоначальный слой, включим Quick Mask и закрасим заново.
[[Image:Img_76_81_1.PNG|center]]

===== Проба SIOX =====

Foreground Select в Gimp 2.4 работает немного лучше, но постоянно прихватывает лишние участки. Рисунок запечатлел четыре разные
попытки работы с этим инструментом. В последней из них удалось показать ворс на мячике - для Quick Mask подобное почти невозможно.
[[Image:Img_76_81_2.jpg|center]]

===== Играем с картинками =====
{{Врезка|right|
|Заголовок=CREDIT TO...
|Содержание=Images used in this tutorial are from http://www.BigStockPhoto.com and the free collection at http://PDPhoto.org.
|Ширина=150px}}

Перебрав еще несколько изображений, я нашел то, в котором, на мой взгляд, Foreground Select проявил себя очень неплохо. Однако разработчики SIOX говорят, что при работе в режиме Mark Foreground, нежелательно, чтобы пиксели фона и вырезки имели сходные цвета.
В случае выделения кофе в чашке могут возникнуть проблемы.
[[Image:Img_76_81_3.jpg|center]]

===== Выделение фона =====

Как обычно, выбираемый объект очерчивается по контуру от руки. Я провел черту, начав ее вне окна изображения, снизу вправо, и вывел ее снова в окно справа наверху. Затем я закрасил чашку широкой кистью со сглаживающим фактором четыре. В вырезку попал только
маленький кусочек фона, слева внизу.
[[Image:Img_76_81_4.PNG|center]]

===== Уточнение выделения =====

Включите выделение фона (Mark Background) и закрасьте нежелательные участки фона для их удаления. Quick Mask могла бы сгладить ободок чашки так же быстро.
[[Image:Img_76_81_5.png|center]]

==== Подведем итоги ====

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

Поймите меня правильно, я не отрицаю, что Foreground Select имеет значительный потенциал. Обратите внимание, что в случае
с изображением чашки кофе (там, где программа смогла блеснуть способностями) я сделал вырезку меньше чем за минуту. Но отнюдь не
очевидно, где почва для наилучшего применения программы. Инструмент может делать хотя и не идеальную, но очень хорошую
выборку. Весьма способствует результату работа над параметрами. И не забудьте, что ко времени официального выхода версии 2.4 инструмент Foreground Selection может реально измениться (я пользовался версией Gimp 2.3.4 для разработчиков) - не спешите соглашаться с моей критикой.