Учебник Python 2.5: различия между версиями
Содержимое удалено Содержимое добавлено
-> 2.6 |
|||
Строка 2:
= Учебник Python 2.
{|class="standard"
|''Автор языка''
|Гвидо ван Россум (Guido van Rossum)
|-
Строка 14:
|[mailto:docs@python.org docs@python.org]
|-
|''
|http://docs.python.org/tutorial/index.html
|-
|''Редактор, Автор''
|Фред Л. Дрейк мл. (Fred L. Drake, Jr. ) [http://docs.python.org/about.html и другие]
|-
|''Релиз''
|2.
|-
|''Дата написания''
|22 декабря 2008
|}
Строка 27 ⟶ 30 :
__TOC__
===
Python — мощный и простой для изучения язык программирования. В нём предоставлены проработанные высокоуровневые структуры данных и простой, но эффективный подход к объектно-ориентированному программированию. Сочетание изящного синтаксиса и динамического типизирования, совмещённых с интерпретируемой сущностью, делает Python идеальным языком для написания сценариев и ускоренной разработки приложений в различных сферах и на большинстве платформ.
Строка 49 ⟶ 41 :
Этот учебник неформально представляет читателю основные концепции и возможности языка и системы Python. Полезно держать интерпретатор Python под рукой для практического опыта, но при этом все примеры самодостаточны, так что учебник вполне возможно читать вне сети.
Описание стандартных объектов и модулей вы можете найти в [[Справочник по библиотеке Python 2.
Этот учебник не претендует на звание всеобъемлющего и не описывает каждую особенность Python и даже не описывает ''всех'' его часто
Кроме того, не будет лишним полистать [[Глоссарий Python 2.6|Глоссарий]].
== Разжигая ваш аппетит ==
Строка 61 ⟶ 55 :
Python — язык, который вам подойдёт.
Вы можете написать шелл-скрипт для Unix или использовать пакетные файлы Windows для некоторых из этих задач, но шелл-скрипты хороши лишь для перемещения файлов и замены текстовых данных — они вряд ли подойдут для написания приложений, снабженных графическим интерфейсом, или игр. Вы можете написать программу на C/C++/Java, но разработка может занять довольно много времени — даже на то, чтобы получить первый рабочий набросок, его требуется немало. Python — проще в использовании, доступен на операционных системах Windows,
Даже учитывая лёгкость использования, Python — полноценный язык программирования, предлагающий много больше возможностей для структурирования и поддержки крупных программ, чем могут позволить себе шелл-скрипты или пакетные файлы. С другой стороны, Python также предоставляет намного больше информации для отладки ошибок чем C и, будучи ''сверх-высокоуровневым-языком'', имеет встроенные высокоуровневые типы данных — такие, как гибкие массивы и словари. Благодаря наличию обобщённых типов данных Python применим для более широкого круга приложений чем Awk или даже Perl, и при этом очень многие вещи остаются в языке Python как минимум настолько же простыми, насколько просты в этих языках.
Строка 77 ⟶ 71 :
Python ''расширяем'': если вы знаете, как программировать на C, то вам легко будет добавить к интерпретатору новую встроенную функцию или модуль, выполнить критические операции на максимальной скорости или связать программы на Python с библиотеками, которые могут быть доступны только в бинарной форме (например, зависящие от поставщика графические библиотеки). Если вы действительно увлечены — вы можете привязать интерпретатор Python к приложению, написанному на C — чтобы использовать его как язык расширений или командный язык этого приложения.
Кстати, язык назван в честь шоу «Летающий цирк Монти Пайтона» на BBC и не имеет ничего общего с
Теперь, когда ваш интерес к Python полностью пробужден, вам наверняка захочется изучить его более детально. В связи с тем, что лучший способ выучить язык — использовать его — автор приглашает вас использовать интерпретатор Python в процессе чтения.
Строка 89 ⟶ 83 :
=== Запуск интерпретатора ===
Интерпретатор Python после установки располагается, обычно, по пути <tt>/usr/local/bin/python<tt> —
<code>python</code>
прямо из шелла. Поскольку выбор каталога, в котором будет обитать интерпретатор, осуществляется при его установке, то возможны и другие варианты — посоветуйтесь с вашим Python-гуру или системным администратором. (Например, путь <tt>/usr/local/python</tt> тоже популярен в качестве альтернативного расположения.)
На машинах с ОС Windows, инсталляция Python обычно осуществляется в каталог <tt>C:\
<code>set path=%path%;C:\
При наборе символа конца файла (<tt>Ctrl-D</tt> в Unix, <tt>Ctrl-Z</tt> в Windows) в ответ на основное приглашение интерпретатора, последний будет вынужден закончить работу с нулевым статусом выхода. Если это не сработает — вы можете выйти из интерпретатора путём ввода следующих команд:
<source lang="python">import sys; sys.exit()</source>
Особенности редактирования строк в интерпретаторе не оказываются, обычно, чересчур сложными. Те, кто установил интерпретатор на машину Unix, потенциально имеют поддержку библиотеки <tt>GNU readline</tt>, обеспечивающей усовершенствованное интерактивное редактирование и сохранение истории. Самый быстрый, наверное, способ проверить, поддерживается ли расширенное редактирование командной строки, заключается в нажатии <tt>Ctrl-P</tt> в ответ на первое полученное приглашение Python. Если вы услышите сигнал — значит вам доступно редактирование командной строки — тогда обратитесь к [[
Интерпретатор ведёт себя сходно шеллу Unix: если он вызван, когда ''стандартный ввод'' привязан к устройству <tt>tty</tt> — он считывает и выполняет команды в режиме диалога; будучи вызванным с именем файла в качестве аргумента или с файлом, назначенным на ''стандартный ввод'' — он читает и выполняет сценарий из этого файла.
Другой способ запустить интерпретатор — директива
Некоторые модули Python оказываются полезными при использовании их в качестве сценариев. Они могут быть запущены в этом виде командой
Обратите внимание на различие между командами <tt>python file</tt> и <tt>python <file</tt>. В последнем случае запросы на ввод из программы, такие как вызовы <code>input()</code> и <code>raw_input()</code>, удовлетворяются из самого файла. Поскольку файл уже был прочитан до конца ещё до начала выполнения программы — символ конца файла будет обнаружен программой незамедлительно. В большинстве случаев (это, чаще всего, и есть те ситуации, которых вы ожидали) вызовы удовлетворяются независимо от того, файл или устройство привязаны к стандартному вводу интерпретатора Python.
При использовании файла сценария иногда полезно иметь возможность запустить сценарий и затем войти в интерактивный режим. Это может быть сделано через указание параметра '''-i''' перед именем сценария. (Этот способ не сработает, если сценарий считывается со стандартного ввода — по той самой причине, которая описана в предыдущем абзаце).
Строка 121 ⟶ 115 :
==== Интерактивный режим ====
Если команды считываются с <tt>tty</tt> — говорят, что интерпретатор находится в ''интерактивном режиме'' (режиме диалога). В этом режиме он приглашает к вводу следующей команды, отобразив ''основное приглашение''<ref>''(Прим. перев.)'' <tt>primary prompt</tt> — ''зд.'', основное приглашение: приглашение к вводу команды или нескольких команд (сценария);</ref> (обычно это три знака «больше-чем» —
<source lang="python">python
Python
Type "help", "copyright", "credits" or "license" for more information.
>>>
''Продолжающие строки'' используются в случаях, когда необходимо ввести многострочную конструкцию. Взгляните, например, на следующий оператор <code>if</code><ref>''(Прим. перев.)'' Здесь и далее тексты некоторых исходных кодов также будут переведены в примечаниях (вместе с ключевыми словами, поэтому их нельзя будет запустить в интерпретаторе), чтобы показать их смысл или задумку, которые не всегда очевидны без перевода (если он вам нужен :) ):<br/><br/>
Строка 133 ⟶ 127 :
<span style="color: #aaa">...</span> '''вывести''' "Будьте осторожны — не упадите!"<br/>
<span style="color: #aaa">...</span> <br/>
<span style="color: #030">Будьте осторожны — не упадите!</span></code><br/></ref>:
<source lang="python">>>> the_world_is_flat = 1
>>> if the_world_is_flat:
... print "Be careful not to fall off!"
...
Be careful not to fall off!</source>
Строка 153 ⟶ 147 :
На Unix-системах семейства BSD сценарии на Python могут быть сделаны исполняемыми, также как и шелл-сценарии, путём добавления следующей строки
<code>#! /usr/bin/env
(предполагается, что интерпретатор может быть найден по одному из путей, указанных в пользовательской переменной <tt>PATH</tt>) в начало сценария и установки файла в исполняемый режим. Символы
Исполняемый режим (или разрешение на исполнение) может быть установлен сценарию использованием команды '''chmod''':
<code>$ chmod +x myscript.py</code>
У систем с операционной системой Windows нет такого понятия, как исполняемый режим. Установщик Python автоматически связывает файлы <tt>.py</tt> с файлом <tt>python.exe</tt>, таким образом двойной клик на файле Python запустит его в виде сценария. Расширение может быть и <tt>.pyw</tt> в случае, если окно консоли (которое, обычно, отображается) при запуске скрипта подавляется.
==== Кодировка исходных файлов ====
Строка 167 ⟶ 163 :
<code># -*- coding: encoding -*-</code>
Если используется это описание — все символы в этом файле будут разпознаваться как имеющие соответствующую кодировку и появится возможность употреблять символы Unicode в выбранной кодировке. Список возможных кодировок представлен в [[Справочник по библиотеке Python 2.
Например, для написания таких символов в кодировке Unicode, как, например, знак валюты Евро — может быть использована кодировка <tt>ISO-8859-15</tt>, где знак Евро имеет порядковый номер 164. Этот сценарий выведет значение 8346 (место в таблице Unicode, соответствующее символу Евро) и затем выполнит выход:
Строка 184 ⟶ 180 :
Если вы используете Python интерактивно — часто бывает удобным выполнить некоторые стандартные команды перед запуском интерпретатора. Вы можете сделать это, установив переменную окружения с именем <tt>PYTHONSTARTUP</tt> равной имени файла, содержащего ваши команды запуска. Способ схож с использованием файла <tt>.profile</tt> в Unix-шелле.
Этот файл читается только в интерактивных сессиях, но не в случае считывания команд из сценария, и не в случае, если <tt>/dev/tty</tt> назначен как независимый источник комманд (который в других случаях ведет себя сходно интерактивным сессиям). Файл исполняется в том же пространстве имён, что и исполняемые команды - поэтому объекты и импортированные модули, которые он определяет могут свободно использоваться в интерактивной сессии. Также в этом файле вы можете изменить приглашения: <code>sys.ps1</code> и <code>sys.ps2</code>.
Если вы хотите прочитать дополнительный файл запуска из текущего каталога — вы можете использовать код вроде:
Строка 199 ⟶ 195 :
== Неформальное введение в Python ==
В приведенных далее примерах, ввод и вывод различаются присутствием и отсутствием приглашений соответственно (приглашениями являются
Большинство примеров в этом руководстве — даже те, которые вводятся в интерактивном режиме — содержат комментарии. Комментарии в Python начинаются с символа решетки
Несколько примеров:
Строка 212 ⟶ 208 :
=== Использование Python в качестве калькулятора ===
Давайте опробуем несколько простых команд Python. Запустите интерпретатор и дождитесь появления основного приглашения —
==== Числа ====
Строка 233 ⟶ 229 :
-3</source>
Знак равенства (
<source lang="python">>>> width = 20
Строка 250 ⟶ 246 :
0</source>
Переменные должны быть ''определены'' (<tt>defined</tt>) (должны иметь присвоенное значение) перед использованием, иначе будет сгенерирована ошибка:
>>> # попытка получить доступ к неопределённой переменной
... n
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
Присутствует полная поддержка операций с плавающей точкой; операторы с операндами смешанного типа конвертируют целочисленный операнд в число с плавающей точкой:
<source lang="python">>>> 3 * 3.75 / 1.5
Строка 257 ⟶ 261 :
3.5</source>
Также поддерживаются комплексные числа; к мнимым частям добавляется суффикс
<source lang="python">>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0, 1)
(-1+0j)
>>> 3+1j*3
Строка 278 ⟶ 282 :
0.5</source>
Функции конвертации (приведения) к вещественным и целым числам (<code>float()</code>, <code>int()</code> и <code>long()</code>) не работают с комплексными числами —
<source lang="python">>>> a=3.0+4.0j
Строка 344 ⟶ 348 :
Note that whitespace at the beginning of the line is significant.</pre>
Если мы объявим строковой литерал
<source lang="python">hello = r"This is a rather long string containing\n\
Строка 359 ⟶ 363 :
<source lang="python">print """
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
Строка 366 ⟶ 370 :
выводит в результате следующее:
<
-h Display this usage message
-H hostname Hostname to connect to</
Интерпретатор выводит результаты операций над строками тем же способом, каким они были введены: в кавычках, а также в кавычках и с другими забавными символами, экранированными обратными слэшами — для того, чтобы показать точное значение. Строка заключается в двойные кавычки если строка содержит одинарную кавычку и ни одной двойной, иначе она заключается в одинарные кавычки. (Оператор <code>print</code>, описанный позже, может использоваться для вывода строк без кавычек или экранирования.)
Строка 380 ⟶ 384 :
'<HelpAHelpAHelpAHelpAHelpA>'</source>
Два строковых литерала, расположенные друг за другом, автоматически конкатенируются; первая строка в предыдущем примере также могла быть записана как
<source lang="python">>>> 'str' 'ing' # <- Так — верно
Строка 392 ⟶ 396 :
SyntaxError: invalid syntax</source>
Строки могут быть проиндексированы; также как и в C, первый символ строки имеет индекс <tt>0</tt>. Отсутствует отдельный тип для символов; символ является строкой с единичной длиной.
<source lang="python">>>> word[4]
Строка 467 ⟶ 471 :
IndexError: string index out of range</source>
<pre> +---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1</pre>
Строка 486 ⟶ 490 :
{{Смотрите также|
;[[Справочник по библиотеке Python 2.
;[[Справочник по библиотеке Python 2.
;[[Справочник по библиотеке Python 2.
;[[Справочник по библиотеке Python 2.6#Операции форматирования строк|Операции форматирования строк]]:Операции форматирования, вызывающиеся тогда, когда обычные строки или строки в Unicode оказываются левым операндом относительно оператора <code>%</code>, более детально рассмотрены здесь. }}
Строка 601 ⟶ 606 :
Встроенная функция <code>len()</code> также применима к спискам:
<source lang="python">>>>
>>> len(a)
4</source>
Вы можете встраивать списки (создавать списки, содержащие другие списки), например так:
<source lang="python">>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2</source>
Вы можете добавить что-нибудь в конец списка.
<source lang="python">>>> q = [2, 3]
Строка 614 ⟶ 631 :
>>> p[1][0]
2
>>> p[1].append('xtra') # Смотрите раздел
>>> p
[1, [2, 3, 'xtra'], 4]
Строка 661 ⟶ 678 :
:Обратите внимание на то, что интерпретатор вставляет новую строку перед тем как выводит следующее приглашение, если последняя строка не была завершена.
== Больше средств для
Помимо описанного выше оператора <code>while</code>, в Python доступны привычные операторы управления из других языков, но с некоторыми различиями.
Строка 670 ⟶ 687 :
<source lang="python">>>> x = int(raw_input("Введите пожалуйста целое число: "))
Введите пожалуйста целое число: 42
>>> if x < 0:
... x = 0
Строка 679 ⟶ 697 :
... else:
... print 'Больше'
...
Больше</source>
Блоков <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>, которые можно встретить в других языках.
Строка 691 ⟶ 710 :
>>> for x in a:
... print x, len(x)
...
cat 3
window 6
Строка 700 ⟶ 719 :
<source lang="python">>>> for x in a[:]: # создать срез-копию всего списка
... if len(x) > 6: a.insert(0, x)
...
>>> a
['defenestrate', 'cat', 'window', 'defenestrate']</source>
Строка 731 ⟶ 750 :
3 little
4 lamb</source>
Однако, в большинстве таких случаев, удобно использовать функцию <code>enumerate()</code>, обратитесь к [[Учебник Python 2.6#Техника прохода циклом|Техникам проходов циклом]].
=== Операторы <code>break</code> и <code>continue</code>, а также условие <code>else</code> в циклах ===
Строка 743 ⟶ 764 :
... for x in range(2, n):
... if n % x == 0:
... print
... break
... else:
... # циклу не удалось найти множитель
... print
...
2 - простое число
3 - простое число
Строка 763 ⟶ 784 :
<source lang="python">>>> while True:
... pass # Ожидание прерывания c клавиатуры (Ctrl+C) в режиме занятости
...</source>
Этот оператор часто используется для создания минималистичных классов, к примеру ''исключений'' (<tt>exceptions<tt>), или для игнорирования нежелательных исключений:
<source lang="python">>>> class ParserError(Exception):
... pass
...
>>> try:
... import audioop
... except ImportError:
... pass
...</source>
Другой вариант: <code>pass</code> может применяться в качестве заглушки для тела функции или условия при создании нового кода, позволяя вам сохранить абстрактный взгяд на вещи. С другой стороны, оператор <code>pass</code> игнорируется без каких-либо сигналов и лучшим выбором было бы породить исключение <code>NotImplementedError</code>:
<source lang="python">>>> def initlog(*args):
... raise NotImplementedError # Открыть файл для логгинга, если он ещё не открыт
... if not logfp:
... raise NotImplementedError # Настроить заглушку для логгинга
... raise NotImplementedError('Обработчик инициализации лога вызовов')
...</source>
Если бы здесь использовались операторы <code>pass</code>, а позже вы бы запускали тесты, они могли бы упасть без указания причины. Использование <code>NotImplementedError<code> принуждает этот код породить исключение, сообщая вам кокретное место, где присутствует незавершённый код. Обратите внимание на два способа порождения исключений. Первый способ, без сообщения, но сопровождаемый комментарием, позволяет вам оставить комментарий когда вы будете подменять выброс исключения рабочим кодом, который, в свою очередь, в идеале, будет хорошим описанием блока кода, для которого исключение предназначалось заглушкой. Однако, передача сообщения вместе с исключением, как в третьем примере, обуславливает более насыщенный информацией вывод при отслеживании ошибки.
=== Определение функций ===
Строка 776 ⟶ 819 :
... print b,
... a, b = b, a+b
...
>>> # Теперь вызовем определенную нами функцию:
... fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597</source>
Зарезервированное слово <code>def</code> предваряет ''определение'' функции. За ним должны следовать имя функции и заключённый в скобки список формальных параметров. Выражения, формирующие тело функции, начинаются со следующей строки и должны иметь отступ
Первым выражением в теле функции может быть строковой литерал — этот литерал является строкой документации функции, или ''док-строкой'' (<tt>docstring</tt>). (Больше информации о ''док-строках'' вы найдёте в разделе [[Учебник Python 2.6#Строки документации|Строки документации]]) Существуют инструменты, которые используют ''док-строки'' для того, чтобы сгенерировать печатную или онлайн-документацию или чтобы позволить пользователю перемещаться по коду интерактивно; добавление строк документации в ваш код - это хорошая практика,
''Исполнение'' функции приводит к созданию новой таблицы символов<ref>''(Прим. перев.)'' Здесь слово «символ» используется не в привычном значении — под ''символом'' подразумевается нечто лингвистическое, описывающее какую-либо сущность (близко к значению ''символизировать''), в данном случае: имя переменной — саму переменную.</ref>, использующейся для хранения локальных переменных функции. Если быть более точными, все присваивания переменных в функции сохраняют значение в локальной таблице символов; при обнаружении ссылки на переменную, в первую очередь просматривается локальная таблица символов, затем
Фактические параметры (аргументы) при вызове функции помещаются в локальную таблицу символов вызванной функции; в результате аргументы передаются через ''вызов по значению'' (<tt>call by value</tt>) (где значение - это всегда ''ссылка'' (<tt>reference</tt>) на объект, а не значение его самого)<ref>На самом деле, лучшим определением был бы ''вызов по ссылке на объект'' (<tt>call by object reference</tt>), так как при передаче изменяемого объекта, вызывающему будут видны все изменения, которые производит над объектом вызываемый (вставка элементов в список)</ref>. Если одна функция вызывает другую — то для этого вызова создается новая локальная таблица символов.
Строка 797 ⟶ 840 :
1 1 2 3 5 8 13 21 34 55 89</source>
<source lang="python">>>>
>>> print fib(0)
None</source>
Строка 812 ⟶ 856 :
... a, b = b, a+b
... return result
...
>>> f100 = fib2(100) # вызываем
>>> f100 # выводим результат
Строка 819 ⟶ 863 :
Этот пример, как уже привычно, демонстрирует некоторые новые возможности Python:
* Оператор <code>return</code> завершает выполнение функции, возвращая некоторое значение. Оператор <code>return</code> без аргумента возвращает <code>None</code>. Достижение конца
* Выражение <code>result.append(b)</code> вызывает метод объекта списка <code>result</code>. Метод — это функция, которая "принадлежит" (<tt>belongs</tt>) объекту и указывается через выражение <code>obj.methodname</code>, где <code>obj</code> — некоторый объект (может быть выражением), а <code>methodname</code> — имя метода, который определён типом объекта. Различные типы определяют различные методы. Методы разных типов могут иметь одинаковое имя, не оказываясь причинами неопределённостей. (Возможно определять ваши собственные типы объектов и методы используя классы, что будет рассмотрено позже в этом учебнике.) Метод <code>append()</code>, показанный в примере, определён для объектов типа список — он добавляет в конец списка новый элемент. В данном примере это действие эквивалентно выражению
=== Подробнее об определении функций ===
Строка 939 ⟶ 983 :
TypeError: function() got multiple values for keyword argument 'a'</source>
Если в определении функции присутствует завершающий параметр в виде ''**имя'' — он принимает словарь (подробнее в разделе [[Справочник по библиотеке Python 2.
<br/><br/>
<code style="background-color: inherit !important;">'''опред''' лавка_сыров(сорт, *аргументы, **именованные):<br/>
'''вывести''' "-- Есть ли у вас ", сорт,
'''вывести''' "-- Простите, весь ", сорт, " у нас закончился."<br/>
'''для''' аргумент '''среди''' аргументы: '''вывести''' аргумент<br/>
'''вывести'''
имена = именованные.''ключи''()<br/>
имена.''сортировка''()<br/>
'''для''' имя '''среди''' имена: '''вывести''' имя ,
(''Из [http://www.ibras.dk/montypython/episode33.htm#7 скетча Монти Пайтона]'')</ref>:
<source lang="python">def cheeseshop(kind, *arguments, **keywords):
print "-- Do you have any", kind,
print "-- I'm sorry, we're all out of", kind
for arg in arguments: print arg
print
keys = keywords.keys()
keys.sort()
for kw in keys: print kw,
то её можно будет вызвать так<ref>''(Прим. перев.):''
<br/><br/>
<code style="background-color: inherit !important;">лавка_сыров(
"Это действительно очень, ОЧЕНЬ расстраивает, сэр.",<br/>
скетч=
<source lang="python">cheeseshop(
"It's really very, VERY runny, sir.",
sketch=
и она, конечно же, выведет<ref>''(Прим. перев.):''
Строка 998 ⟶ 1042 :
==== Списки аргументов произвольной длины ====
Наконец, наиболее редко используется возможность указания того, что функция может быть вызвана с произвольным числом аргументов. При этом сами аргументы будут обёрнуты в кортеж (см.
<source lang="python">def
file.write(
==== Распаковка списков аргументов ====
Строка 1036 ⟶ 1080 :
==== Модель <tt>lambda</tt> ====
По частым просьбам, в Python были добавлены несколько возможностей, которые были привычны для функциональных языков программирования, таких как Lisp. Используя зарезервированное слово <code>lambda</code> вы можете создать небольшую анонимную функцию. Здесь представлена функция, которая возвращает сумму двух её аргументов:
<source lang="python">>>> def make_incrementor(n):
Строка 1049 ⟶ 1093 :
==== Строки документации ====
Перечислим некоторые существующие соглашения по содержимому строк документации и их форматированию.
По поводу форматирования строк документации и их содержимого постоянно появляются всё новые соглашения.
Первая строка всегда должна быть сжатой, лаконичной сводкой о назначении объекта. Для краткости, в ней не обязательно присутствие имени типа или объекта, поскольку они доступны другими способами (исключая случай, когда имя функции оказывается глаголом, описывающим суть операции). Эта строка должна начинаться с прописной буквы и оканчиваться точкой.
Строка 1061 ⟶ 1107 :
<source lang="python">>>> def my_function():
... """Не делаем ничего, но документируем.
...
... Нет, правда, эта функция ничего не делает.
... """
... pass
...
>>> print my_function.__doc__
Не делаем ничего, но документируем.
Нет, правда, эта функция ничего не делает.</source>
=== Интермеццо: Стиль написания кода ===
Теперь, когда вам предстоит писать более объёмные и сложные блоки кода на Python, настало время поговорить о ''стиле написания кода'' (<tt> coding style</tt>). Код на большинстве языков программирования может быть записан (или, точнее говоря, ''отформатирован'' (<tt> formatted</tt>)) различными способами; некоторые из них более читабельны, некоторые — нет. Стремление к написанию лёгкого для прочтения другими кода всегда считалось хорошим тоном, и выбор правильного стиля для кода крайне ему способствует.
В случае языка Python, в качестве руководства по стилю было создано предложение [http://www.python.org/dev/peps/pep-0008 PEP8]<ref>''(Прим. перев.)'' — <tt>[[w:Python_Enhancement_Proposal|PEP]]</tt> (</tt>''Python Enchancement Proprosal</tt>'', Предложение по улучшению Python) — документ, имеющий стандартизированный формат и описывающий какую-либо из возможностей или какое-либо из свойств языка Python, планируемые для разработки в будущем (или уже разработанную). В завершённом варианте используется как основное соглашение по данной функциональности. (см. также [[w:Python#Дальнейшая разработка|пояснение на странице языка Python]])</ref>, которого придерживаются создатели большинства проектов. В нём учреждается чрезвычайно читабельный и приятный для глаза стиль написания кода. В некоторый момент с ним должен ознакомиться каждый разработчик на Python. Приведём здесь избранные, наиболее важные, пункты:
* Используйте отступ в 4 пробела, не используйте табуляцию
:4 пробела легко опознаются и в случае небольших отступов (хватает места для глубоких вложений) и в случае больших отступов (приятнее читается). Табуляция вносит путаницу и лучше от неё воздержаться.
* Разделяйте строки так, чтобы их длина не превышала 79-и символов
:Это поможет пользователям с небольшими экранами, а пользователям с большими экранами позволит уложить несколько файлов с исходным кодом рядом.
* Используйте пустые строки для отделения функций, классов, и крупных блоков внутри функций.
* При возможности располагайте комментарий на отдельной строке.
* Используйте строки документации (''док-строки'')
* Применяйте пробелы вокруг операторов и после запятых, но не добавляйте их в конструкции со скобками: <code>a = f(1, 2) + g(3, 4)</code>
* Называйте ваши классы и функции единоообразно; соглашение следующее: используйте <code>CamelCase</code><ref>''(Прим. перев.)'' <tt>CamelCase</tt> (''ВерблюжийСтиль'') — стиль именования идентификаторов, при котором все слова, записанные строчными буквами, объединяются в одно и первая буква каждого слова выделяется заглавной буквой — такая запись напоминает верблюжьи горбы, в связи с чем и названа.</ref> для именования классов и <code>нижний_регистр_с_подчёркиваниями</tt><ref>''(Прим. перев.)'' Пусть данный пример по вине переводчика и использует русские буквы, соглашение корректно настаивает на использовании латиницы для именования идентификаторов, см. следующий пункт соглашения</ref> для функций и методов. (обращайтесь к разделу [[Учебник Python 2.6#Первый взгляд на классы|Первый взгляд на классы]] за дополнительной информации о классах и методах)
* Не используйте в вашем коде изощрённых кодировок<ref>''(Прим. перев.)'' В строковых литералах (не комментариях) это, конечно же, позволено</ref>, если он расчитан на использование в интернациональной среде. Стандартный набор ASCII всегда работает на ура<ref>''(Прим. перев.)'' Не кодировка, а именно набор символов — латиница, пунктуация и несколько служебных символов. Кодировка по умолчанию для файлов с иходными кодами, начиная с Python 3.0, всегда UTF-8 — дабы существовала возможность использовать национальные символы в строковых литералах и, в редких случаях — комментариях.</ref>.
== Структуры данных ==
Строка 1079 ⟶ 1142 :
У типа данных список также имеются не описанные ранее методы. Ниже описаны все методы объектов списка:
;<code>list.append(''x'')</code>:Добавить элемент к концу списка; эквивалент <code>a[len(a):] = [x]</code>
;<code>list.extend(''L'')</code>:Расширить список за счёт добавления всех элементов переданного списка; эквивалентно <code>a[len(a):] = L</code>.
;<code>list.insert(''i'', ''x'')</code>:Вставить элемент в указанную позицию. Первый аргумент — это индекс того элемента, перед которым требуется выполнить операцию вставки, поэтому вызов <code>a.insert(0, x)</code> вставляет элемент в начало списка, а <code>a.insert(len(a), x)</code> эквивалентно <code>a.append(x)</code>.
;<code>list.remove(''x'')</code>:Удалить первый найденный элемент из списка, значение которого — <code>x</code>. Если элемент не найден, генерируется ошибка.
;<code>list.pop([''i''])</code>:Удалить элемент, находящийся на указанной позиции в списке, и возвратить его. Если индекс не указан, <code>a.pop()</code> удаляет и возвращает последний элемент списка. (Квадратные скобки вокруг <code>i</code> в сигнатуре метода означают, что параметр необязателен, а не необходимость набора квадратных скобок в этой позиции. Вы часто будете встречать такую нотацию в [[Справочник по библиотеке Python 2.
;<code>list.index(''x'')</code>:Вернуть индекс первого найденного в списке элемента, значение которого равно <code>x</code>. Если элемент не найден, генерируется ошибка.
;<code>list.count(''x'')</code>:Вернуть количество раз, которое <code>x</code> встречается в списке.
;<code>list.sort()</code>:Сортировать элементы списка, на месте.
;<code>list.reverse()</code>:Обратить порядок элементов списка, на месте.
Пример, использующий большинство методов списка:
Строка 1156 ⟶ 1219 :
Есть три встроенных функции, которые очень удобно использовать в сочетании со списками: <code>filter()</code>, <code>map()</code> и <code>reduce()</code>.
<source lang="python">>>> def f(x): return x % 2 != 0 and x % 3 != 0 # вернуть истину, если x не делится ни на 2 ни на 3
Строка 1163 ⟶ 1226 :
[5, 7, 11, 13, 17, 19, 23]</source>
<source lang="python">>>> def cube(x): return x*x*x # вернуть куб аргумента
Строка 1178 ⟶ 1241 :
[0, 2, 4, 6, 8, 10, 12, 14]</source>
<source lang="python">>>> def add(x,y): return x+y # функция add складывает оба аргумента
Строка 1199 ⟶ 1262 :
0</source>
Не используйте определение функции <code>sum()</code> из этого примера: поскольку суммирование чисел — обычная необходимость, уже доступна встроенная функция <code>sum(''последовательность'')</code>, которая работает точно таким же образом
==== Списковые сборки<ref>''(Прим. перев.)'' ''Lists Comprehensions'', comprehension - включение, вложение, добавление (понимание, охват, интенция).</ref> ====
Строка 1241 ⟶ 1304 :
... # 335 на 113, округлённый до i знаков за запятой
['3.1', '3.14', '3.142', '3.1416', '3.14159']</source>
==== Вложенные списковые сборки ====
Если ваш живот ещё готов воспринять это, списковые сборки могут быть вложенными. Это мощный инструмент, но - как и любой мощный инструмент - их стоит использовать с осторожностью, если и использовать вообще.
Представьте нижеследующий пример матрицы 3x3 в виде списка, содержащего три других списка, по одному в ряд:
<source lang="python">>>> mat = [
... [1, 2, 3],
... [4, 5, 6],
... [7, 8, 9],
... ]</source>
Теперь, если вам нужно подменить строки столбцами, вы можете использовать списковую сборку:
<source lang="python">>>> print [[row[i] for row in mat] for i in [0, 1, 2]]
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]</source>
При создании вложенных списковых сборках нужно помнить об важной вещи:
:Чтобы избежать опасений при конструировании вложенных списковых сборок, читайте справа налево.
Чуть более многословная, но наглядная, версия этого примера позволяет взглянуть на процесс более детально:
<source lang="python">for i in [0, 1, 2]:
for row in mat:
print row[i],
print</source>
В реальных случаях лучше предпочесть встроенные функции, чем сложные выражения. В нашем случае поможет функция <code>zip()</code>:
<source lang="python">>>> zip(*mat)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]</source>
В разделе [[Учебник Python 2.6#Распаковка списков аргументов|Распаковка списков аргументов]] описано предназначение звёздочки в этих строках.
=== Оператор <code>del</code> ===
<source lang="python">>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
Строка 1261 ⟶ 1359 :
<source lang="python">>>> del a</source>
Ссылка на имя <code>a</code> в дальнейшем вызовет ошибку (по крайней мере до тех пор, пока
=== Кортежи и последовательности ===
Мы видели, что списки и строки поддерживают много привычных свойств, таких как индексирование и операция получения срезов. Существует два
Кортеж состоит из некоторого числа значений разделённых запятыми, например:
Строка 1343 ⟶ 1441 :
=== Словари ===
Другой полезный, встроенный в Python, тип данных — ''словарь'' (<tt>dictionary</tt>) (см. [[Справочник по библиотеке Python 2.
Лучше всего воспринимать словарь как неупорядоченный набор пар ''ключ: значение'' с требованием, чтобы ключи были уникальны (в пределах одного словаря). Пара скобок создает пустой словарь: <code>{}</code>. Указывая разделённый запятыми список пар ''ключ: значение'' внутри скобок, вы поочерёдно добавляете эти пары в словарь; таким же способом словарь пишется в вывод.
Строка 1349 ⟶ 1447 :
Главные операции над словарём — сохранение значения с каким-либо ключом и извлечение значения по указанному ключу. Также возможно удалить пару ''ключ: значение'' используя оператор <code>del</code>. Если вы сохраняете значение используя ключ, который уже встречается в словаре — старое значение, ассоциированное с этим ключом, стирается. Извлечение значения по несуществующему ключу вызывает ошибку.
Метод <code>keys()</code> объекта словарь возвращает список всех ключей, использующихся в словаре в случайном порядке (если вы хотите отсортировать его, к списку ключей можно применить метод <code>sort()</code>). Чтобы проверить, содержит ли словарь определённый ключ, используйте
Вот небольшой пример использования словарей:
Строка 1365 ⟶ 1463 :
>>> tel.keys()
['guido', 'irv', 'jack']
>>> 'guido' in tel
True</source>
Строка 1409 ⟶ 1505 :
>>> ответы = ['ланцелот', 'святой грааль', 'синий']<br/>
>>> '''для''' в, о '''среди''' ''зип''(вопросы, ответы):<br/>
... '''вывести''' 'Каков(о) ваш(е)
...<br/>
Каков(о) ваш(е) имя? ланцелот.<br/>
Строка 1418 ⟶ 1514 :
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print 'What is your
...
What is your name? It is lancelot.
Строка 1450 ⟶ 1546 :
Условия, участвующие в выражениях с <code>if</code> и <code>while</code> могут содержать любые операторы, не только операторы сравнения.
Операторы сравнения <code>in</code> и <code>not in</code> проверяют, встречается значение в последовательности или нет. Операторы <code>is</code> и <code>is not</code> проверяют, не являются ли два объекта на самом деле одним и тем же (это имеет
Сравнения можно объединять в цепи. Например, <code>a < b == c</code> проверяет, меньше ли <code>a</code> чем <code>b</code> и сверх того — равны ли <code>b</code> и <code>c</code>.
Строка 1456 ⟶ 1552 :
Сравнения могут быть скомпонованы с использованием булевых операций <code>and</code> и <code>or</code>, а результат сравнения (или любого другого булева выражения) можно отрицать используя <code>not</code>. Эти операторы имеют меньший приоритет, чем у операторов сравнения; среди них у <code>not</code> высший приоритет, а у <code>or</code> — низший, поэтому <code>A and not B or C</code> эквивалетно <code>(A and (not B)) or C</code>. Как всегда, скобки помогут выразить желаемый уклад.
Булевы операторы <code>and</code> и <code>or</code> — это так называемые ''коротящие операторы''<ref>''(Прим. перев.)'' ''short-circuit''{{ref-en}} — закоротить, обходить, идти обходными путями (для достижения цели), препятствовать</ref> (<tt>short-circuit operators</tt>): их аргументы вычисляются слева направо и вычисление заканчивается как только результат становится определён (очевиден). Например, если <code>A</code> и <code>C</code> являются истинами, а <code>B</code> — ложью, в условии <code>A and B and C</code> выражение <code>C</code> не вычисляется.
Можно присвоить результат сравнения, или другого булева выражения, переменной. Например,
Строка 1479 ⟶ 1575 :
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)</source>
Обратите внимание, что разрешено сравнение объектов разных типов
== Модули ==
Если вы выйдете из интерпретатора и зайдёте в него снова — все элементы, которые были вами определены (функции и переменные) будут потеряны. По этой причине, если вы захотите написать несколько более длинную программу, вам лучше использовать текстовый редактор для подготовки ввода для интерпретатора и запускать последний в режиме файлового ввода. Это называется созданием сценария. Если ваша программа становится обширнее, вы можете предпочесть разделить её на несколько файлов, для более удобной эксплуатации. Также вы можете захотеть использовать сразу в нескольких программах некоторую полезную функцию, написанную вами, без копирования её определения в каждую.
Для поддержки таких решений, в Python есть способ поместить определения в файл и использовать их в сценарии или в интерактивном режиме интерпретатора. Такой файл называется ''модулем'' (<tt>module</tt>); определения из модуля могут быть импортированы в другие модули, либо в главный модуль (коллекция переменных, к которым у вас есть доступ в сценарии, исполняемом на верхнем уровне и в режиме калькулятора).
Строка 1496 ⟶ 1592 :
print b,
a, b = b, a+b
print()
def fib2(n): # вернуть числа Фибоначчи вплоть до n
Строка 1547 ⟶ 1644 :
Импортируются все имена, кроме тех, которые начинаются на подчёркивание (<code>_</code>).
{{Info2|Для повышения эффективности, каждый модуль импортируется лишь единожды на каждый сеанс работы с интерпретатором. Поэтому, если вы изменили ваши модули, вам придётся перезапустить интерпретатор — или, если вам нужно интерактивно протестировать только один модуль, используйте <code>reload()</code> таким образом: <code>reload(<имя_модуля>)</code>}}
==== Выполнение модулей в качестве сценариев ====
Когда вы запускаете модуль Python в виде
<source lang="python">python fibo.py <аргументы></source>
то код в этом модуле будет исполнен в момент его импортирования, но значение <code>__name__</code> будет установлено как <code>"__main__"</code>. Это значит, что добавляя этот код в конец сценария:
<source lang="python">if __name__ == "__main__":
import sys
fib(int(sys.argv[1]))</source>
вы можете сделать возможным запуск файла и в качестве сценария и в качестве импортируемого модуля, поскольку код, который разбирает командную строку выполняется только в том случае, когда модуль исполняется как ''основной'' (<tt>main</tt>) файл:
<source lang="python">$ python fibo.py 50
1 1 2 3 5 8 13 21 34</source>
Если модуль импортируется, код не будет выполнен:
<source lang="python">>>> import fibo
>>></source>
Такой приём часто используется, чтобы предоставить удобный пользовательский интерфейс к модулю или для тестирования (выполнение модуля в качестве сценария запускает набор тестов).
==== Путь поиска модулей ====
Строка 1552 ⟶ 1675 :
Если импортируется модуль с именем <code>spam</code>, интерпретатор ищет файл с именем <tt>spam.py</tt> в текущем каталоге, а затем в каталогах, указанных в переменной окружения <code>PYTHONPATH</code>. У неё такой же синтаксис, как и у переменной шелла <code>PATH</code>, которая, в свою очередь, является перечислением каталогов. Когда переменная <code>PYTHONPATH</code> не установлена, или файл не найден в описанных в ней местах, поиск продолжается по пути по умолчанию, зависящему от указанного при установке; на Unix это обычно <tt>.:/usr/local/lib/python</tt>.
В действительности, поиск модулей производится в списке каталогов, передающемся в переменной <code>sys.path</code>, которая инициируется: каталогом, содержащим сценарий на входе (или текущий каталог), <code>PYTHONPATH</code> и умолчанием для каталога, указанного при установке. Это позволяет программам на Python (которые знают что делают) изменять или подменять путь поиска модулей. Заметьте — поскольку каталог, содержащий запускаемый вами сценарий, также находится в пути поиска — важно чтобы имя сценария не совпадало с именем стандартного модуля, иначе — когда этот модуль будет импортироваться — Python будет пытаться загрузить в виде модуля сам сценарий, в большинстве случаев это будет ошибкой. Для более подробной информации обратитесь к разделу [[Учебник Python 2.
==== „Скомпилированные“ файлы Python ====
Строка 1572 ⟶ 1695 :
* Можно иметь в наличии файл с именем <tt>spam.pyc</tt> (или <tt>spam.pyo</tt>, когда используется <tt>'''-O'''</tt>), не имея файла <tt>spam.py</tt> для того же модуля. Таким образом, можно распространять библиотеки кода Python в том виде, из которого трудно восстановить исходный код.
* Модуль <tt>[[
=== Стандартные модули ===
Python поставляется с библиотекой стандартных модулей, описанной в отдельном документе, [[Справочник по библиотеке Python 2.
<source lang="python">>>> import sys
Строка 1604 ⟶ 1727 :
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__',
'__stdin__', '__stdout__', '_getframe', 'api_version', 'argv',
'builtin_module_names', 'byteorder', 'callstats', 'copyright',
'displayhook', 'exc_clear', 'exc_info', 'exc_type', 'excepthook',
Строка 1614 ⟶ 1737 :
'version', 'version_info', 'warnoptions']</source>
Будучи
<source lang="python">>>> a = [1, 2, 3, 4, 5]
Строка 1622 ⟶ 1745 :
['__builtins__', '__doc__', '__file__', '__name__', 'a', 'fib', 'fibo', 'sys']</source>
Обратите внимание, что список состоит из имён всех типов: переменных, модулей, функций и т.д.
В списке, возвращаемом функцией <code>dir()</code> не содержится встроенных функций и переменных. Если вы хотите получить ''их'' список, то они определены в стандартном модуле <code>__builtin__</code>:
Строка 1633 ⟶ 1756 :
'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
'NotImplementedError', 'OSError', 'OverflowError',
'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',
'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError',
Строка 1655 ⟶ 1778 :
=== Пакеты ===
Пакеты — способ структурирования ''пространств имён'' (<tt>namespaces</tt>) модулей Python засчёт использования имён модулей, разделённых точками („<tt>dotted module names</tt>“). Например, имя модуля <code>A.B</code> означает — подмодуль<ref>''(Прим. перев.)'' ''подмодуль'' (<tt>submodule</tt>), ''зд.'' — модуль, находящийся в пакете. ''подпакет'' (<tt>subpackage</tt>), ''зд.'' — пакет, расположенный в пакете.</ref> с именем
Допустим, вы собираетесь разработать набор модулей (''пакет'', <tt>package</tt>) для унифицированной работы со звуковыми файлами и звуковыми данными. Существует множество форматов звуковых файлов (обычно их можно распознать по расширению, например: <tt>.wav</tt>, <tt>.aiff</tt>, <tt>.au</tt>) — таким образом, вам может понадобиться создать и поддерживать разрастающуюся коллекцию модулей для конвертирования между различными форматами файлов. Также вам наверняка захочется иметь побольше операций для обработки звуковых данных (таких как смешивание, добавление эха, применение функции эквалайзера, создание искусственного стерео-эффекта), так что в дополнение к этому вы будете писать нескончаемый поток модулей для исполнения этих операций. Вот возможная структура вашего пакета (выраженная в терминологии иерархической файловой системы):
<pre style="color:#00008b;">
__init__.py Инициализация пакета работы со звуком (sound)
__init__.py
wavread.py (чтение wav)
Строка 1670 ⟶ 1793 :
auwrite.py (запись au)
...
__init__.py
echo.py ( эхо )
Строка 1676 ⟶ 1799 :
reverse.py ( обращение )
...
__init__.py
equalizer.py ( эквалайзер )
vocoder.py ( вокодер )
karaoke.py ( караоке )
...</pre>
Строка 1689 ⟶ 1812 :
Пользователи пакета могут импортировать из него конкретные модули, например:
<source lang="python">import
Таким образом подгружается подмодуль <code>
<source lang="python">
Другой способ импортирования подмодуля:
<source lang="python">from
Так тоже подгружается подмодуль <code>echo</code>, но теперь он доступен без префикса пакета, поэтому может использоваться следующим образом:
Строка 1705 ⟶ 1828 :
И еще один вариант — прямое импортирование желаемой функции или переменной:
<source lang="python">from
Опять же, таким образом подгружается подмодуль <code>echo</code>, но теперь его функция <code>echofilter()</code> может быть вызвана непосредственно:
Строка 1717 ⟶ 1840 :
==== Импорт <code>*</code> из пакета ====
Что происходит, когда пользователь пишет <code>from
Единственный выход для автора пакета — предоставить его подробное содержание. Оператор <code>import</code> использует следующее соглашение: если в коде файла <tt>__init__.py</tt> текущего пакета определён список <code>__all__</code>, то он полагается списком имён модулей, которые нужно импортировать если обнаружено выражение <code>from ''пакет'' import *</code>. На совести автора поддержка этого списка в соответсвующем состоянии в каждой новой версии пакета. Впрочем, авторы пакета могут его не поддерживать вообще, если не видят смысла в импортировании <code>*</code> из их пакета. Например, файл <code>
<source lang="python">__all__ = ["echo", "surround", "reverse"]</source>
Это будет значить, что выражение <code>from
Если список <code>__all__</code> не определён, выражение <code>from Sound.Effects import *</code> не импортирует все подмодули пакета <code>
<source lang="python">import
import
from
В этом примере, модули <code>echo</code> и <code>surround</code> импортируются в текущее пространство имён, поскольку они определены в пакете <code>
Обратите внимание, что в общем случае импортирование <code>*</code> из модуля не приветствуется, поскольку в результате часто получается плохо-читаемый код. Однако, вполне нормально использовать его в интерактивных сессиях чтобы меньше печатать и определённые модули разработаны для экспорта только тех имён, которые следуют определённым шаблонам.
Помните, в использовании <code>from ''пакет'' import ''определённый_подмодуль''</code> нет ничего плохого. На самом деле — это рекомендованная запись, до тех пор пока при импортировании модуля не нужно использовать подмодулей с одинаковым именем из разных пакетов.
Строка 1763 ⟶ 1886 :
=== Прихотливое форматирование вывода ===
На данный момент мы выяснили два способа вывода значений: ''выражения с операторами'' (<tt>expression statements</tt>) и оператор <code>print</code>. (Третий способ — использование метода <code>write()</code> объектов файлов; на файл стандартного вывода можно сослаться как на <code>sys.stdout</code>. Более подробную информацию по этому пункту смотрите в [[Справочник по библиотеке Python 2.
Часто возникает желание иметь больший контроль над форматированием вывода, чем обычная печать значений разделённых пробелами. Есть два способа форматирования вашего вывода. Первый способ — выполнять самостоятельно всю работу над строками: используя срезы строк и конкатенацию вы можете создать любой шаблон какой пожелаете. Стандартный модуль <code>string</code> содержит много полезных операций для выравнивания строк по определённой ширине колонки — скоро мы их кратко рассмотрим. Второй способ — использование
Остаётся, конечно, один вопрос: какимм образом вам конвертировать значения в строки? К счастью, в Python есть пути для конвертации любого значения в строку: передайте его функциям <code>repr()</code> или <code>str()</code>
Предназначение функции <code>str()</code> — возврат значений в довольно-таки читабельной форме; в отличие от <code>repr()</code> , чьё назначение — генерирование форм<ref>(''Прим. перев.'') ''representation'' {{ref-en}} - представление, образ, форма</ref>, которые могут быть прочитаны интерпретатором (или вызовут ошибку <code>SyntaxError</code>, если эквивалентного синтаксиса не существует). Для тех объектов, у которых нету формы для человеческого прочтения функция <code>str()</code> возвратит такое же значение, какое возвратит <code>repr()</code>. У многих значений, таких как числа или структуры, вроде списков и словарей, одинаковая форма для обоих функций. Строки и числа с плавающей точкой, в частности, имеют по две разных формы.
Несколько примеров:
Строка 1793 ⟶ 1916 :
'привет, мир\n'
>>> # Аргументом функции repr() может быть объект Python:
... repr((x, y, ('
"(32.5, 40000, ('
Вот два способа вывести таблицу квадратов и кубов:
Строка 1830 ⟶ 1950 :
10 100 1000</source>
(Обратите внимание, что
Этот пример демонстрирует работу метода объектов строк <code>rjust()</code>, выравнивающего строку по правому краю в поле переданной ширины, отступая пробелами слева. Есть также похожие методы <code>ljust()</code> и <code>center()</code>. Эти методы не выводят ничего, они лишь возвращают новую строку. Если строка на входе чересчур длинная, то они не усекают её, а возвращают неизменённой; таким образом ваши колонки могут перемешаться, но это обычно лучшая идея чем её альтернативы, которые могут некорректно обработать значение. (Если вы действительно хотите использовать усечение, вы всегда можете добавить операцию среза, как в
Есть другой метод, <code>zfill()</code>, который заполняет нулями пространство слева от числовой строки. Он распознаёт знаки плюс и минус:
Строка 1843 ⟶ 1963 :
'3.14159265359'</source>
Основной способ применения метода <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>:
<source lang="python">>>> print 'Мы — те {0}, что говорят "{1}!"'.format('рыцари', 'Ни')
Мы — те рыцари, что говорят "Ни!"</source>
Скобки и символы, которые они окружают (их называют ''полями форматирования'' (<tt>format fields</tt>)) заменяются на объекты, переданные в метод <code>format</code>. Номер в скобках обозначает позицию объекта в списке аргументов, переданных в метод <code>format</code>.
<source lang="python">>>> print '{0} и {1}'.format('фарш', 'яйца')
фарш и яйца
>>> print '{1} и {0}'.format('фарш', 'яйца')
яйца и фарш</source>
Если в методе <code>format</code> используются именованные аргументы, ссылаться на их значения можно используя имя соответствующего аргумента<ref>''(Прим. перев.)'' <tt>вывести('Этот {пища} — {прилагательное}.'.format(пища='фарш', прилагательное='непередаваемо ужасен'))</tt></ref>.
<source lang="python">>>> print 'Этот {food} — {adjective}.'.format(
... food='фарш', adjective='непередаваемо ужасен')
Этот фарш — непередаваемо ужасен.</source>
Позиционные и именованные аргументы можно произвольно совмещать<ref>''(Прим. перев.)'' <tt>вывести 'История о {0}, {1}, и {другой}.'.форматировать('Билл', 'Манфред', другой='Георг')</tt></ref>:
<source lang="python">>>> print 'История о {0}е, {1}е, и {other}е.'.format('Билл', 'Манфред',
other='Георг')
История о Билле, Манфреде, и Георге.</source>
После имени поля может следовать необязательный спецификатор формата ‘<code>:</code>’. Пользуясь им, можно управлять тем, как значение будет отформатировано. Следующий пример оставляет у числа Пи только три цифры после десятичного разделителя<ref>''(Прим. перев.)'' В качестве десятичного разделителя в Python используется точка, в соответствии со стандартами большинства стран.</ref>.
<source lang="python">>>> import math
>>> print 'Значение ПИ — примерно
Значение ПИ — примерно 3.142.</source>
Если после спецификатора ‘<code>:</code>’ указать число — оно будет обозначать минимальную ширину поля, выраженную в количестве символов. Это удобно использовать для создания приятных для прочтения таблиц:
<source lang="python">>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
... print '
...
Jack ==> 4098
Dcab ==> 7678
Sjoerd ==> 4127</source>
Если ваша строка с форматами очень длинна, а вы не хотите разбивать её на подстроки, было бы неплохо если бы вы могли ссылаться на переменные, предназначенные для форматирования, не по позиции, а по имени. Это можно сделать, просто передав словарь и используя квадратные скобки ‘<tt>[]</tt>’ для доступа к ключам.
<source lang="python">>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
'Dcab: {0[Dcab]:d}'.format(table)
Jack: 4098; Sjoerd: 4127; Dcab: 8637678</source>
Также это можно сделать, передав таблицу в виде именованных аргументов, используя нотацию „<code>**</code>“:
<source lang="python">>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack:
Jack: 4098; Sjoerd: 4127; Dcab: 8637678</source>
Подробное описание форматирования строк с применением метода <code>str.format()</code> описано в разделе [[Справочник по библиотеке Python 2.6#Синтаксис строк форматирования|Синтаксис строк форматирования]].
==== Форматирование строк в старом стиле ====
Для фоматирования строк можно использовать и оператор <code>%</code>. Он интерпретирует левый аргумент как строку форматирования в стиле <code>sprintf</code>, которую следует применить к правому аргументу и возвращает строку, получившуюся за счёт этого преобразования. Например:
<source lang="python">>>> import math
>>> print 'Значение ПИ — примерно %5.3f.' % math.pi
Значение ПИ — примерно 3.142.</source>
Поскольку метод <code>str.format()</code> довольно нов, большая часть исходных кодов Python всё ещё использует оператор <code>%<code>. Однако, со временем, форматирование строк будет удалено из языка, поэтому в большинстве случаев следует использовать <code>str.format()</code>.
Больше информации можно найти в разделе [[Справочник по библиотеке Python 2.6#Операции форматирования строк|Операции форматирования строк]].
=== Запись и чтение файлов ===
Функция <code>open()</code> возвращает объект файла и в большинстве случаев используется с двумя аргументами:
<source lang="python">>>> f = open('/tmp/workfile', 'w')
>>> print f
<open file '/tmp/workfile', mode 'w' at 80a0960></source>
Строка 1879 ⟶ 2042 :
Первый аргумент — строка, содержащая имя файла. Второй аргумент — другая строка, содержащая несколько символов, описывающих каким образом файл будет использоваться. Значение аргумента ''режим'' может быть символом <code>'r'</code>, если файл будет открыт только для чтения, <code>'w'</code> — открыт только для записи (существующий файл с таким же именем будет стёрт), и <code>'a'</code> — файл открыт для добавления: любые данные, записанные в файл автоматически добавляются в конец. <code>'r+'</code> открывает файл и для чтения и для записи. Аргумент ''режим'' необязателен: если он опущен — предполагается, что он равен <code>'r'</code>.
==== Методы объектов <code>File</code> ====
Строка 1945 ⟶ 2108 :
ValueError: I/O operation on closed file</source>
Считается хорошей манерой использовать ключевое слово <code>with</code> при работе с объектами файлов. Преимущество этого способа в том, что файл всегда корректно закрывается после выполнения блока, либо если при выполении было порождено исключение. Кроме того, получающийся код намного короче, чем эквивалентная форма с блоками <tt><code>try</code>-<code>finally</code></tt>:
<source lang="python">>>> with open('/tmp/workfile', 'r') as f:
... read_data = f.read()
>>> f.closed
True</source>
У объектов файла есть ещё несколько дополнительных методов, таких как <code>isatty()</code> и <code>truncate()</code>, которые используются не так часто; обратитесь к [[Справочник по библиотеке Python 2.6|Справочнику по библиотеке]] для более полного обзора по объекту файла.
==== Модуль <code>pickle</code> ====
Строка 1961 ⟶ 2131 :
<source lang="python">x = pickle.load(f)</source>
(Существуют варианты выполнения этих операций, применяемые при ''расконсервации'' нескольких объектов или когда вам требуется записать ''консервированные'' данные в файл; проконсультируйтесь с полной документацией по модулю [[Справочник по библиотеке Python 2.
[[Справочник по библиотеке Python 2.
== Ошибки и исключения ==
Строка 1979 ⟶ 2149 :
SyntaxError: invalid syntax</source>
Парсер<ref>''(Прим. перев.)'' ''Parser'' {{ref-en}} — программа синтаксического анализа, синтаксический анализатор; программа грамматического разбора</ref> повторно выводит возмутившую его строку и отображает небольшую «стрелку», указывающую на самую первую позицию в строке, где была обнаружена ошибка. Причина ошибки (или по крайней мере место обнаружения) находится в символе<ref>''(Прим. перев.)'' ''Token'' {{ref-en}} — некоторая смысловая единица выражения: оператор, ключевое слово, значение переменной, ...</ref>, предшествующем указанному: в приведённом примере ошибка обнаружена на месте
=== Исключения ===
Строка 2004 ⟶ 2174 :
Предшествующая часть сообщения об ошибке показывает контекст, где произошло исключение, в форме стека вызовов. В общем случае она содержит стек, состоящий из списка строк исходного кода; тем не менее, в неё не войдут строки, прочитанные из стандартного ввода.
В разделе [[Справочник по библиотеке Python 2.6#Встроенные исключения|Встроенные исключения]] [[Справочник по библиотеке Python 2.
=== Обработка исключений ===
Строка 2041 ⟶ 2211 :
s = f.readline()
i = int(s.strip())
except IOError
print "I/O error(
except ValueError:
print "Не могу преобразовать данные в целое."
Строка 2070 ⟶ 2240 :
<source lang="python">>>> try:
... raise Exception('spam', 'eggs')
... except Exception
... print type(inst) # экземпляр исключения
... print inst.args # аргументы хранятся в .args
Строка 2093 ⟶ 2263 :
>>> try:
... this_fails()
... except ZeroDivisionError
... print 'Перехват ошибки времени исполнения:', detail
...
Строка 2134 ⟶ 2304 :
>>> try:
... raise MyError(2*2)
... except MyError
... print 'Поймано моё исключение со значением:', e.value
...
Строка 2143 ⟶ 2313 :
__main__.MyError: 'ой!'</source>
В этом примере конструктор по умолчанию <code>__init__()</code> класса <code>Exception</code> был перегружен. Новое поведение отличается лишь созданием нового атрибута <code>value</code> и заменяет поведение по умолчанию, при котором создаётся атрибут <code>args</code>.
Классы исключений могут определять любые действия, которые могут делать все другие классы, но обычно их внутренняя структура сохраняётся в простом виде, часто предоставляя лишь некоторые атрибуты, которые позволят обработчикам исключений выяснить информацию об ошибке подробно. При создании модуля, который может породить различные ошибки, обычной практикой будет создание базового класса для исключений, определённых в этом модуле, и подклассов, которые будут создавать определённые классы исключений для разных ошибочных состояний:
Строка 2180 ⟶ 2350 :
Большинство исключений определяются именем, заканчивающися на «<code>Error</code>», сходно именованию стандартных исключений.
Много стандартных модулей определяют собственные исключения, сообщающие об ошибках, которые могут появится в определяемых ими модулях. Больше информации о классах представлено в главе 1.10, [[Учебник Python 2.6#Классы|Классы]]
=== Определение действий при подчистке ===
Строка 2230 ⟶ 2400 :
<source lang="python">for line in open("myfile.txt"):
print
Проблема этого кода в том, что он оставляет файл открытым на неопределённое количество времени после выполнения данной части кода. В простых сценариях это не является проблемой, но может стать ей в больших приложениях. Оператор <code>with</code> позволяет использовать объекты (такие как, например, файлы) таким образом, чтобы вы всегда могли быть уверены в том, что ресурсы будут сразу и корректно очищены.
<source lang="python">with open("myfile.txt") as f:
for line in f:
print
После выполнения оператора, файл ''<code>f</code>'' всегда закрывается, даже если при прочтении строк обнаружилась проблема.
== Классы ==
Строка 2246 ⟶ 2414 :
За счёт механизма классов Python в язык с минимальным использованием нового синтаксиса и семантики добавляется возможность создания классов. Это смесь классовых механизмов, заимствованных из C++ и Modula-3. Как и в случае модулей, классы в Python не устанавливают абсолютного барьера между определением и программистом, рассчитывая больше на аккуратность и вежливость последнего — чтобы он не «врывался в определения». Наиболее важные возможности классов, тем не менее, содержат в себе всю возможную мощь: механизм наследования классов поддерживает несколько предков для класса, производный класс может перегружать любые методы своего предка или предков, а любой его метод может вызвать метод предка с таким же именем. Объекты могут содержать произвольное количество закрытых (<tt>private</tt>) данных.
В терминологии C++, все члены класса (включая данные-члены) открыты (<tt>public</tt>), а все функции-члены — виртуальны. Нет специальных конструкторов и деструкторов. Как в Modula-3, нет краткой ссылки на члены объекта из его методов: функция-метод определяется с явным первым аргументом, описывающем объект, который неявно передаётся при вызове. Как в Smalltalk, классы сами по себе являются объектами, хотя и в более широком смысле: в Python все типы данных — объекты. Таким образом обеспечивается семантика для импортирования и переименования. В отличие от C++ и Modula-3 встроенные типы могут использоваться в качестве предков для расширения возможностей пользователем. Кроме того, как в C++, но не как в Modula-3, большинство встроенных операторов со специальным синтаксисом (арифметические операторы, индексирование и т.д.) могут быть переопределены для экземпляров классов.
=== Пара слов о терминологии ===
Строка 2266 ⟶ 2434 :
Запись в атрибуты может быть запрещена (''атрибут только для чтения'', <tt>read-only attribute</tt>) или разрешена (''перезаписываемый атрибут'', <tt>writable attribute</tt>). В последнем случае присваивание атрибуту является возможным. Атрибуты модуля перезаписываемы: вы можете написать "<code>modname.the_answer = 42</code>"<ref>''(Прим. перев.)'' Снова [[w:ru:%D0%9E%D1%82%D0%B2%D0%B5%D1%82_%D0%BD%D0%B0_%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D1%8B%D0%B9_%D0%B2%D0%BE%D0%BF%D1%80%D0%BE%D1%81_%D0%B6%D0%B8%D0%B7%D0%BD%D0%B8%2C_%D0%B2%D1%81%D0%B5%D0%BB%D0%B5%D0%BD%D0%BD%D0%BE%D0%B9_%D0%B8_%D0%B2%D1%81%D0%B5%D0%B3%D0%BE_%D1%82%D0%B0%D0%BA%D0%BE%D0%B3%D0%BE|ответ на главный вопрос жизни, вселенной и всего такого]]</ref>. Перезаписываемые атрибуты могут также быть удалены оператором <code>del</code>. Например, код "<code>del modname.the_answer</code>" удалит атрибут <code>the_answer</code> из объекта с именем <code>modname</code>.
Пространства имён создаются в различные моменты и имеют разные жизненные циклы. Пространство имён, содержащее встроенные имена создаётся при запуске интерпретатора и не удаляется никогда. Глобальное пространство имён модуля создаётся при вычитке определения модуля; обычно, пространства имён модулей также «живут» до выхода из интерпретатора. Выражения, выполняемые верхне-уровневым порождением интерпретатора, прочитанные из файла сценария или интерактивно, рассматриваются как часть модуля под названием <code>__main__</code>, поэтому у них есть своё собственное глобальное пространство имён. (Встроенные имена по факту также живут в модуле, он называется <code>__builtin__</code>).
Локальное пространство имён функции создаётся при её вызове и удаляется когда функция возвращает значение либо порождает исключение, внутри неё не перехваченное. (На самом деле, лучшим способом объяснить, что происходит на самом деле, было бы «забывание»). Конечно же, рекурсивные порождения имеют свои пространства имён каждое.
Строка 2274 ⟶ 2442 :
Несмотря на то, что области видимости определяются статически, используются они динамически. В любой момент во время выполнения существует как минимум три вложенных области видимости, чьи пространства имён доступны прямым образом: самая глубокая<ref>''(Прим. перев.)'' ''Innermost scope'', ''outermost scope'' {{ref-en}} — самая внутренняя и самая внешняя области видимости</ref> область видимости, по которой поиск осуществляется в первую очередь, содержит локальные имена; пространства имён всех заключающих [данный код] функций, поиск по которым осуществляется начиная с ближайшей заключающей [код] области видимости; область видимости среднего уровня, по ней следующей проходит поиск и она содержит глобальные имена текущего модуля; и самая внешняя область видимости (заключительный поиск) — это пространство имён, содержащее встроенные имена.
Если имя определяется глобально, тогда все ссылки и присваивания уходят прямо в область видимости среднего уровня, содержащую глобальные имена модуля. Иначе
Обычно, локальная область видимости ссылается на локальные имена текущей (на уровне текста) функции. Вне функций локальная область видимости ссылается на то же пространство имён, что и глобальная область видимости: пространство имён модуля. Определения классов помещают в локальную область видимости ещё одно пространство имён.
Строка 2280 ⟶ 2448 :
Важно осознавать, что области видимости ограничиваются на текстовом уровне: глобальная область видимости функции, определённая в модуле, является пространством имён этого модуля, независимо от того, откуда или по какому псевдониму была эта функция вызвана. С другой стороны, фактический поиск имён осуществляется динамически, во время выполнения — как бы то ни было, описание языка эволюционирует в направлении статического разрешения имён, так что не стоит полагаться на динамическое разрешение имён. (По факту, локальные переменные уже определены статично.)
Особая хитрость в Python состоит в том, что
=== Первый взгляд на классы ===
Строка 2301 ⟶ 2469 :
На практике, выражения внутри определения класса обычно являются определениями функций, но также позволено использовать и другие операторы — и иногда с пользой — мы к этому вернёмся позже. Определения функций внутри класса имеют особенную форму списка аргументов, в связи с соглашениями по вызову методов — опять же, это будет рассмотрено ниже.
При вводе определения класса создаётся новое пространство имён, и используется в качестве локальной области видимости — таким образом, все присваивания локальным переменным уходят в это новое пространство имён. В частности, определения функций связываются здесь с именами новых функций.
При удачном окончании парсинга определения класса (при достижении конца определения), создаётся ''объект-класс'' (<tt>class object</tt>). По существу, это обёртка вокруг содержимого пространства имён, созданного по определению класса; подробнее объекты классов мы изучим в следующем разделе. Оригинальная локальная область видимости (та, которая действовала в последний момент перед вводом определения класса) восстанавливается, а объект-класс тут же связывается в ней с именем класса, указанном в заголовке определения класса (в примере — ''<code>ИмяКласса</code>'').
Строка 2312 ⟶ 2480 :
<source lang="python">class MyClass:
"""Простой пример класса"""
i = 12345
def f(self):
Строка 2327 ⟶ 2495 :
Операция ''создания экземпляра'' (<tt>instantiation</tt>, «вызов» объекта-класса) создаёт пустой объект. Большая часть классов предпочитает создавать экземпляры, настроенные с учётом определённого начального состояния. Для этого класс может определять специальный метод под именем <code>__init__()</code>, например так:
<source lang="python">
Когда в классе определён метод <code>__init__()</code>, при создании экземпляра автоматически вызывается <code>__init__()</code> нового, созданного, класса. Так, в этом примере, новый инициализированный экземпляр может быть получен засчёт выполнения кода:
Строка 2340 ⟶ 2508 :
... self.r = realpart
... self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
Строка 2367 ⟶ 2535 :
<source lang="python">x.f()</source>
<source lang="python">xf = x.f
Строка 2373 ⟶ 2541 :
print xf()</source>
будет печатать
Что конкретно происходит при вызове метода? Вы, возможно, заметили, что <code>x.f()</code> выше был вызван без аргументов, хотя в описании функции <code>f</code> аргумент был указан. Что же случилось с аргументом? Несомненно, Python порождает исключение когда функция, требующая присутствия аргумента, вызвана без единого — даже, если он на самом деле не используется...
Строка 2393 ⟶ 2561 :
Обычно, первый аргумент метода называется <code>self</code>. Это не более чем соглашение: имя <code>self</code> не имеет абсолютно никакого специального смысла для языка Python. (Однако, обратите внимание, что если вы не следуете соглашениям, ваш код может стать менее читабелен для других программистов; и также, потенциально, программа навигациии по классам может опираться на такие соглашения.)
Любой объект-функция, являющийся атрибутом класса, определяет метод для экземпляров этого класса. Не так важно, чтобы текст определения функции был заключен в определение класса: присваивание объекта-функции локальной переменной класса также работает неплохо. Например:
<source lang="python"># Функция, определённая вне класса
Строка 2442 ⟶ 2610 :
При перегрузке метода в производном классе возможна не только замена действия метода базового класса с тем же именем, но и его расширение. Существует простой способ вызвать метод базового класса прямым образом: просто вызовите "<code>ИмяБазовогоКласса.имяметода(self, аргументы)</code>". Такой способо будет неожиданно полезным и для клиентов. (Обратите внимание, что он работает только если базовый класс определён и импортирован прямо в глобальную область видимости.)
В языке Python есть две функции, которые работают с наследованием:
* Используйте <code>isinstance()</code> чтобы проверить тип объекта: <code>isinstance(obj, int)</code> возвратит <code>True</code> только если <code>obj.__class__<code> является <code>int</code> или некоторым классом, наследованным от <code>int</code>.
* Используйте <code>issubclass()</code> чтобы проверить наследственность класса: <code>issubclass(bool, int)</code> возвратит <code>True</code>, поскольку класс <code>bool<code> является наследником (<tt>subclass</tt>) <code>int</code>. Однако, <code>issubclass(unicode, str)</code> возвратит <code>False</code>, поскольку класс <code>unicode<code> не является наследником <code>str</code> (у них есть только общий дочерний класс, <code>basestring</code>).
==== Множественное наследование ====
Строка 2454 ⟶ 2627 :
<выражение-N></source>
(Для широкого круга людей, на первый взгляд, поиск в классах ''<code>Базовый2</code>'' и ''<code>Базовый3</code>'' перед поиском в базовых классах ''<code>Базового1</code>'', выглядит более естественным. Однако, предварительно здесь необходимо знание о том, определён ли действительно атрибут в ''<code>Базовом1</code>'', или он определён в одном из его предков — иначе вы столкнётесь с конфликтом имён с атрибутом в классе ''<code>Базовый2</code>''. Правило «глубина-сначала» не делает различий между прямыми и наследованными атрибутами ''<code>Базового1</code>''.)
Для классов в новом стиле, порядок разрешения методов<ref>''(Прим. перев.)'' другими словами — поиска корректной привязки для метода</ref> (<tt>method resolution order</tt>) меняется динамически, чтобы обеспечить возможность совместных вызовов <code>super()</code>. Этот способ известен в некоторых других языках с поддержкой множественного наследования как "вызов-следующего-метода" („<tt>call-next-method</tt>“) и имеет больше возможностей, чем вызов родительского метода в языках с единичным наследованием.
В случае классов в новом стиле, динамическое упорядочивание (<tt>dynamic ordering</tt>) имеет большую важность, поскольку все вариации множественного наследования проявляют в себе эффект ромбовых отношений (когда как минимум один родительский класс может быть доступен различными путями из низшего в иерархии класса). Например, все классы нового стиля наследуются от <code>object</code>, так что множественное наследование в любом виде предоставляет более одного пути для того, чтобы достичь <code>object</code>. Чтобы защитить базовые классы от двойных и более запросов, динамический алгоритм «выпрямляет» (<tt>linearizes</tt>) порядок поиска так способом, что тот сохраняет указанный слева-направо порядок для каждого класса, который вызывает каждый родительский класс только единожды и является монотонным (значит, класс можно сделать наследником, не взаимодействуя с порядком предсшествования его родителей). Обобщённые вместе, эти свойства позволяют разрабатывать надёжные и расширяемые классы, используя множественное наследование. С подробностями можно ознакомиться по этой ссылке: http://www.python.org/download/releases/2.3/mro/ ([[Python — Порядок разрешения методов|перевод]]).
=== Приватные переменные ===
Присутствует ограниченная поддержка идентификаторов, приватных для класса. Любой идентификатор в форме <code>__spam</code> (как минимум два предшествующих символа подчёркивания, как максимум один завершающий) заменяется дословно на <code>_classname__spam</code>, где <code>classname</code> — текущее имя класса, лишённое предшествующих символов подчёркивания. Это ''искажение'' (<tt>mangling</tt>) производится без оглядки на синтаксическую позицию идентификатора, поэтому может использоваться для определения переменных, приватных для класса экземпляров, переменных класса, методов, переменных в глобальной области видимости (<tt>globals</tt>), и даже переменных, использующихся в экземплярах, приватных для этого класса на основе экземпляров ''других'' классов. Имя может быть обрезано, если его длина превышает 255 символов. Вне классов, или когда имя состоит из одних символов подчёркивания, искажения не происходит.
Предназначение искажения имён состоит в том, чтобы дать классам лёгкую возможность определить «приватные» переменные экземпляров и методы, не беспокоясь о переменных экземпляров, определённых в производных классах, и о забивании кодом вне класса переменных экземпляров. Обратите внимание, что правила искажения имён разработаны, в основном, чтобы исключить неприятные случайности — решительная душа всё ещё может получить доступ или изменить переменные, предполагавшиеся приватными. В некотором особом окружении, таком как отладчик, это может оказаться полезным — и это единственная причина, по которой лазейка не закрыта. (Внимание: наследование класса с таким же именем как и у базового делает возможным использование приватных переменных базового класса.)
Заметьте, что код, переданный в <code>exec</code>
=== Всякая всячина ===
Строка 2492 ⟶ 2667 :
Отрезок кода на Python, требующий на входе определённого абстрактного типа данных, часто может быть передан классу, который эмулирует заместо него методы этого типа данных. Например, если у вас есть функция, форматирующая некоторые данные из объекта файла, то вы можете определить методы класса <code>read()</code> и <code>readline()</code>, которые вместо этого получат данные из строкового буфера и передать им его в качестве аргумента.
Объекты-методы экземпляров также имеют атрибуты: <code>m.im_self</code> — объект-экземпляр с методом <code>m()</code>, а <code>m.im_func</code> — объект-функция, соответствующий методу.
=== Исключения — тоже классы ===
| |||