Python/Учебник Python 2.6: различия между версиями

При наборе символа конца файла (<tt>Ctrl-D</tt> в Unix, <tt>Ctrl-Z</tt> в Windows) в ответ на основное приглашение интерпретатора, последний будет вынужден закончить работу с нулевым статусом выхода. Если это не сработает — вы можете выйти из интерпретатора путём ввода следующих команд:

 

 

Особенности редактирования строк в интерпретаторе, обычно не вызывают, особых сложностей. Те, кто установил интерпретатор на машину Unix, потенциально имеют поддержку библиотеки [[w:GNU Readline|GNU Readline]], обеспечивающей усовершенствованное интерактивное редактирование и сохранение истории. Самый быстрый, наверное, способ проверить, поддерживается ли расширенное редактирование командной строки, заключается в нажатии <tt>Ctrl-P</tt> в ответ на первое полученное приглашение Python. Если вы услышите сигнал — значит вам доступно редактирование командной строки — тогда обратитесь к [[Учебник Python 2.6 — Приложения#Интерактивное редактирование входных данных и подстановка истории|Приложению об Интерактивном редактировании входных данных]] за описанием клавиш. Если на ваш взгляд ничего не произошло или отобразился символ <tt>^P</tt> — редактирование командной строки недоступно — удалять символы из текущей строки возможно будет лишь использованием клавиши <tt>Backspace</tt>.

Если команды считываются с <tt>tty</tt> — говорят, что интерпретатор находится в ''интерактивном режиме'' (режиме диалога). В этом режиме он приглашает к вводу следующей команды, отобразив ''основное приглашение''<ref>''(Прим. перев.)'' <tt>primary prompt</tt> — ''зд.'', основное приглашение: приглашение к вводу команды или нескольких команд (сценария);</ref> (обычно это три знака «больше-чем» — <tt>&gt;&gt;&gt;</tt>); в то же время, для ''продолжающих строк''<ref>''(Прим. перев.)'' <tt>continuation lines</tt> — ''зд.'', продолжающие строки (строки продолжения): строки, продолжающие текст команды (оператора, выражения), или раскрывающие внутреннее устройство внешнего оператора (команды, выражения), в последнем случае определяются дополнительным отступом от края — углублением в структуру;</ref> выводится ''вспомогательное приглашение''<ref>''(Прим. перев.)'' <tt>secondary prompt</tt> — ''зд.'', вспомогательное приглашение: приглашение к продолжению ввода команды или набора команд (сценария) с использованием ''продолжающих строк'';</ref> (по умолчанию — три точки — <tt>...</tt>). Перед выводом первого приглашения интерпретатор отображает приветственное сообщение, содержащее номер его версии и пометку о правах копирования:

 

Python 2.6 (#1, Feb 28 2007, 00:02:06)

Type "help", "copyright", "credits" or "license" for more information.

 

''Продолжающие строки'' используются в случаях, когда необходимо ввести многострочную конструкцию. Взгляните, например, на следующий оператор <code>if</code><ref>''(Прим. перев.)'' Здесь и далее тексты некоторых исходных кодов также будут переведены в примечаниях (вместе с ключевыми словами, поэтому их нельзя будет запустить в интерпретаторе), чтобы показать их смысл или задумку, которые не всегда очевидны без перевода (если он вам нужен :) ):<br/><br/>

<span style="color: #030">Будьте осторожны — не упадите!</span></code><br/></ref>:

 

>>> if the_world_is_flat:

... print ("Be careful not to fall off!")

...

 

=== Интерпретатор и его окружение ===

Например, для написания таких символов в кодировке Unicode, как, например, знак валюты Евро — может быть использована кодировка <tt>ISO-8859-15</tt>, где знак Евро имеет порядковый номер 164. Этот сценарий выведет значение 8346 (место в таблице Unicode, соответствующее символу Евро) и затем выполнит выход:

 

currency = u"€"

 

Если ваш редактор поддерживает сохранение файлов в <tt>UTF-8</tt> вместе с пометкой порядка байтов (также известной как BOM - ''Byte Order Mark'') — вы можете использовать эту его возможность вместо указания кодировки. Редактор IDLE приобретает такую способность при установленном пункте меню <tt>Options/General/Default Source Encoding/UTF-8</tt>. Обратите внимание, что такие файлы не распознаются в прошлых релизах (2.2 и ранее), и также не распознаются самой операционной системой в случае файлов сценария со строкой <tt>#!</tt> в заголовке (используется только в системах Unix).

Если вы хотите прочитать дополнительный файл запуска из текущего каталога — вы можете использовать код вроде:

 

 

Если вы хотите использовать файл запуска в сценарии — вам нужно будет указать это явно:

 

filename = os.environ.get('PYTHONSTARTUP')

if filename and os.path.isfile(filename):

 

== Неформальное введение в Python ==

Несколько примеров:

 

SPAM = 1 # а это второй комментарий

# ... и наконец третий!

 

=== Использование Python в качестве калькулятора ===

Поведение интерпретатора сходно поведению калькулятора: вы вводите выражение, а в ответ он выводит значение. Синтаксис выражений прямолинеен: операторы <code>+</code>, <code>-</code>, <code>*</code> и <code>/</code> работают также как и в большинстве других языков (например, Паскале или C); для группировки можно использовать скобки. Например:

 

4

>>> # Это комментарий

2

>>> 7//-3

 

Знак равенства (<code>'='</code>) используется для присваивания переменной какого-либо значения. После этого действия в интерактивном режиме ничего не выводится:

 

>>> height = 5*9

>>> width * height

 

Значение может быть присвоено нескольким переменным одновременно:

 

>>> x

0

0

>>> z

 

Переменные должны быть ''определены'' (<tt>defined</tt>) (должны иметь присвоенное значение) перед использованием, иначе будет сгенерирована ошибка:

 

... n

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

 

Присутствует полная поддержка операций с плавающей точкой; операторы с операндами смешанного типа конвертируют целочисленный операнд в число с плавающей точкой:

 

7.5

>>> 7.0 / 2

 

Также поддерживаются комплексные числа; к мнимым частям добавляется суффикс <code>j</code> или <code>J</code>. Комплексные числа с ненулевым вещественным компонентом записываются в виде <code>(''<вещественная_часть>''+''<мнимая_часть>''j)</code>, или могут быть созданы с помощью функции <code>complex(''<вещественная_часть>'', ''<мнимая_часть>'')</code>.

 

(-1+0j)

>>> 1j * complex(0, 1)

(9+3j)

>>> (1+2j)/(1+1j)

 

Комплексные числа всегда представлены в виде двух чисел с плавающей точкой - вещественной и мнимой частями. Для получения этих частей из комплексного числа <code>z</code> используйте <code>z.real</code> и <code>z.imag</code>.

 

>>> a.real

1.5

>>> a.imag

 

Функции конвертации (приведения) к вещественным и целым числам (<code>float()</code>, <code>int()</code> и <code>long()</code>) не работают с комплексными числами — нет единственно правильного способа сконвертировать комплексное число в вещественное. Используйте функцию <code>abs(z)</code> чтобы получить ''модуль'' числа (в виде числа с плавающей точкой) или <code>z.real</code> чтобы получить его вещественную часть:

 

>>> float(a)

Traceback (most recent call last):

>>> abs(a) # sqrt(a.real**2 + a.imag**2)

5.0

 

В интерактивном режиме последнее выведенное выражение сохраняется в переменной <code>_</code>. Это значит, что если вы используете Python в качестве настольного калькулятора — всегда есть способ продолжить вычисления с меньшими усилиями, например:

 

>>> price = 100.50

>>> price * tax

>>> round(_, 2)

113.06

 

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

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

 

'spam eggs'

>>> 'doesn\'t'

'"Yes," he said.'

>>> '"Isn\'t," she said.'

 

несколько строк текста — такой вы бы представили её в C.\n\

Обратите внимание, что пробельное пространство в начале строки\

имеет значение."

 

 

several lines of text just as you would do in C.\n\

Note that whitespace at the beginning of the line is\

significant."

 

 

Обратите внимание, что для переноса строки все ещё нужно указывать <code>\n</code>; строка, за которой следует обратный слэш перенесена не будет. Запуск примера выведет следующее:

Если мы объявим строковой литерал ''сырым'' (<tt>raw</tt>)<ref>''(Прим. перев.)'' ''raw string'' — для описания ''сырой строки'' (не требующей последующей обработки) используется префикс '''<code>r</code>'''.</ref> — символы <code>\n</code> не будут конвертированы в новые строки, таким образом и обратный слэш в конце строки, и символ новой строки в исходном коде — будут добавлены в строку в виде данных. Следовательно, код из примера:

 

several lines of text much as you would do in C."

 

 

выведет:

Или строки могут быть обрамлены совпадающей парой тройных кавычек: <code>"""</code> или <code><nowiki>'''</nowiki></code>. Окончания каждой строчки не нужно завершать тройными кавычками. В примере ниже строки, начинающиеся с дефиса, также будут включены в строку.

 

Usage: thingy [OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

 

выводит в результате следующее:

 

-h Display this usage message

 

Интерпретатор выводит результаты операций над строками тем же способом, каким они были введены: в кавычках, а также в кавычках и с другими забавными символами, экранированными обратными слэшами — для того, чтобы показать точное значение. Строка заключается в двойные кавычки, если строка содержит одинарную кавычку и ни одной двойной, иначе она заключается в одинарные кавычки. (Оператор <code>print</code>, описанный позже, может использоваться для вывода строк без кавычек или экранирования.)

Строки могут конкатенироваться (склеиваться вместе) оператором <code>+</code> и быть повторенными оператором <code>*</code>:

 

>>> word

'HelpA'

>>> '<' + word*5 + '>'

 

Два строковых литерала, расположенные друг за другом, автоматически конкатенируются; первая строка в предыдущем примере также могла быть записана как <code>word = 'Help' 'A'</code>; это работает только с двумя литералами — не с произвольными выражениями, содержащими строки.

 

'string'

>>> 'str'.strip() + 'ing' # <- Так — верно

'str'.strip() 'ing'

^

 

Строки могут быть проиндексированы; также как и в C, первый символ строки имеет индекс <tt>0</tt>. Отсутствует отдельный тип для символов; символ является строкой с единичной длиной. Подобно языку [[w:Icon (язык программирования)|Icon]], подстроки могут определены через нотацию срезов (<tt>slice</tt>): два индекса, разделенных двоеточием.

 

>>> word[4]

'A'

'He'

>>> word[2:4]

 

Индексы срезов имеют полезные значения по умолчанию; опущенный первый индекс заменяется нулём, опущенный второй индекс подменяется размером срезаемой строки.

 

'He'

>>> word[2:] # Всё, исключая первые два символа

 

В отличие от строк в C, строки Python не могут быть изменены. Присваивание по позиции индекса строки вызывает ошибку:

 

Traceback (most recent call last):

File "<stdin>", line 1, in ?

Traceback (most recent call last):

File "<stdin>", line 1, in ?

 

Тем не менее, создание новой строки со смешанным содержимым — процесс легкий и очевидный:

 

'xelpA'

>>> 'Splat' + word[4]

 

Полезный инвариант операции среза: <code>s[:i] + s[i:]</code> эквивалентно <code>s</code>.

 

'HelpA'

>>> word[:3] + word[3:]

 

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

 

'elpA'

>>> word[10:]

''

>>> word[2:1]

 

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

 

'A'

>>> word[-2] # Предпоследний символ

'pA'

>>> word[:-2] # Всё, кроме последних двух символов

 

Но обратите внимание, что <tt>-0</tt> действительно эквивалентен <tt>0</tt> - это не отсчет справа.

 

 

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

 

'HelpA'

>>> word[-10] # ошибка

Traceback (most recent call last):

File "<stdin>", line 1, in ?

 

Один из способов запомнить, как работают срезы — думать о них, как об указателях на места между символами, где левый край первого символа установлен в ноль, а правый край последнего символа строки из <code>n</code> символов имеет индекс <code>n</code>, например:

Встроенная функция <code>len()</code> возвращает длину строки<ref>''(Прим. перев.)'': [[w:en:Supercalifragilisticexpialidocious|Supercalifragilisticexpialidocious]] — английское слово из одноименной песни, прозвучавшей в фильме [[w:en:Mary Poppins (film)|Мэри Поппинс]].</ref>:

 

>>> len(s)

 

{{Смотрите также|

Создание в Python строк в Unicode является действием настолько же простым, насколько простым является и создание обычных строк:

 

 

Строчная буква "<code>u</code>" перед кавычкой указывает на необходимость создания Unicode-строки. Если вы хотите включить в строку специальные символы — вы можете сделать это используя ''кодирование Unicode-Экранированием'' Python (<tt>Python Unicode-Escape encoding</tt>). Следующий пример поясняет как:

 

 

Экранированная последовательность <code>\u0020</code> указывает на позицию, куда требуется вставить символ Unicode с порядковым номером <tt>0x0020</tt> (символ пробела).

Для экспертов присутствует также ''сырой'' режим — такой же, как и для обычных строк. Вам требуется поставить перед открывающей кавычкой префикс "<code>ur</code>", чтобы Python использовал ''кодирование Сырым-Unicode-Экранированием'' (<tt>Raw-Unicode-Escape encoding</tt>). Описанная выше конверсия <code>\uXXXX</code> будет применена только при условии наличия перед строчной "<code>u</code>" нечётного количества обратных слэшей.

 

u'Hello World !'

>>> ur'Hello\\u0020World !'

 

''Сырой'' режим наиболее полезен, если вам необходимо ввести множество обратных слэшей — это может потребоваться в случае использования регулярных выражений.

Встроенная функция <code>unicode()</code> предоставляет доступ ко всем зарегистрированным кодекам ('''код'''ировщикам и '''дек'''одировщикам) Unicode. Наиболее известными кодировками, которые могут использовать эти кодеки являются <tt>Latin-1</tt>, <tt>ASCII</tt>, <tt>UTF-8</tt> и <tt>UTF-16</tt>. Последние две — кодировки с ''различными длинами'' элементов — они могут хранить каждый символ Unicode в одном или более байтах<ref>''(Прим. перев.)'' <tt>[[w:UTF-16|UTF-16]]</tt> — либо в двух либо в четырёх байтах, <tt>[[w:UTF-8|UTF-8]]</tt> — от одного до четырёх байт</ref>. Кодировкой по умолчанию установлена <tt>ASCII</tt>, принимающая все символы в диапазоне от <tt>0</tt> до <tt>127</tt> и отвергающая любые другие символы сообщением об ошибке. В случае, если Unicode-строка выводится на печать, пишется в файл или конвертируется функцией <code>str()</code> — конвертирование производится с использованием кодировки по умолчанию.

 

u'abc'

>>> str(u"abc")

Traceback (most recent call last):

File "<stdin>", line 1, in ?

 

Для конвертирования Unicode-строки в строку с использованием желаемой кодировки, объекты Unicode предоставляют метод <code>encode()</code>, имеющей формат <code>encode([encoding,[,errors]]</code>. Encoding - необязательный аргумент, указывающий в какую кодировку стоит перевести строку. По умолчанию - ASCII. Errors - так же необязательный аргумент - указывает на способ обработки ошибок кодировщиком. По умолчанию используется 'strict' - если символ не может быть представлен в данной кодировке, генерируется исключение UnicodeError. Другие возможные значения - 'ignore' (отсутствующие символы удаляются) и 'replace' - (отсутствующие в кодировке символы заменяются, обычно на символ '?'). Для именования кодировок предпочитаются названия записанные в нижнем регистре.

 

 

Если у вас есть в наличии данные в некоторой кодировке, а вы хотите создать на их основе соответствующую строку в Unicode — вы можете использовать функцию <code>unicode()</code>, передав название кодировки вторым аргументом.

 

 

==== Списки ====

В языке Python доступно некоторое количество ''составных'' типов данных, использующихся для группировки прочих значений вместе. Наиболее гибкий из них — список (<tt>list</tt>); его можно выразить через разделённые запятыми значения (''элементы''), заключённые в квадратные скобки. Элементы списка могут быть разных типов.

 

>>> a

 

Подобно индексам в строках, индексы списков начинаются с нуля, списки могут быть срезаны, объединены (''конкатенированы'') и так далее:

 

'spam'

>>> a[3]

['spam', 'eggs', 'bacon', 4]

>>> 3*a[:3] + ['Boo!']

 

В отличие от строк, являющихся неизменяемыми, изменить индивидуальные элементы списка вполне возможно:

 

['spam', 'eggs', 100, 1234]

>>> a[2] = a[2] + 23

>>> a

 

Присваивание срезу также возможно, и это действие может даже изменить размер списка или полностью его очистить:

 

... a[0:2] = [1, 12]

>>> a

>>> a[:] = []

>>> a

 

Встроенная функция <code>len()</code> также применима к спискам:

 

>>> len(a)

 

Вы можете встраивать списки (создавать списки, содержащие другие списки), например так:

 

>>> p = [1, q, 4]

>>> len(p)

[2, 3]

>>> p[1][0]

 

Вы можете добавить что-нибудь в конец списка.

 

>>> p

[1, [2, 3, 'xtra'], 4]

>>> q

 

Обратите внимание, что в последнем примере <code>p[1]</code> и <code>q</code> на самом деле ссылаются на один и тот же объект! Мы вернёмся к ''семантике объектов'' позже.

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

 

... # сумма двух элементов определяет следущий элемент

... a, b = 0, 1

3

5

 

Этот пример представляет нам некоторые новые возможности.

 

* Оператор <code>print</code> выводит значения переданного(-ных) ему выражения(-ний). Это поведение отличается от обычного вывода выражения (как происходило выше в примерах с калькулятором) тем, каким способом обрабатываются ряды выражений и строки. Строки выводятся без кавычек и между элементами вставляются пробелы, благодаря чему форматирование вывода становится более удобным — как, например, здесь:

>>> print ('Значением i является', i)

:Замыкающая строку запятая отменяет перевод строки после вывода:

>>> while b < 1000:

... print b,

... a, b = b, a+b

...

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

 

Возможно наиболее широко известный тип выражения &#151; оператор <code>if</code>. Пример:

 

print(x)

>>> if x < 0:

... print ('Больше')

...

 

Блоков <code>elif</code> может быть ноль или больше, а блок <code>else</code> не обязателен. Ключевое слово „<tt>elif</tt>“ — краткая запись „<tt>else if</tt>“ — позволяет избавиться от чрезмерных отступов. Последовательность <code>if</code> <tt>...</tt> <code>elif</code> <tt>...</tt> <code>elif</code> <tt>...</tt> — замена операторам <code>switch</code> или <code>case</code>, которые можно встретить в других языках.

Оператор <code>for</code> в Python немного отличается от того, какой вы, возможно, использовали в C или Pascal. Вместо неизменного прохождения по арифметической прогрессии из чисел (как в Pascal) или предоставления пользователю возможности указать шаг итерации и условие останова (как в С), оператор <code>for</code> в Python проходит по всем элементам любой последовательности (списка или строки) в том порядке, в котором они в ней располагаются. Например (игра слов не подразумевалась):<ref>''(Прим. перев.)'' Defenestrate{{ref-en}} — выкидывать кого-либо из окна с целью покалечить. Другие слова — «кошка» и «окно».</ref>

 

... a = ['cat', 'window', 'defenestrate']

>>> for x in a:

cat 3

window 6

 

Изменять содержимое последовательности, по которой проходит цикл, небезопасно (это можно сделать только для изменяемых типов последовательностей, таких как списки).

Нотация срезов делает это практически безболезненным:

 

... if len(x) > 6: a.insert(0, x)

...

>>> a

 

=== Функция <code>range()</code> ===

Если вам нужно перебрать последовательность чисел, встроенная функция <code>range()</code> придёт на помощь. Она генерирует списки, содержащие арифметические прогрессии:

 

 

Указанная точка завершения никогда не оказывается частью сгенерированного списка; вызов <code>range(10)</code> генерирует список из десяти значений — потенциальные индексы для элементов последовательности длиной 10. Позволено установить начало списка на другое число или указать другую величину инкремента (даже негативную; иногда её называют ''шагом'' (<tt>step</tt>)).

 

[5, 6, 7, 8, 9]

>>> range(0, 10, 3)

[0, 3, 6, 9]

>>> range(-10, -100, -30)

 

Чтобы пройти по всем индексам какой-либо последовательности, совместите вызовы <code>range()</code> и <code>len()</code> следующим образом:

 

>>> for i in range(len(a)):

... print i, a[i]

2 a

3 little

 

Однако в большинстве таких случаев удобно использовать функцию <code>enumerate()</code>.

Операторы циклов могут иметь ветвь <code>else</code>; она исполняется, когда цикл прекращает сквозной анализ списка (в случае <code>for</code>) или когда условие становится ложным (в случае <code>while</code>), но не в тех случаях, когда цикл прерывается по <code>break</code>. Это поведение иллюстрируется следующим примером, в котором производится поиск простых чисел:

 

... for x in range(2, n):

... if n % x == 0:

7 - простое число

8 равно 2 * 4

 

=== Оператор <code>pass</code> ===

Например:

 

... pass # Ожидание прерывания c клавиатуры (Ctrl+C) в режиме занятости

 

Этот оператор часто используется для создания минималистичных классов, к примеру ''исключений'' (<tt>exceptions<tt>), или для игнорирования нежелательных исключений:

 

... pass

...

... except ImportError:

... pass

 

Другой вариант: <code>pass</code> может применяться в качестве заглушки для тела функции или условия при создании нового кода, позволяя вам сохранить абстрактный взгляд на вещи.

С другой стороны, оператор <code>pass</code> игнорируется без каких-либо сигналов, и лучшим выбором было бы породить исключение <code>NotImplementedError</code>:

 

... raise NotImplementedError # Открыть файл для логгинга, если он ещё не открыт

... if not logfp:

... raise NotImplementedError # Настроить заглушку для логгинга

... raise NotImplementedError('Обработчик инициализации лога вызовов')

 

Если бы здесь использовались операторы <code>pass</code>, а позже вы бы запускали тесты, они могли бы упасть без указания причины.

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

 

... """Выводит ряд Фибоначчи, ограниченный n."""

... a, b = 0, 1

>>> # Теперь вызовем определенную нами функцию:

... fib(2000)

 

Зарезервированное слово <code>def</code> предваряет ''определение'' функции. За ним должны следовать имя функции и заключённый в скобки список формальных параметров. Выражения, формирующие тело функции, начинаются со следующей строки и должны иметь отступ.

При определении функции её имя также помещается в текущую таблицу символов. Тип значения, связанного с именем функции, распознается интерпретатором как функция, определённая пользователем (<tt>user-defined function</tt>). Само значение может быть присвоено другому имени, которое затем может также использоваться в качестве функции. Эта система работает в виде основного механизма переименования:

 

<function fib at 10042ed0>

>>> f = fib

>>> f(100)

 

Если вы использовали в работе другие языки программирования, вы можете возразить, что <code>fib</code> — это не функция, а процедура, поскольку не возвращает никакого значения. На самом деле, даже функции без ключевого слова <code>return</code> возвращают значение, хотя и более скучное. Такое значение именуется <code>None</code> (это встроенное имя). Описание значения <code>None</code> обычно придерживается за интерпретатором, если оно оказывается единственным значением, которое нужно вывести. Вы можете проследить за этим процессом, если действительно хотите, используя оператор <code>print</code>:

 

>>> print fib(0)

 

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

 

... """Возвращает список чисел ряда Фибоначчи, ограниченный n."""

... result = []

>>> f100 = fib2(100) # вызываем

>>> f100 # выводим результат

 

Этот пример, как уже привычно, демонстрирует некоторые новые возможности Python:

(''Refusenik''{{ref-en}} — [[w:ru:Отказник|Отказник]]). Ниже: «...<code>спросить_подтверждения('Вы действительно хотите выйти?')</code> или так: <code>спросить_подтверждения('Согласны ли вы перезаписать файл?', 2)</code>...»</ref>:

 

while True:

ok = raw_input(prompt)

retries = retries - 1

if retries < 0: raise IOError, 'refusenik user'

 

Эта функция может быть вызвана, например, так: <code>ask_ok('Do you really want to quit?')</code> или так: <code>ask_ok('OK to overwrite the file?', 2)</code>.

Значения по умолчанию вычисляются в точке определения функции — в ''определяющей'' области, поэтому код

 

 

def f(arg=i):

 

i = 6

 

выведет 5.

'''Важное предупреждение:''' Значение по умолчанию вычисляется лишь единожды. Это имеет вес, когда значением по умолчанию является изменяемый объект, такой как список, словарь (<tt>dictionary</tt>) или экземляры большинства классов. Например, следующая функция накапливает переданные ей аргументы с последовательными вызовами:

 

L.append(a)

return L

print f(1)

print f(2)

 

Она выведет

 

[1, 2]

 

==== Именованные аргументы <ref>''(Прим. перев.)'' В оригинале — Keyword Arguments — аргументы по ключевым словам, ключевые аргументы (далее используется слово ''keywords'' для набора имён параметров непостоянного количества. ''Ключевые'' - возможно, корректнее, но как мне показалось — менее понятно ([http://www.infocity.kiev.ua/prog/python/content/sempit_14.phtml альтернативный перевод]))</ref> ====

(''Из [http://www.ibras.dk/montypython/episode08.htm#6 скетча Монти Пайтона]'')</ref>:

 

print "-- This parrot wouldn't", action,

print "if you put", voltage, "volts through it."

print "-- Lovely plumage, the", type

 

могла бы быть вызвана любым из следующих способов<ref>''(Прим. перев.):''

попугай('миллион', 'лишённый жизни', 'прыжок')</code><br/><br/></ref>:

 

parrot(action = 'VOOOOOM', voltage = 1000000)

parrot('a thousand', state = 'pushing up the daisies')

 

а эти случаи оказались бы неверными<ref>''(Прим. перев.):''

попугай(исполнитель='Джон Клиз')</code><br/><br/></ref>:

 

parrot(voltage=5.0, 'dead') # неименованный аргумент следом за именованным

parrot(110, voltage=220) # повторное значение аргумента

 

В общем случае, список аргументов должен содержать любое количество позиционных (<tt>positional</tt>) аргументов, за которыми должно следовать любое количество именованных аргументов, и при этом имена аргументов выбираются из формальных параметров. Неважно, имеет формальный параметр значение по умолчанию или нет. Ни один из аргументов не может получать значение более чем один раз — имена формальных параметров, совпадающие с именами позиционных аргументов, не могут использоваться в качестве именующих в одном и том же вызове<ref>''(Прим. перев.)'' В главе о функциях автор отталкивается не от привычного по другим учебникам первоначального полного описания определения функций, а уже потом — описания их вызова, а объединяет обе темы вместе (как минимум в случае с непостоянным списком аргументов это возможно непривычно, но оправдано), отдавая приоритет описанию вызова. Учебник рассчитан на тех, кто уже программирует на каком-либо языке программирования и потенциально не должен смутить читателя.</ref>. Вот пример, завершающийся неудачей по причине описанного ограничения:

 

... pass

...

Traceback (most recent call last):

File "<stdin>", line 1, in ?

 

Если в определении функции присутствует завершающий параметр в виде ''**имя'' — он принимает словарь (подробнее в разделе [[Справочник по библиотеке Python 2.6#Маппинг типов|Справочника — Маппинг типов — словари]]), содержащий все именованные аргументы, исключая те, которые соответствуют формальным параметрам. Можно совместить эту особенность с поддержкой формального параметра в формате ''*имя'' (описывается в следующем подразделе), который получает кортеж (<tt>tuple</tt>), содержащий все позиционные аргументы, следующие за списком формальных параметров. (параметр в формате ''*имя'' должен описываться перед параметром в формате ''**имя''.) Например, если мы определим такую функцию<ref>''(Прим. перев.):''

(''Из [http://www.ibras.dk/montypython/episode33.htm#7 скетча Монти Пайтона]'')</ref>:

 

print "-- Do you have any", kind, "?"

print "-- I'm sorry, we're all out of", kind

keys = keywords.keys()

keys.sort()

 

то её можно будет вызвать так<ref>''(Прим. перев.):''

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;скетч="Скетч о сырной лавке")<br/></br></ref>:

 

"It's really very, VERY runny, sir.",

shopkeeper="Michael Palin",

client="John Cleese",

 

и она, конечно же, выведет<ref>''(Прим. перев.):''

Наконец, наиболее редко используется возможность указания того, что функция может быть вызвана с произвольным числом аргументов. При этом сами аргументы будут обёрнуты в кортеж (см. раздел [[#Кортежи и последовательности|Кортежи и последовательности]]). Переменное количество аргументов могут предварять ноль или более обычных аргументов.

 

 

==== Распаковка списков аргументов ====

Обратная ситуация возникает когда аргументы уже содержатся в списке или в кортеже, но должны быть распакованы для вызова функции, требующей отдельных позиционных аргументов. Например, встроенная функция <code>range()</code> ожидает отдельных аргументов ''start'' и ''stop'' соответственно. Если они не доступны раздельно, для распаковки аргументов из списка или кортежа в вызове функции используйте *-оператор:

 

[3, 4, 5]

>>> args = [3, 6]

>>> range(*args) # вызов с распакованными из списка аргументами

 

Схожим способом, словари могут получать именованные аргументы через **-оператор<ref>''(Прим. перев.):''

(''Из [http://www.ibras.dk/montypython/episode08.htm#6 скетча Монти Пайтона]'')</ref>:

 

... print "-- This parrot wouldn't", action,

... print "if you put", voltage, "volts through it.",

>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}

>>> parrot(**d)

 

==== Модель <tt>lambda</tt> ====

По частым просьбам, в Python были добавлены несколько возможностей, которые были привычны для функциональных языков программирования, таких как Lisp. Используя зарезервированное слово <code>lambda</code> вы можете создать небольшую анонимную функцию. Здесь представлена функция, которая возвращает сумму двух её аргументов: <code>lambda a, b: a+b</code>. Формы <code>lambda</code> могут быть использованы в любом месте где требуется объект функции. При этом они синтаксически ограничены на одно выражение. Семантически, они лишь синтаксический сахар для обычного определения функции. Как и определения вложенных функций, <code>lambda</code>-формы могут ссылаться на переменные из содержащей их области видимости:

 

... return lambda x: x + n

...

42

>>> f(1)

 

==== Строки документации ====

Вот пример многострочной документации (''док-строки''):

 

... """Не делаем ничего, но документируем.

...

Не делаем ничего, но документируем.

 

 

=== Интермеццо: Стиль написания кода ===

* Используйте строки документации (''док-строки'')

* Применяйте пробелы вокруг операторов и после запятых, но не добавляйте их в конструкции со скобками:

* Называйте ваши классы и функции единообразно; соглашение следующее: используйте <code>CamelCase</code><ref>''(Прим. перев.)'' <tt>CamelCase</tt> (''ВерблюжийСтиль'') — стиль именования идентификаторов, при котором все слова, записанные строчными буквами, объединяются в одно и первая буква каждого слова выделяется заглавной буквой — такая запись напоминает верблюжьи горбы, в связи с чем и названа.</ref> для именования классов и <code>нижний_регистр_с_подчёркиваниями</tt><ref>''(Прим. перев.)'' Пусть данный пример по вине переводчика и использует русские буквы, соглашение корректно настаивает на использовании латиницы для именования идентификаторов, см. следующий пункт соглашения</ref> для функций и методов. (обращайтесь к разделу [[#Первый взгляд на классы|Первый взгляд на классы]] за дополнительной информации о классах и методах)

* Не используйте в вашем коде изощрённых кодировок<ref>''(Прим. перев.)'' В строковых литералах (не комментариях) это, конечно же, позволено</ref>, если он рассчитан на использование в интернациональной среде. Стандартный набор ASCII всегда работает на ура<ref>''(Прим. перев.)'' Не кодировка, а именно набор символов — латиница, пунктуация и несколько служебных символов. Кодировка по умолчанию для файлов с исходными кодами, начиная с Python 3.0, всегда UTF-8 — дабы существовала возможность использовать национальные символы в строковых литералах и, в редких случаях — комментариях.</ref>.

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

 

>>> print a.count(333), a.count(66.25), a.count('x')

2 1 0

>>> a.sort()

>>> a

 

==== Использование списка в качестве стека ====

Методы списков позволяют легко использовать список в качестве стека, где последний добавленный элемент становится первым полученным („последним пришел — первым вышел“). Чтобы добавить элемент на вершину стека, используйте метод <code>append()</code>. Чтобы получить элемент с вершины стека, используйте метод <code>pop()</code>, без указания явного индекса. Например:

 

>>> stack.append(6)

>>> stack.append(7)

5

>>> stack

 

==== Использование списка в качестве очереди ====

Вы можете без труда использовать список также и в качестве очереди, где первый добавленный элемент оказывается первым полученным („первый пришёл — первый вышел“). Чтобы добавить элемент в конец очереди, используйте метод <code>append()</code>. Чтобы получить элемент из начала очереди, используйте метод <code>pop()</code> с нулём в качестве индекса. Например:

 

>>> queue.append("Terry") # Прибыл Terry

>>> queue.append("Graham") # Прибыл Graham

'John'

>>> queue

 

==== Инструменты функционального программирования ====

<code>filter(''функция'', ''последовательность'')</code> возвращает последовательность, состоящую из тех элементов ''последовательности'', для которых ''функция''(''элемент'') является истиной. Если последовательность — строка (<tt>string</tt>) или кортеж (<tt>tuple</tt>), результат будет иметь тот же тип; в других случаях — это всегда список. Например, чтобы найти несколько простых чисел:

 

...

>>> filter(f, range(2, 25)) # отфильтровать диапазон чисел от 2 до 24 через функцию f

 

----

<code>map(''функция'', ''последовательность'')</code> совершает вызов ''функция''(''элемент'') с каждым элементом ''последовательности'' и возвращает список из возвращавшихся функцией значений. Например, чтобы вычислить кубы нескольких чисел:

 

...

>>> map(cube, range(1, 11)) # спроецировать функцию cube на диапазон от 1 до 10

 

Можно передать более чем одну последовательность; тогда функция должна иметь столько аргументов, сколько передано последовательностей и вызывается для каждого соответствующего элемента каждой последовательности (или <code>None</code>, если одна из последовательностей короче другой). Например:

 

>>> def add(x, y): return x+y # функция add складывает свои аргументы

...

>>> map(add, seq, seq) # пропустить функцию add через две последовательности seq параллельно

 

----

<code>reduce(''функция'', ''последовательность'')</code> возвращает единственное значение, собранное из результатов вызовов двухаргументной ''функции'' с первыми двумя элементами последовательности, затем с полученным результатом и последующим элементом, и так далее. Например, чтобы сосчитать сумму чисел от 1 до 10:

 

...

>>> reduce(add, range(1, 11)) # пройти функцией add последовательно аккумулятивно по числам из диапазона от 1 до 10.

 

Если в последовательности только один элемент — возвращается его значение; если последовательность пуста — порождается исключение.

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

 

... def add(x,y): return x+y # определить внутреннюю функцию add, возвращающую сумму переданных параметров

... return reduce(add, seq, 0) # вернуть результат аккумулятивного прохождения функцией add по переданной

55

>>> sum([]) # сумма пустой последовательности

 

Не используйте определение функции <code>sum()</code> из этого примера: поскольку суммирование чисел — обычная необходимость, уже доступна встроенная функция <code>sum(''последовательность'')</code>, которая работает точно таким же образом.

Метод списковой сборки обеспечивает легкий способ создать список без обращений к <code>map()</code>, <code>filter()</code> и/или <code>lambda</code>. Определение списка, получающееся в результате, имеет тенденцию читаться проще чем списки, построенные с использованием таких конструкций. Каждая списковая сборка состоит из выражения, за которым следует оператор <code>for</code>, а затем ноль или более операторов <code>for</code> или <code>if</code>. Если в результате вычисления выражения получается кортеж, его нужно обернуть в скобки.

 

>>> [weapon.strip() for weapon in freshfruit] # взять каждый элемент списка freshfruit, и временно обозначив его как weapon

... # (создав алиас), обрезать у weapon пробелы

>>> [vec1[i]*vec2[i] for i in range(len(vec1))] # умножить i-ый элемент списка vec1 на i-ый элемент списка vec2

... # для всех i от нуля до длины массива vec1 минус единица включительно

 

Списковые сборки являются более гибкими чем функция <code>map()</code> и могут применяться к сложным выражениям и вложенным функциям<ref>''(Прим. перев.)'' в Python, как и в большинстве других языков программирования, используется европейский стандарт разделения целой и дробной части десятичных дробей точкой.</ref>:

 

... # 335 на 113, округлённый до i знаков за запятой

 

==== Вложенные списковые сборки ====

Представьте нижеследующий пример матрицы 3x3 в виде списка, содержащего три других списка, по одному в ряд:

 

... [1, 2, 3],

... [4, 5, 6],

... [7, 8, 9],

 

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

 

 

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

Чуть более многословная, но наглядная, версия этого примера позволяет взглянуть на процесс более детально:

 

for row in mat:

print row[i],

 

В реальных случаях лучше предпочесть встроенные функции, чем сложные выражения. В нашем случае поможет функция <code>zip()</code>:

 

 

В разделе [[#Распаковка списков аргументов|Распаковка списков аргументов]] описано предназначение звёздочки в этих строках.

Существует способ удалить элемент, указывая его индекс, а не его значение: оператор <code>del</code>. В отличие от метода <code>pop()</code>, он не возвращает значения. Оператор <code>del</del> может также использоваться для удаления срезов из списка или полной очистки списка (что мы делали ранее через присваивание пустого списка срезу). Например:

 

>>> del a[0]

>>> a

>>> del a[:]

>>> a

 

<code>del</code> может быть также использован для удаления переменных полностью:

 

 

Ссылка на имя <code>a</code> в дальнейшем вызовет ошибку (по крайней мере до тех пор, пока с ним не будет связано другое значение). Позже мы с вами узнаем другие способы использования <code>del</code>.

Кортеж состоит из некоторого числа значений разделённых запятыми, например:

 

>>> t[0]

12345

... u = t, (1, 2, 3, 4, 5)

>>> u

 

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

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

 

>>> singleton = 'hello', # <-- обратите внимание на замыкающую запятую

>>> len(empty)

1

>>> singleton

 

Выражение <code>t = 12345, 54321, 'hello!'</code> является примером ''упаковки кортежей'' (<tt>tuple packing</tt>): значения <code>12345</code>, <code>54321</code> и <code>'hello!'</code> упаковываются в кортеж вместе. Обратная операция также возможна:

 

 

Такое действие называется, довольно удачно, ''распаковкой последовательности'' (<tt>sequence unpacking</tt>). Для распаковки на левой стороне требуется список переменных с количеством элементов равным длине последовательности. Обратите внимание, что множественное присваивание на самом деле является лишь комбинацией упаковки кортежа и распаковки последовательности.

Ложь</code><br/><br/></ref>:

 

>>> fruit = set(basket) # создать множество

>>> fruit

True

>>> 'crabgrass' in fruit

 

...

>>> a = set('abracadabra')

set(['a', 'c'])

>>> a ^ b # буквы в a или в b, но не в обоих

 

=== Словари ===

Вот небольшой пример использования словарей:

 

>>> tel['guido'] = 4127

>>> tel

['guido', 'irv', 'jack']

>>> 'guido' in tel

 

Конструктор <code>dict()</code> строит словарь непосредственно на основе пар ключ-значение, где каждая пара представлена в виде кортежа. Когда пары могут быть сформированы шаблоном, ''списковые сборки'' помогут описать список пар ключ-значение более компактно.

 

{'sape': 4139, 'jack': 4098, 'guido': 4127}

>>> dict([(x, x**2) for x in (2, 4, 6)]) # использование списковой сборки

 

Позже в учебнике мы изучим выражения-генераторы (<tt>Generator Expressions</tt>), которые даже лучше подходят для снабжения конструктора <code>dict()</code> парами ключ-значение.

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

 

 

=== Техника прохода циклом ===

При прохождении словарей циклом, ключ и соответствующее ему значение могут быть получены параллельно посредством метода <code>iteritems()</code>.

 

>>> for k, v in knights.iteritems():

... print k, v

...

gallahad the pure

 

При прохождении циклом последовательностей, индекс позиции и соответствующее ему значение могут быть получены одновременно посредством функции <code>enumerate()</code>.

... print i, v

...

0 tic

1 tac

 

Для того, чтобы пройти циклом две или более последовательности параллельно, вхождения можно сгруппировать функцией <code>zip()</code><ref>''(Прим. перев.):''

Каков(о) ваш(е) любимый цвет? синий.</code></ref>.

 

>>> answers = ['lancelot', 'the holy grail', 'blue']

>>> for q, a in zip(questions, answers):

What is your name? It is lancelot.

What is your quest? It is the holy grail.

 

Чтобы пройти циклом последовательность в обратном порядке, сначала укажите последовательность в прямом направлении, а затем вызовите функцию <code>reversed()</code>.

 

... print i

...

5

3

 

Чтобы пройти циклом последовательность в отсортированном порядке, используйте функцию <code>sorted()</code>, которая возвращает отсортированный список, оставляя исходный без изменений.

 

>>> for f in sorted(set(basket)):

... print f

banana

orange

 

=== Подробнее об условиях ===

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

 

>>> non_null = string1 or string2 or string3

>>> non_null

 

Заметьте, что в Python, в отличие от C, присваивание не может использоваться внутри выражений. Программисты на C могут возмутиться по этому поводу, но на самом деле это позволяет избежать класса проблем, обычного для программ на C: ввода <code>=</code> в выражении, вместо предполагавшегося <code>==</code>.

Объекты последовательностей можно сравнивать с другими объектами с тем же типом последовательности. Сравнение использует лексикографический порядок: сравниваются первые два элемента, и если они различны — результат сравнения определён; если они равны, сравниваются следующие два элемента и так далее до тех пор, пока одна из последовательностей не будет истощена. Если сравниваемые два элемента сами являются последовательностями одного типа, лексикографическое сравнение входит в них рекурсивно. Если все элементы обеих последовательностей оказались равны, последовательности считаются равными. Если одна последовательность оказывается стартовой последовательностью другой, более короткая последовательность считается меньшей. Лексикографическое упорядочивание строк использует порядок в таблице ASCII для индивидуальных символов. Несколько примеров сравнений между однотипными последовательностями:

 

[1, 2, 3] < [1, 2, 4]

'ABC' < 'C' < 'Pascal' < 'Python'

(1, 2) < (1, 2, -1)

(1, 2, 3) == (1.0, 2.0, 3.0)

 

Обратите внимание, что разрешено сравнение объектов разных типов. Итог обусловлен, но кажется произвольным: типы сортируются по их имени. Таким образом, список (<tt>list</tt>) всегда меньше строки (<tt>string</tt>), строка всегда меньше кортежа (<tt>tuple</tt>) и т.д.<ref>Не стоит полагаться на правила сравнения разных типов — в последующих версиях языка они могут быть изменены.</ref> Смешанные числовые типы сравниваются в соответствии с их численными значениями, так что <code>0</code> равен <code>0.0</code> и т.д.

Модуль — это файл, содержащий определения и выражения на Python. Именем файла является имя модуля с добавленным суффиксом <tt>.py</tt>. Внутри модуля его имя (в качестве строки) доступно в виде значения глобальной переменной с именем <code>__name__</code>. Например, используя ваш любимый текстовый редактор создайте в текущем каталоге файл с именем <tt>fibo.py</tt> со следующим содержимым (не забывайте, что первой или второй строкой файла должна быть строка с указанием кодировки):

 

# -*- coding: iso-8859-15 -*-

# модуль вычисления чисел Фибоначчи

result.append(b)

a, b = b, a+b

 

Теперь войдите в интерпретатор Python и импортируйте этот модуль следующей командой:

 

 

Это действие не переводит имена определённых функций в текущую таблицу символов; здесь вводится лишь имя модуля <code>fibo</code>. Используя имя модуля вы можете получить доступ к функциям:

 

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

>>> fibo.fib2(100)

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

>>> fibo.__name__

 

Если вы собираетесь использовать функцию часто, вы можете присвоить её локальному имени:

 

>>> fib(500)

 

=== Подробнее о модулях ===

Есть вариация оператора <code>import</code>, которая переносит имена из модуля прямо в таблицу символов импортирующего модуля. Например:

 

>>> fib(500)

 

При этом имя самого модуля, из которого переносятся имена элементов, не добавляется в ''локальную таблицу символов'' (так, в этом примере, имя <code>fibo</code> не определено)

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

 

>>> fib(500)

 

Импортируются все имена, кроме тех, которые начинаются на подчёркивание (<code>_</code>).

Когда вы запускаете модуль Python в виде

 

 

то код в этом модуле будет исполнен в момент его импортирования, но значение <code>__name__</code> будет установлено как <code>"__main__"</code>. Это значит, что добавляя этот код в конец сценария:

 

import sys

 

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

 

 

Если модуль импортируется, код не будет выполнен:

 

 

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

Python поставляется с библиотекой стандартных модулей, описанной в отдельном документе, [[Справочник по библиотеке Python 2.6|Справочнике по библиотеке Python]] (далее — «Справочнику по библиотеке»). Некоторые модули встроены в интерпретатор; они обеспечивают доступ к операциям, не являющимся ядром языка, но несмотря на это, они встроены для большей эффективности и предоставления доступа к примитивам операционной системы, таким как ''системные вызовы'' (<tt>system calls</tt>). Набор таких модулей — выбор настройки, который также зависит от используемой платформы. Например, модуль <code>winreg</code> предоставляется только на тех системах, на которые установлен Windows. Один конкретный модуль заслуживает большего внимания: модуль <tt>[[Справочник по библиотеке Python 2.6#sys|sys]]</tt>, встроенный в каждую версию интерпретатора Python. Переменные </code>sys.ps1</code> и <code>sys.ps2</code> определяют строки, использующиеся в качестве основного и вспомогательного приглашений:

 

>>> sys.ps1

'>>> '

C> print 'Yuck!'

Yuck!

 

Эти две переменные определены только если интерпретатор находится в интерактивном режиме.

Переменная <code>sys.path</code> представляет собой список строк, определяющий путь поиска модулей интерпретатора. Она инициируется путём по умолчанию, взятым из переменной окружения <tt>PYTHONPATH</tt>, или встроенным значением по умолчанию, если <tt>PYTHONPATH</tt> не установлен. Вы можете изменить её значение, используя стандартные операции со списками:

 

 

=== Функция <code>dir()</code> ===

Встроенная функция <code>dir()</code> используется для получения имён, определённых в модуле. Она возвращает отсортированный список строк:

 

>>> dir(fibo)

['__name__', 'fib', 'fib2']

'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdlopenflags',

'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',

 

Будучи использованной без аргументов, функция <code>dir()</code> возвращает список имён, определённых в данный момент.

 

>>> import fibo

>>> fib = fibo.fib

>>> dir()

 

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

В списке, возвращаемом функцией <code>dir()</code> не содержится встроенных функций и переменных. Если вы хотите получить ''их'' список, то они определены в стандартном модуле <code>__builtin__</code>:

 

>>> dir(__builtin__)

['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning',

'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set',

'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',

 

=== Пакеты ===

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

 

 

Таким образом подгружается подмодуль <code>sound.effects.echo</code>. Ссылаться на него нужно используя его полное имя:

 

 

Другой способ импортирования подмодуля:

 

 

Так тоже подгружается подмодуль <code>echo</code>, но теперь он доступен без префикса пакета, поэтому может использоваться следующим образом:

 

 

И еще один вариант — прямое импортирование желаемой функции или переменной:

 

 

Опять же, таким образом подгружается подмодуль <code>echo</code>, но теперь его функция <code>echofilter()</code> может быть вызвана непосредственно:

 

 

Заметьте, что при использовании выражения <code>from ''пакет'' import ''элемент''</code>, ''элементом'' может быть подмодуль (или подпакет) пакета или любое другое имя, определённое в пакете - например, функция, класс или переменная. Оператор <code>import</code> сначала проверяет, определён ли элемент в пакете; если нет — он трактует его как модуль и пытается загрузить. Если не удается его найти, порождается исключение <code>ImportError</code>.

Единственный выход для автора пакета — предоставить его подробное содержание. Оператор <code>import</code> использует следующее соглашение: если в коде файла <tt>__init__.py</tt> текущего пакета определён список <code>__all__</code>, то он полагается списком имён модулей, которые нужно импортировать если обнаружено выражение <code>from ''пакет'' import *</code>. На совести автора поддержка этого списка в соответствующем состоянии в каждой новой версии пакета. Впрочем, авторы пакета могут его не поддерживать вообще, если не видят смысла в импортировании <code>*</code> из их пакета. Например, файл <code>sounds/effects/__init__.py</code> может содержать следующий код:

 

 

Это будет значить, что выражение <code>from sound.effects import *</code> импортирует три именованных подмодуля из пакета <code>sound</code>.

Если список <code>__all__</code> не определён, выражение <code>from Sound.Effects import *</code> не импортирует все подмодули пакета <code>sound.effects</code> в текущее пространство имён — оно лишь убеждается, что импортирован пакет <code>sound.effects</code> (возможно, выполняя код инициализации из <tt>__init__.py</tt>), а затем импортирует все определённые в пакете имена. В этот список попадают любые имена, определённые (и загруженные явно подмодулями) в <tt>__init__.py</tt>. В него также попадают все явно загруженные предшествующими операторами <code>import</code> подмодули. Рассмотрим следующий код:

 

import sound.effects.surround

 

В этом примере, модули <code>echo</code> и <code>surround</code> импортируются в текущее пространство имён, поскольку они определены в пакете <code>sound.effects</code> на тот момент, когда исполняется оператор <code>from ... import</code>. (И это также работает если определён <code>__all__</code>.)

Начиная с Python 2.5, в дополнение к описанным выше способам ''неявного относительного импортирования'' (<tt>implicit relative imports</tt>), вы можете использовать ''явное относительное импортирование'' (<tt>explicit relative imports</tt>) пользуясь формой <code>from ''модуль'' import ''имя''</code> оператора <code>import</code>. Такие способы импортирования используют символы точки для описания текущего и родительского пакетов, порожденных относительным импортированием. Например, для модуля <code>surround</code> вы можете написать:

 

from .. import Formats

 

Обратите внимание, что и явное и неявное относительное импортирование основано на имени текущего модуля. Поскольку имя главного модуля всегда „<code>__main__</code>“ — модули, предназначенные для использования в качестве главных модулей приложения на Python, должны всегда использовать ''абсолютное импортирование'' (<tt>absolute imports</tt>).

Несколько примеров:

 

>>> str(s)

'Привет, мир.'

>>> # Аргументом функции repr() может быть объект Python:

... repr((x, y, ('фарш', 'яйца')))

 

Вот два способа вывести таблицу квадратов и кубов:

 

... print repr(x).rjust(2), repr(x*x).rjust(3),

... # Заметьте замыкающую предыдущую строку запятую

8 64 512

9 81 729

 

(Обратите внимание, что в первом примере единичные пробелы между колонок добавлены за счёт принципов работы оператора <code>print</code>: он всегда вставляет пробелы между своими аргументами)

Есть другой метод, <code>zfill()</code>, который заполняет нулями пространство слева от числовой строки. Он распознаёт знаки плюс и минус:

 

'00012'

>>> '-3.14'.zfill(7)

'-003.14'

>>> '3.14159265359'.zfill(5)

 

Основной способ применения метода <code>str.format()</code> выглядит так<ref>''(Прим. перев.)'' We are the knights who say "Ni!" (''Мы - те рыцари, что говорят "Ни!"'') — цитата из [http://www.mwscomp.com/movies/grail/grail-13.htm сцены 13-й] фильма Монти Пайтон и Святой Грааль (Monty Python and Holy Grail)</ref>:

 

 

Скобки и символы, которые они окружают (их называют ''полями форматирования'' (<tt>format fields</tt>)) заменяются на объекты, переданные в метод <code>format</code>. Номер в скобках обозначает позицию объекта в списке аргументов, переданных в метод <code>format</code>.

 

фарш и яйца

>>> print '{1} и {0}'.format('фарш', 'яйца')

 

Если в методе <code>format</code> используются именованные аргументы, ссылаться на их значения можно используя имя соответствующего аргумента<ref>''(Прим. перев.)'' <tt>вывести('Этот {пища} — {прилагательное}.'.format(пища='фарш', прилагательное='непередаваемо ужасен'))</tt></ref>.

 

... food='фарш', adjective='непередаваемо ужасен')

 

Позиционные и именованные аргументы можно произвольно совмещать<ref>''(Прим. перев.)'' <tt>вывести 'История о {0}, {1}, и {другой}.'.форматировать('Билл', 'Манфред', другой='Георг')</tt></ref>:

 

other='Георг')

 

После имени поля может следовать необязательный спецификатор формата ‘<code>:</code>’. Пользуясь им, можно управлять тем, как значение будет отформатировано. Следующий пример оставляет у числа Пи только три цифры после десятичного разделителя<ref>''(Прим. перев.)'' В качестве десятичного разделителя в Python используется точка, в соответствии со стандартами большинства стран.</ref>.

 

>>> print 'Значение ПИ — примерно {0:.3f}.'.format(math.pi)

 

Если после спецификатора ‘<code>:</code>’ указать число — оно будет обозначать минимальную ширину поля, выраженную в количестве символов. Это удобно использовать для создания приятных для прочтения таблиц:

 

>>> for name, phone in table.items():

... print '{0:10} ==> {1:10d}'.format(name, phone)

Jack ==> 4098

Dcab ==> 7678

 

Если ваша строка с форматами очень длинна, а вы не хотите разбивать её на подстроки, было бы неплохо если бы вы могли ссылаться на переменные, предназначенные для форматирования, не по позиции, а по имени. Это можно сделать, просто передав словарь и используя квадратные скобки ‘<tt>[]</tt>’ для доступа к ключам.

 

>>> print 'Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '

'Dcab: {0[Dcab]:d}'.format(table)

 

Также это можно сделать, передав таблицу в виде именованных аргументов, используя нотацию „<code>**</code>“:

 

>>> print 'Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table)

 

Это, в отдельности, довольно полезно использовать в сочетании с новой встроенной функцией <code>vars()</code>, которая возвращает словарь, содержащий все локальные переменные.

Для форматирования строк можно использовать и оператор <code>%</code>. Он интерпретирует левый аргумент как строку форматирования в стиле <code>sprintf</code>, которую следует применить к правому аргументу, и возвращает строку, получившуюся за счёт этого преобразования. Например:

 

>>> print 'Значение ПИ — примерно %5.3f.' % math.pi

 

Поскольку метод <code>str.format()</code> довольно нов, большая часть исходных кодов Python всё ещё использует оператор <code>%<code>. Однако, со временем, форматирование строк будет удалено из языка, поэтому в большинстве случаев следует использовать <code>str.format()</code>.

Функция <code>open()</code> возвращает объект файла и в большинстве случаев используется с двумя аргументами: <code>open(''имя_файла'', ''режим'')</code>.

 

>>> print f

 

Первый аргумент — строка, содержащая имя файла. Второй аргумент — другая строка, содержащая несколько символов, описывающих каким образом файл будет использоваться. Значение аргумента ''режим'' может быть символом <code>'r'</code>, если файл будет открыт только для чтения, <code>'w'</code> — открыт только для записи (существующий файл с таким же именем будет стёрт), и <code>'a'</code> — файл открыт для добавления: любые данные, записанные в файл автоматически добавляются в конец. <code>'r+'</code> открывает файл и для чтения и для записи. Аргумент ''режим'' необязателен: если он опущен — предполагается, что он равен <code>'r'</code>.

Чтобы прочитать содержимое файла вызовите <code>f.read(''размер'')</code> — функция читает некоторое количество данных и возвращает их в виде строки. <code>''размер''</code> — необязательный числовой аргумент. Если <code>''размер''</code> опущен или отрицателен, будет прочитано и возвращено всё содержимое файла; если файл по величине в два раза больше оперативной памяти вашего компьютера, то решение этой проблемы остаётся на вашей совести. В обратном случае, будет прочитано и возвращено максимум <code>''размер''</code> байт. Если был достигнут конец файла, <code>f.read()</code> вернёт пустую строку (<code>""</code>).

 

'Это всё содержимое файла.\n'

>>> f.read()

 

<code>f.readline()</code> читает одну строку из файла; символ новой строки (<code>\n</code>) остаётся в конце прочитанной строки и отсутствует при чтении последней строки файла только если файл не оканчивается пустой строкой. За счёт этого возвращаемое значение становится недвусмысленным: если <code>f.readline()</code> возвращает пустую строку — достигнут конец файла, в то же время незаполненная строка, представленная посредством <code>'\n'</code>, содержит лишь символ новой строки.<ref>''(Прим. перев.)'' В источнике, в большинстве случаев, разделяется понятие ''строки'' как типа данных и ''строки'' как строки текста (ср., ''строчка'') за счёт слов ''string'' и ''line'' соответственно. В русском языке это различие передать сложно, тем не менее я старался по возможности избежать двусмысленностей.</ref>

 

'Это первая строка файла.\n'

>>> f.readline()

'Вторая строка файла\n'

>>> f.readline()

 

<code>f.readlines()</code> возвращает список, содержащий все строки с данными, обнаруженные в файле. Если передан необязательный параметр <code>подсказка_размера</code>, функция читает из файла указанное количество байт, плюс некоторое количество байт сверх, достаточное для завершения строки, и формирует список строк из результата. Функция часто используется для построчного чтения больших файлов, эффективного за счёт отсутствия необходимости загрузки файла в память полностью. Возвращены будут только полные (завершённые) строки.

 

 

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

 

print line,

Это первая строка файла.

 

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

<code>f.write(''строка'')</code> записывает содержимое ''строки'' в файл и возвращает <code>None</code>.

 

 

Чтобы записать в файл нечто отличное от строки, предварительно это нечто нужно в строку сконвертировать<ref>''(Прим. перев.)'' Возможно, подразумевается [[w:Ответ на главный вопрос жизни, вселенной и всего такого|ответ на главный вопрос жизни, вселенной и всего такого]]</ref>:

 

>>> s = str(value)

 

<code>f.tell()</code> возвращает целое, представляющее собой текущую позицию в файле объекта файла <code>f</code>, измеренную в байтах от начала файла. Чтобы изменить позицию объекта файла, используйте "<code>f.seek(''смещение'', ''откуда'')</code>". Позиция вычисляется за счёт сложения смещения и точки отсчёта; точка отсчёта выбирается из аргумента <code>''откуда''</code>. Значение <code>0</code> аргумента <code>''откуда''</code> отмеряет смещение от начала файла, значение <code>1</code> применяет текущую позицию в файле, а значение <code>2</code> в качестве точки отсчёта использует конец файла. Аргумент <code>''откуда''</code> может быть опущен и по умолчанию устанавливается в <code>0</code>, используя начало файла в качестве точки отсчёта.

 

>>> f.write('0123456789abcdef')

>>> f.seek(5) # Перейти к шестому байту в файле

>>> f.seek(-3, 2) # Перейти к третьему байту с конца

>>> f.read(1)

 

Когда вы закончили все действия над файлом, вызовите <code>f.close()</code> чтобы закрыть его и освободить все системные ресурсы, использованные при открытии этого файла. Все попытки использовать объект файла после вызова <code>f.close()</code> будут завершены неудачей.

 

>>> f.read()

Traceback (most recent call last):

File "<stdin>", line 1, in ?

 

Считается хорошей манерой использовать ключевое слово <code>with</code> при работе с объектами файлов. Преимущество этого способа в том, что файл всегда корректно закрывается после выполнения блока, либо если при выполнении было порождено исключение. Кроме того, получающийся код намного короче, чем эквивалентная форма с блоками <tt><code>try</code>-<code>finally</code></tt>:

 

... read_data = f.read()

>>> f.closed

 

У объектов файла есть ещё несколько дополнительных методов, таких как <code>isatty()</code> и <code>truncate()</code>, которые используются не так часто; обратитесь к [[Справочник по библиотеке Python 2.6|Справочнику по библиотеке]] для более полного обзора по объекту файла.

Если у вас есть некоторый объект <code>x</code> и объект файла <code>f</code>, открытый на запись, простейший способ ''законсервировать'' объект требует одной-единственной строки кода:

 

 

Чтобы снова расконсервировать объект, при условии, что <code>f</code> — объект файла, открытого для чтения:

 

 

(Существуют варианты выполнения этих операций, применяемые при ''расконсервации'' нескольких объектов или когда вам требуется записать ''консервированные'' данные в файл; проконсультируйтесь с полной документацией по модулю [[Справочник по библиотеке Python 2.6#pickle|pickle]] из [[Справочник по библиотеке Python 2.6|Справочника по библиотеке]].)

Синтаксические ошибки, также известные как ошибки разбора кода (''парсинга'', <tt>parsing</tt>) — вероятно, наиболее привычный вид протестов интерпретатора, попадающихся вам при изучении Python:

 

File "<stdin>", line 1, in ?

while True print 'Hello world'

^

 

Парсер<ref>''(Прим. перев.)'' ''Parser'' {{ref-en}} — программа синтаксического анализа, синтаксический анализатор; программа грамматического разбора</ref> повторно выводит возмутившую его строку и отображает небольшую «стрелку», указывающую на самую первую позицию в строке, где была обнаружена ошибка. Причина ошибки (или, по крайней мере, место обнаружения) находится в символе<ref>''(Прим. перев.)'' ''Token'' {{ref-en}} — некоторая смысловая единица выражения: оператор, ключевое слово, значение переменной, ...</ref>, предшествующем указанному: в приведённом примере ошибка обнаружена на месте вызова оператора <code>print</code>, поскольку перед ним пропущено двоеточие (<code>':'</code>). Также здесь выводятся имя файла и номер строки, благодаря этому вы знаете в каком месте искать, если ввод был сделан из сценария.

Даже если выражение или оператор синтаксически верны, они могут вызвать ошибку при попытке их исполнения. Ошибки, обнаруженные при исполнении, называются ''исключениями'' (<tt>exceptions</tt>) и не фатальны безоговорочно: позже вы научитесь перехватывать их в программах на Python. Большинство исключений, правда, как правило, не обрабатываются программами и приводят к сообщениям об ошибке, таким как следующие:

 

Traceback (most recent call last):

File "<stdin>", line 1, in ?

Traceback (most recent call last):

File "<stdin>", line 1, in ?

 

Последняя строка сообщения об ошибке описывает произошедшее. Исключения представлены различными типами и тип исключения выводится в качестве части сообщения: в примере это типы <code>ZeroDivisionError</code>, <code>NameError</code> и <code>TypeError</code>. Часть строки, описывающая тип исключения — это имя произошедшего встроенного исключения. Такое утверждение истинно для всех встроенных исключений, но не обязано быть истинным для исключений, определённых пользователем (однако, само соглашение — довольно полезное). Имена стандартных исключений это встроенные идентификаторы (не ключевые слова).

Существует возможность написать код, который будет перехватывать избранные исключения. Посмотрите на представленный пример, в котором пользователю предлагают вводить число до тех пор, пока оно не окажется корректным целым. Тем не менее пользователь может прервать программу (используя сочетание клавиш <tt>Control-C</tt> или какое-либо другое, поддерживаемое операционной системой); заметьте — о вызванном пользователем прерывании сигнализирует исключение <code>KeyboardInterrupt</code>.

 

... try:

... x = int(raw_input("Введите, пожалуйста, число: "))

... except ValueError:

... print "Ой! Это некорректное число. Попробуйте ещё раз..."

 

Оператор <code>try</code> работает следующим образом:

Оператор <code>try</code> может иметь более одного блока <code>except</code> — для описания обработчиков различных исключений. При этом будет выполнен максимум один обработчик. Обработчики следят<ref>''(Прим. перев.)'' ''Handle'' {{ref-en}} — ''зд.'', [ловить и] обрабатывать, управлять, контролировать, разбирать, следить, управляться с...</ref> только за теми исключениями, которые появляются в соответствующем блоке <code>try</code>, не за порождёнными в других обработчиках. Блок <code>except</code> может указывать несколько исключений в виде заключённого в скобки кортежа, например:

 

 

В последнем блоке <code>except</code> можно не указывать имени (имён) исключений, тогда он будет действовать как обработчик группы исключений. Используйте эту возможность с особой осторожностью, поскольку таким образом он может с лёгкостью перехватить и фактическую ошибку программиста! Также такой обработчик может быть использован для вывода сообщения об ошибке и порождения исключения заново (при этом позволяя обработать исключение коду, вызвавшему обработчик):

 

 

try:

except:

print "Неожиданная ошибка:", sys.exc_info()[0]

 

У оператора <code>try ''...'' except</code> есть необязательный ''блок <code>else<code>'', который, если присутствует, должен размещаться после всех блоков <code>except<code>. Его полезно использовать при наличии кода, который должен быть выполнен, если блок <code>try<code> не породил исключений. Например:

 

try:

f = open(arg, 'r')

else:

print arg, 'содержит', len(f.readlines()), 'строк'

 

Использование блока <code>else</code> предпочтительнее, чем добавление дополнительного кода к блоку <code>try</code>, поскольку исключает неожиданный перехват исключения, которое появилось не по причине выполнения кода, защищенного оператором <code>try ''...'' except</code>.

Использование <code>.args</code> в целом не одобряется. Вместо этого, рекомендуемый способ использования — это передача исключению единственного аргумента (который может быть кортежем, если требуется несколько аргументов) и его связь с атрибутом <code>message</code>. Таким образом можно создать экземпляр исключения перед его ''порождением'' (<tt>raising</tt>) и добавить любые атрибуты по желанию.

 

... raise Exception('spam', 'eggs')

... except Exception as inst:

('spam', 'eggs')

x = spam

 

Если у исключения есть аргумент, он выводится в качестве последней части («детальной») сообщения необработанных исключений.

Обработчики исключений перехватывают не только исключения, появившиеся прямо в блоке <code>try</code>, но также если они появились внутри функций, которые были в блоке <code>try</code> вызваны (даже неявно). Например:

 

... x = 1/0

...

... print 'Перехват ошибки времени исполнения:', detail

...

 

=== Порождение исключений ===

Оператор <code>raise</code> позволяет программисту принудительно породить исключение. Например:

 

Traceback (most recent call last):

File "<stdin>", line 1, in ?

 

Первый аргумент оператора <code>raise</code> именует исключение, которое нужно породить. Необязательный второй аргумент определяет аргумент исключения. Кроме того, код выше может быть записан в виде <code>raise NameError('ПриветТам')</code>. Обе формы работают корректно, однако второму варианту, похоже, отдаётся стилистическое предпочтение.

Если вам нужно определить, было ли порождено исключение, но при этом не перехватывать его — упрощённая форма оператора <code>raise</code> позволяет вам породить исключение заново:

 

... raise NameError, 'ПриветТам'

... except NameError:

Traceback (most recent call last):

File "<stdin>", line 2, in ?

 

=== Исключения, определённые пользователем ===

В программах можно определять свои собственные исключения — посредством создания нового класса исключения. В общем случае, исключения должны быть отнаследованы от класса <code>Exception</code>: явно или не явно. Например:

 

... def __init__(self, value):

... self.value = value

Traceback (most recent call last):

File "<stdin>", line 1, in ?

 

В этом примере конструктор по умолчанию <code>__init__()</code> класса <code>Exception</code> был перегружен. Новое поведение отличается лишь созданием нового атрибута <code>value</code> и заменяет поведение по умолчанию, при котором создаётся атрибут <code>args</code>.

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

 

"""Базовый класс для всех исключений в этом модуле."""

pass

self.previous = previous

self.next = next

 

Большинство исключений определяются именем, заканчивающимся на «<code>Error</code>», сходно именованию стандартных исключений.

У оператора <code>try</code> есть другой необязательный блок, предназначенный для операций подчистки, которые нужно выполнить независимо от условий:

 

... raise KeyboardInterrupt

... finally:

Traceback (most recent call last):

File "<stdin>", line 2, in ?

 

''Блок <code>finally</code>'' исполняется всегда, когда интерпретатор покидает оператор <code>try</code>, независимо — были исключения или нет. Если в блоке <code>try</code> появилось исключение, которое не было обработано в блоке <code>except</code> (или появилось в самих блоках <code>except</code> или <code>else</code>) — оно порождается заново после выполнения блока <code>finally</code>. Также блок <code>finally</code> исполняется «по пути наружу», если какой-либо другой блок оператора <code>try</code> был покинут за счёт одного из операторов: <code>break</code>, <code>continue</code> или <code>return</code>. Более сложный пример:

 

... try:

... result = x / y

File "<stdin>", line 1, in ?

File "<stdin>", line 3, in divide

 

Как видите, блок <code>finally</code> выполняется при любом событии. Ошибка <code>TypeError</code> порождается при делении двух строк и не перехватывается блоком <code>except</code>, и поэтому порождается заново сразу после выполнения блока <code>finally</code>.

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

 

 

Проблема этого кода в том, что он оставляет файл открытым на неопределённое время после выполнения данной части кода. В простых сценариях это не является проблемой, но может стать ей в больших приложениях. Оператор <code>with</code> позволяет использовать объекты (такие как, например, файлы) таким образом, чтобы вы всегда могли быть уверены в том, что ресурсы будут сразу и корректно очищены.

 

for line in f:

 

После выполнения оператора, файл ''<code>f</code>'' всегда закрывается, даже если при прочтении строк обнаружилась проблема. В документации к объектам, которые поддерживают предопределённые действия по подчистке, таким как файлы, эта их способность будет явно указана.

Простейшая форма определения класса выглядит так:

 

<выражение-1>

.

.

.

 

Определения классов, как и определения функций (операторы <code>def</code>) должны быть исполнены для того, чтобы иметь какой-либо эффект. (Вы можете, предположим, поместить определение класса в ветку оператора <code>if</code> или внутрь функции.)

''Ссылки на атрибуты'' (<tt>Attribute references</tt>) используют стандартный синтаксис, использующийся для всех ссылок на атрибуты в Python: <code>''объект''.''имя''</code>. Корректными именами атрибутов являются все имена, которые находились в пространстве имён класса при создании объекта-класса. Таким образом, если определение класса выглядело так:

 

"""Простой пример класса"""

i = 12345

def f(self):

 

то <code>MyClass.i</code> и <code>MyClass.f</code> являются корректными ссылками на атрибуты, возвращающими целое и ''объект-функцию'' (<tt>function object</tt>) соответственно. Атрибутам класса можно присваивать значение, так что вы можете изменить значение <code>MyClass.i</code> через присваивание. <code>__doc__</code> также является корректным атрибутом, возвращающим строку документации, принадлежащей классу: <code>"Простой пример класса"</code>.

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

 

 

создаёт новый экземпляр класса и присваивает этот объект локальной переменной <code>x</code>.

Операция ''создания экземпляра'' (<tt>instantiation</tt>, «вызов» объекта-класса) создаёт пустой объект. Большая часть классов предпочитает создавать экземпляры, настроенные с учётом определённого начального состояния. Для этого класс может определять специальный метод под именем <code>__init__()</code>, например так:

 

 

Когда в классе определён метод <code>__init__()</code>, при создании экземпляра автоматически вызывается <code>__init__()</code> нового, созданного, класса. Так, в этом примере, новый инициализированный экземпляр может быть получен за счёт выполнения кода:

 

 

Конечно же, для большей гибкости, метод <code>__init__()</code> может иметь аргументы. В этом случае аргументы, переданные оператору создания экземпляра класса, передаются методу <code>__init__()</code>. Например,

 

... def __init__(self, realpart, imagpart):

... self.r = realpart

>>> x = Complex(3.0, -4.5)

>>> x.r, x.i

 

==== Объекты-экземпляры ====

''Атрибуты-данные'' (<tt>data attributes</tt>) аналогичны «переменным экземпляров» в Smalltalk и «членам-данным» в C++. Атрибуты данных не нужно описывать — как и переменные, они начинают существование в момент первого присваивания. Например, если <code>x</code> — экземпляр созданного выше <code>MyClass</code>, следующий отрывок кода выведет значение <code>16</code>, не вызвав ошибок:

 

while x.counter < 10:

x.counter = x.counter * 2

print x.counter

 

Другой тип ссылок на атрибуты экземпляра — это ''метод'' (<tt>method</tt>). Метод — это функция, «принадлежащая» объекту. (В Python термин не уникален для экземпляров класса: другие объекты также могут иметь методы. Например, объекты списков имеют методы <code>append</code>, <code>insert</code>, <code>remove</code>, <code>sort</code> и т. д. Тем не менее, далее по обсуждению под термином «метод» мы будем понимать только методы объектов-экземпляров классов, пока отдельно не будет указано иное.)

Обычно, метод вызывают сразу после его связывания [с функцией]:

 

 

На примере <code>MyClass</code> такой код возвратит строку <code>'привет мир'<code>. Однако, не обязательно вызывать метод так уж сразу: <code>x.f</code> — это объект-метод, он может быть отложен и вызван когда-либо позже. Например:

 

while True:

 

будет печатать <code>'привет мир'<code> до конца времён.

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

 

def f1(self, x, y):

return min(x, x+y)

def g(self):

return 'привет мир'

 

Теперь <code>f</code>, <code>g</code> и <code>h</code> — все являются атрибутами класса <code>C</code>, ссылающимися на объекты-функции, и, следовательно, все они являются методами экземпляров <code>C</code> — <code>h</code> становится полностью эквивалентен <code>g</code>. Заметьте, что такая практика обычно служит лишь тому, чтобы запутать читателя программы.

Методы могут вызывать другие методы за счёт использования атрибутов-методов аргумента <code>self</code>:

 

def __init__(self):

self.data = []

def addtwice(self, x):

self.add(x)

 

Методы могут ссылаться на глобальные имена таким же образом, как и обычные функции. Глобальная область видимости, связанная с методом, — это модуль, содержащий определение класса. (Сам класс никогда не используется в качестве глобальной области видимости!) В то время, как одни редко находят причины для использования глобальных данных в методах, существует множество вполне законных способов использования глобальной области видимости: для примера, функции и модули, импортированные в глобальную область видимости, могут использоваться методами так же хорошо, как функциями и классами, в них определёнными. Обычно класс, содержащий метод, сам определён в этой глобальной области видимости, и в следующем разделе мы найдём пару хороших причин, почему метод может иметь желание ссылаться на собственный класс!

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

 

<выражение-1>

.

.

.

 

Имя ''<code>ИмяБазовогоКласса</code>'' должно быть определено в области видимости, содержащей определение производного класса. Вместо имени базового класса также позволяется использовать другие выражения. Это может быть полезно, например, когда базовый класс определён в другом модуле:

 

 

Использование определения производного класса проходит таким же образом, как и базового. Базовый класс полностью сохраняется по завершению конструирования объекта-класса. Такой метод используется для разрешения ссылок на атрибуты<ref>''(Прим. перев.)'' ''Resolving attribute references'' {{ref-en}} — разрешение (поиск значений) ссылок на атрибуты.</ref>: если запрошенный атрибут не был найден в самом классе, поиск продолжается в базовом классе. Правило применяется рекурсивно, если базовый класс сам является производным от некоторого другого класса.

Python также поддерживает ограниченную форму ''множественного наследования'' (<tt>multiple inheritance</tt>). Определение класса с несколькими базовыми классами будет выглядеть так:

 

<выражение-1>

.

.

.

 

Для классов в старом стиле единственное правило — это правило «глубина-сначала», затем «слева-направо». Таким образом, если атрибут не найден в ''<code>ИмяПроизводногоКласса</code>'', его поиск выполняется в ''<code>Базовом1</code>'', затем (рекурсивно) в базовых классах ''<code>Базового1</code>'' и только если он там не найден, поиск перейдёт в ''<code>Базовый2</code>'' и так далее.

=== Всякая всячина ===

 

pass

 

джон.имя = 'Джон До'

джон.отдел = 'компьютерная лаборатория'

 

pass

 

john.name = 'John Doe'

john.dept = 'computer lab'

 

Отрезок кода на Python, требующий на входе определённого абстрактного типа данных, часто может быть передан классу, который эмулирует вместо него методы этого типа данных. Например, если у вас есть функция, форматирующая некоторые данные из объекта файла, то вы можете определить методы класса <code>read()</code> и <code>readline()</code>, которые вместо этого получат данные из строкового буфера и передать им его в качестве аргумента.

Вот две новых (синтаксически) корректных формы оператора <code>raise</code>:

 

 

 

В первой форме, ''<code>экземпляр</code>'' должен быть экземпляром ''<code>Класса</code>'', или класса, производного от него. Вторая форма является краткой записью следующего кода:

 

 

Класс в блоке <code>except</code> является сопоставимым с исключением, если является этим же классом или самим по себе базовым классом (никаких других способов обхода — описанный в блоке <code>except</code> производный класс не сопоставим с базовым). Например, следующий код выведет B, C, D в этом порядке:

 

pass

class C(B):

print "C"

except B:

 

Обратите внимание, что если бы блоки <code>except</code> шли в обратном порядке (начиная с "<code>except B</code>"), код вывел бы B, B, B — сработал бы первый совпадающий блок <code>except</code>.

К этому моменту вы, возможно, заметили, что используя оператор <code>for</code> можно пройти циклом по большинству объектов-контейнеров:

 

print element

for element in (1, 2, 3):

print char

for line in open("myfile.txt"):

 

Такой стиль доступа к элементам прост, лаконичен и удобен. Использованием ''итераторов'' (<tt>iterators</tt>) пропитан язык Python, и это его выделяет среди других. Негласно, оператор <code>for</code> вызывает метод <code>iter()</code> объекта-контейнера. Функция возвращает объект итератора, который определяет метод <code>next()</code>, который по очереди получает доступ к элементам в контейнере, по одному за раз. Если больше не остаётся элементов, метод <code>next()</code> порождает исключение <code>StopIteration</code>, которое сообщает оператору <code>for</code> о необходимости завершения прохода. Следующий пример показывает как это всё работает:

 

>>> it = iter(s)

>>> it

File "<stdin>", line 1, in ?

it.next()

 

Ознакомившись с механизмами, скрытыми за протоколом итераторов, легко добавить возможность итерирования к вашим классам. Определите метод <code>__iter__()</code>, который возвращает объект с методом <code>next()</code>. Если класс определяет и метод <code>next()</code>, тогда <code>__iter__()</code> может просто возвращать <code>self</code>.

 

"Итератор для прохождения циклом по последовательности в обратном направлении"

def __init__(self, data):

а

п

 

=== Генераторы ===

''Генераторы'' (<tt>generators</tt>) — простой и мощный инструмент для создания итераторов. Они записываются как обычная функция, но где бы им ни было необходимо вернуть данные, используется оператор <code>yield</code>. Каждый раз, при вызове <code>next()</code>, генератор возвращается к месту, где он был оставлен (он запоминает все значения данных, а также какой оператор был выполнен последним). Пример показывает, что создание генераторов может быть тривиально простым:

 

for index in range(len(data)-1, -1, -1):

yield data[index]

л

о

 

Всё, что можно сделать с использованием генераторов, может быть сделано с использованием основанных на итераторах классов, как описано в предыдущем разделе. Благодаря автоматическому созданию методов <code>__iter__()</code> и <code>next()</code> генераторы так компактны.

['ф', 'ь', 'л', 'о', 'г']</code></ref>:

 

285

 

>>> data = 'golf'

>>> list(data[i] for i in range(len(data)-1,-1,-1))