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

Содержимое удалено Содержимое добавлено
м Ссылки; избыточные <big /> и <font /> вокруг <source />; пробелы.
Строка 93:
При наборе символа конца файла (<tt>Ctrl-D</tt> в Unix, <tt>Ctrl-Z</tt> в Windows) в ответ на основное приглашение интерпретатора, последний будет вынужден закончить работу с нулевым статусом выхода. Если это не сработает — вы можете выйти из интерпретатора путём ввода следующих команд:
 
<big><source lang="python">import sys; sys.exit()</source></big>
 
Особенности редактирования строк в интерпретаторе не оказываются, обычно, чересчур сложными. Те, кто установил интерпретатор на машину Unix, потенциально имеют поддержку библиотеки <tt>GNU readline</tt>, обеспечивающей усовершенствованное интерактивное редактирование и сохранение истории. Самый быстрый, наверное, способ проверить, поддерживается ли расширенное редактирование командной строки, заключается в нажатии <tt>Ctrl-P</tt> в ответ на первое полученное приглашение Python. Если вы услышите сигнал — значит вам доступно редактирование командной строки — тогда обратитесь к [[Учебник Python 2.6 — Приложения#Интерактивное редактирование входных данных и подстановка истории|Приложению об Интерактивном редактировании входных данных]] за описанием клавиш. Если на ваш взгляд ничего не произошло или отобразился символ <tt>^P</tt> — редактирование командной строки недоступно — удалять символы из текущей строки возможно будет лишь использованием клавиши <tt>Backspace</tt>.
Строка 115:
Если команды считываются с <tt>tty</tt> — говорят, что интерпретатор находится в ''интерактивном режиме'' (режиме диалога). В этом режиме он приглашает к вводу следующей команды, отобразив ''основное приглашение''<ref>''(Прим. перев.)'' <tt>primary prompt</tt> — ''зд.'', основное приглашение: приглашение к вводу команды или нескольких команд (сценария);</ref> (обычно это три знака «больше-чем» — <tt>&gt;&gt;&gt;</tt>); в то же время, для ''продолжающих строк''<ref>''(Прим. перев.)'' <tt>сontinuation lines</tt> — ''зд.'', продолжающие строки (строки продолжения): строки, продолжающие текст команды (оператора, выражения), или раскрывающие внутреннее устройство внешнего оператора (команды, выражения), в последнем случае определяются дополнительным отступом от края — углублением в структуру;</ref> выводится ''вспомогательное приглашение''<ref>''(Прим. перев.)'' <tt>secondary prompt</tt> — ''зд.'', вспомогательное приглашение: приглашение к продолжению ввода команды или набора команд (сценария) с использованием ''продолжающих строк'';</ref> (по умолчанию — три точки — <tt>...</tt>). Перед выводом первого приглашения интерпретатор отображает приветственное сообщение, содержащее номер его версии и пометку о правах копирования:
 
<big><source lang="python">python
Python 2.6 (#1, Feb 28 2007, 00:02:06)
Type "help", "copyright", "credits" or "license" for more information.
>>></source></big>
 
''Продолжающие строки'' используются в случаях, когда необходимо ввести многострочную конструкцию. Взгляните, например, на следующий оператор <code>if</code><ref>''(Прим. перев.)'' Здесь и далее тексты некоторых исходных кодов также будут переведены в примечаниях (вместе с ключевыми словами, поэтому их нельзя будет запустить в интерпретаторе), чтобы показать их смысл или задумку, которые не всегда очевидны без перевода (если он вам нужен :) ):<br/><br/>
Строка 127:
<span style="color: #030">Будьте осторожны — не упадите!</span></code><br/></ref>:
 
<big><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></big>
 
=== Интерпретатор и его окружение ===
Строка 169:
Например, для написания таких символов в кодировке Unicode, как, например, знак валюты Евро — может быть использована кодировка <tt>ISO-8859-15</tt>, где знак Евро имеет порядковый номер 164. Этот сценарий выведет значение 8346 (место в таблице Unicode, соответствующее символу Евро) и затем выполнит выход:
 
<big><source lang="python"># -*- coding: iso-8859-15 -*-
currency = u"€"
print ord(currency)</source></big>
 
Если ваш редактор поддерживает сохранение файлов в <tt>UTF-8</tt> вместе с пометкой порядка байтов (также известной как BOM - ''Byte Order Mark'') — вы можете использовать эту его возможность вместо указания кодировки. Редактор IDLE приобретает такую способность при установленном пункте меню <tt>Options/General/Default Source Encoding/UTF-8</tt>. Обратите внимание, что такие файлы не распознаются в прошлых релизах (2.2 и ранее), и также не распознаются самой операционной системой в случае файлов сценария со строкой <tt>#!</tt> в заголовке (используется только в системах Unix).
Строка 186:
Если вы хотите прочитать дополнительный файл запуска из текущего каталога — вы можете использовать код вроде:
 
<big><source lang="python">if os.path.isfile('.pythonrc.py'): execfile('.pythonrc.py')</source></big>
 
Если вы хотите использовать файл запуска в сценарии — вам нужно будет указать это явно:
 
<big><source lang="python">import os
filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
execfile(filename)</source></big>
 
== Неформальное введение в Python ==
Строка 203:
Несколько примеров:
 
<big><source lang="python"># это первый комментарий
SPAM = 1 # а это второй комментарий
# ... и наконец третий!
STRING = "# Это не комментарий."</source></big>
 
=== Использование Python в качестве калькулятора ===
Строка 216:
Поведение интерпретатора сходно поведению калькулятора: вы вводите выражение, а в ответ он выводит значение. Синтаксис выражений прямолинеен: операторы <code>+</code>, <code>-</code>, <code>*</code> и <code>/</code> работают также как и в большинстве других языков (например, Паскале или C); для группировки можно использовать скобки. Например:
 
<big><source lang="python">>>> 2+2
4
>>> # Это комментарий
Строка 229:
2
>>> 7//-3
-3</source></big>
 
Знак равенства (<code>'='</code>) используется для присваивания переменной какого-либо значения. После этого действия в интерактивном режиме ничего не выводится:
 
<big><source lang="python">>>> width = 20
>>> height = 5*9
>>> width * height
900</source></big>
 
Значение может быть присвоено нескольким переменным одновременно:
 
<big><source lang="python">>>> x = y = z = 0 # Нулевые x, y и z
>>> x
0
Строка 246:
0
>>> z
0</source></big>
 
Переменные должны быть ''определены'' (<tt>defined</tt>) (должны иметь присвоенное значение) перед использованием, иначе будет сгенерирована ошибка:
 
<big><source lang="python"> >>> # попытка получить доступ к неопределённой переменной
... n
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined</source></big>
 
Присутствует полная поддержка операций с плавающей точкой; операторы с операндами смешанного типа конвертируют целочисленный операнд в число с плавающей точкой:
 
<big><source lang="python">>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5</source></big>
 
Также поддерживаются комплексные числа; к мнимым частям добавляется суффикс <code>j</code> или <code>J</code>. Комплексные числа с ненулевым вещественным компонентом записываются в виде <code>(''<вещественная_часть>''+''<мнимая_часть>''j)</code>, или могут быть созданы с помощью функции <code>complex(''<вещественная_часть>'', ''<мнимая_часть>'')</code>.
 
<big><source lang="python">>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0, 1)
Строка 274:
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)</source></big>
 
Комплексные числа всегда представлены в виде двух чисел с плавающей точкой - вещественной и мнимой частями. Для получения этих частей из комплексного числа <code>z</code> используйте <code>z.real</code> и <code>z.imag</code>.
 
<big><source lang="python">>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5</source></big>
 
Функции конвертации (приведения) к вещественным и целым числам (<code>float()</code>, <code>int()</code> и <code>long()</code>) не работают с комплексными числами — нет единственно правильного способа сконвертировать комплексное число в вещественное. Используйте функцию <code>abs(z)</code> чтобы получить ''модуль'' числа (в виде числа с плавающей точкой) или <code>z.real</code> чтобы получить его вещественную часть:
 
<big><source lang="python">>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
Строка 297:
>>> abs(a) # sqrt(a.real**2 + a.imag**2)
5.0
>>></source></big>
 
В интерактивном режиме последнее выведенное выражение сохраняется в переменной <code>_</code>. Это значит, что если вы используете Python в качестве настольного калькулятора — всегда есть способ продолжить вычисления с меньшими усилиями, например:
 
<big><source lang="python">>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
Строка 309:
>>> round(_, 2)
113.06
>>></source></big>
 
Эта переменная для пользователя должна иметь статус ''только для чтения''. Не навязывайте ей значение собственноручно — вы создадите независимую переменную с таким же именем, скрывающую встроенную переменную вместе с её магическими свойствами.
Строка 317:
Помимо чисел, Python может работать со строками, которые, в свою очередь, могут быть описаны различными способами. Строки могут быть заключены в одинарные или двойные кавычки:
 
<big><source lang="python">>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
Строка 328:
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'</source></big>
 
Строковые литералы могут быть разнесены на несколько строк различными способами. Могут быть использованы ''продолжающие строки'', с обратным слэшем в качестве последнего символа строки, сообщающим о том, что следующая строка есть продолжение текущей<ref>''(Прим. перев.):''<source lang="python">hello = "Это довольно длинная строка, содержащая\n\
Строка 337:
print hello</source></ref>:
 
<big><source lang="python">hello = "This is a rather long string containing\n\
several lines of text just as you would do in C.\n\
Note that whitespace at the beginning of the line is\
significant."
 
print (hello)</source></big>
 
Обратите внимание, что для переноса строки все ещё нужно указывать <code>\n</code>; строка, за которой следует обратный слэш перенесена не будет. Запуск примера выведет следующее:
Строка 352:
Если мы объявим строковой литерал ''сырым'' (<tt>raw</tt>)<ref>''(Прим. перев.)'' ''raw string'' — для описания ''сырой строки'' (не требующей последующей обработки) используется префикс '''<code>r</code>'''.</ref> — символы <code>\n</code> не будут конвертированы в новые строки, таким образом и обратный слэш в конце строки, и символ новой строки в исходном коде — будут добавлены в строку в виде данных. Следовательно, код из примера:
 
<big><source lang="python">hello = r"This is a rather long string containing\n\
several lines of text much as you would do in C."
 
print (hello)</source></big>
 
выведет:
Строка 365:
Или строки могут быть обрамлены совпадающей парой тройных кавычек: <code>"""</code> или <code><nowiki>'''</nowiki></code>. Окончания каждой строчки не нужно завершать тройными кавычками. В примере ниже строки, начинающиеся с дефиса также будут включены в строку.
 
<big><source lang="python">print """
Usage: thingy [OPTIONS]
-h Display this usage message
Строка 375:
<source lang="text">Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to</source></big>
 
Интерпретатор выводит результаты операций над строками тем же способом, каким они были введены: в кавычках, а также в кавычках и с другими забавными символами, экранированными обратными слэшами — для того, чтобы показать точное значение. Строка заключается в двойные кавычки, если строка содержит одинарную кавычку и ни одной двойной, иначе она заключается в одинарные кавычки. (Оператор <code>print</code>, описанный позже, может использоваться для вывода строк без кавычек или экранирования.)
Строка 381:
Строки могут конкатенироваться (склеиваться вместе) оператором <code>+</code> и быть повторенными оператором <code>*</code>:
 
<big><source lang="python">>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'</source></big>
 
Два строковых литерала, расположенные друг за другом, автоматически конкатенируются; первая строка в предыдущем примере также могла быть записана как <code>word = 'Help' 'A'</code>; это работает только с двумя литералами — не с произвольными выражениями, содержащими строки.
 
<big><source lang="python">>>> 'str' 'ing' # <- Так — верно
'string'
>>> 'str'.strip() + 'ing' # <- Так — верно
Строка 397:
'str'.strip() 'ing'
^
SyntaxError: invalid syntax</source></big>
 
Строки могут быть проиндексированы; также как и в C, первый символ строки имеет индекс <tt>0</tt>. Отсутствует отдельный тип для символов; символ является строкой с единичной длиной. Подобно языку [[w:Icon (язык программирования)|Icon]], подстроки могут определены через нотацию срезов (<tt>slice</tt>): два индекса, разделенных двоеточием.
 
<big><source lang="python">>>> word = 'Help' + 'A'
>>> word[4]
'A'
Строка 407:
'He'
>>> word[2:4]
'lp'</source></big>
 
Индексы срезов имеют полезные значения по умолчанию; опущенный первый индекс заменяется нулём, опущенный второй индекс подменяется размером срезаемой строки.
 
<big><source lang="python">>>> word[:2] # Первые два символа
'He'
>>> word[2:] # Всё, исключая первые два символа
'lpA'</source></big>
 
В отличие от строк в C, строки Python не могут быть изменены. Присваивание по позиции индекса строки вызывает ошибку:
 
<big><source lang="python">>>> word[0] = 'x'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
Строка 432:
'xelpA'
>>> 'Splat' + word[4]
'SplatA'</source></big>
 
Полезный инвариант операции среза: <code>s[:i] + s[i:]<code> эквивалентно <code>s</code>.
 
<big><source lang="python">>>> word[:2] + word[2:]
'HelpA'
>>> word[:3] + word[3:]
'HelpA'</source></big>
 
Вырождения индексов срезов обрабатываются элегантно: чересчур большой индекс заменяется на размер строки, а верхняя граница меньшая нижней возвращает пустую строку.
 
<big><source lang="python">>>> word[1:100]
'elpA'
>>> word[10:]
''
>>> word[2:1]
''</source></big>
 
Индексы могут быть отрицательными числами, обозначая при этом отсчет справа налево. Например:
 
<big><source lang="python">>>> word[-1] # Последний символ
'A'
>>> word[-2] # Предпоследний символ
Строка 459:
'pA'
>>> word[:-2] # Всё, кроме последних двух символов
'Hel'</source></big>
 
Но обратите внимание, что <tt>-0</tt> действительно эквивалентен <tt>0</tt> - это не отсчет справа.
 
<big><source lang="python">>>> word[-0] # (поскольку -0 равен 0)
'H'</source></big>
 
Отрицательные индексы вне диапазона обрезаются, но не советуем делать это с одно-элементными индексами (''не-срезами''):
 
<big><source lang="python">>>> word[-100:]
'HelpA'
>>> word[-10] # ошибка
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IndexError: string index out of range</source></big>
 
Один из способов запомнить, как работают срезы — думать о них, как об указателях на места между символами, где левый край первого символа установлен в ноль, а правый край последнего символа строки из <code>n</code> символов имеет индекс <code>n</code>, например:
Строка 489:
Встроенная функция <code>len()</code> возвращает длину строки<ref>''(Прим. перев.)'': [[w:en:Supercalifragilisticexpialidocious|Supercalifragilisticexpialidocious]] — английское слово из одноименной песни, прозвучавшей в фильме [[w:en:Mary Poppins (film)|Мэри Поппинс]].</ref>:
 
<big><source lang="python">>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34</source></big>
 
{{Смотрите также|
Строка 508:
Создание в Python строк в Unicode является действием настолько же простым, насколько простым является и создание обычных строк:
 
<big><source lang="python">>>> u'Hello World !'
u'Hello World !'</source></big>
 
Строчная буква "<code>u</code>" перед кавычкой указывает на необходимость создания Unicode-строки. Если вы хотите включить в строку специальные символы — вы можете сделать это используя ''кодирование Unicode-Экранированием'' Python (<tt>Python Unicode-Escape encoding</tt>). Следующий пример поясняет как:
 
<big><source lang="python">>>> u'Hello\u0020World !'
u'Hello World !'</source></big>
 
Экранированная последовательность <code>\u0020</code> указывает на позицию, куда требуется вставить символ Unicode с порядковым номером <tt>0x0020</tt> (символ пробела).
Строка 522:
Для экспертов присутствует также ''сырой'' режим — такой же, как и для обычных строк. Вам требуется поставить перед открывающей кавычкой префикс "<code>ur</code>", чтобы Python использовал ''кодирование Сырым-Unicode-Экранированием'' (<tt>Raw-Unicode-Escape encoding</tt>). Описанная выше конверсия <code>\uXXXX</code> будет применена только при условии наличия перед строчной "<code>u</code>" нечётного количества обратных слэшей.
 
<big><source lang="python">>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'</source></big>
 
''Сырой'' режим наиболее полезен, если вам необходимо ввести множество обратных слэшей — это может потребоваться в случае использования регулярных выражений.
Строка 533:
Встроенная функция <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> — конвертирование производится с использованием кодировки по умолчанию.
 
<big><source lang="python">>>> u"abc"
u'abc'
>>> str(u"abc")
Строка 542:
Traceback (most recent call last):
File "<stdin>", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)</source></big>
 
Для конвертирования Unicode-строки в строку с использованием желаемой кодировки, объекты Unicode предоставляют метод <code>encode()</code>, имеющей формат <code>encode([encoding,[,errors]]</code>. Encoding - необязательный аргумент, указывающий в какую кодировку стоит перевести строку. По умолчанию - ASCII. Errors - так же необязательный аргумент - указывает на способ обрабитки ошибок кодировщиком. По умолчанию используется 'strict' - если символ не может быть представлен в данной кодировке, генерируется исключение UnicodeError. Другие возможные значения - 'ignore' (отсутствующие символы удаляются) и 'replace' - (отсутствующие в кодировке символы заменяются, обычно на символ '?'). Для именования кодировок предпочитаются названия записанные в нижнем регистре.
 
<big><source lang="python">>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'</source></big>
 
Если у вас есть в наличии данные в некоторой кодировке, а вы хотите создать на их основе соответствующую строку в Unicode — вы можете использовать функцию <code>unicode()</code>, передав название кодировки вторым аргументом.
 
<big><source lang="python">>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'</source></big>
 
==== Списки ====
Строка 558:
В языке Python доступно некоторое количество ''составных'' типов данных, использующихся для группировки прочих значений вместе. Наиболее гибкий из них — список (<tt>list</tt>); его можно выразить через разделённые запятыми значения (''элементы''), заключённые в квадратные скобки. Элементы списка могут быть разных типов.
 
<big><source lang="python">>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]</source></big>
 
Подобно индексам в строках, индексы списков начинаются с нуля, списки могут быть срезаны, объединены (''конкатенированы'') и так далее:
 
<big><source lang="python">>>> a[0]
'spam'
>>> a[3]
Строка 575:
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boo!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']</source></big>
 
В отличие от строк, являющихся неизменяемыми, изменить индивидуальные элементы списка вполне возможно:
 
<big><source lang="python">>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]</source></big>
 
Присваивание срезу также возможно, и это действие может даже изменить размер списка или полностью его очистить:
 
<big><source lang="python">>>> # Заменим некоторые элементы:
... a[0:2] = [1, 12]
>>> a
Строка 606:
>>> a[:] = []
>>> a
[]</source></big>
 
Встроенная функция <code>len()</code> также применима к спискам:
 
<big><source lang="python">>>> a = ['a', 'b', 'c', 'd']
>>> len(a)
4</source></big>
 
Вы можете встраивать списки (создавать списки, содержащие другие списки), например так:
 
<big><source lang="python">>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
Строка 623:
[2, 3]
>>> p[1][0]
2</source></big>
 
Вы можете добавить что-нибудь в конец списка.
 
<big><source lang="python">>>> p[1].append('xtra') # Смотрите раздел Подробнее о списках
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']</source></big>
 
Обратите внимание, что в последнем примере <code>p[1]</code> и <code>q</code> на самом деле ссылаются на один и тот же объект! Мы вернёмся к ''семантике объектов'' позже.
Строка 639:
Безусловно, Python можно использовать для более сложных задач, чем сложение двух чисел. Например, мы можем вывести начальную последовательность чисел Фибоначчи таким образом:
 
<big><source lang="python">>>> # Ряд Фибоначчи:
... # сумма двух элементов определяет следущий элемент
... a, b = 0, 1
Строка 651:
3
5
8</source></big>
 
Этот пример представляет нам некоторые новые возможности.
Строка 659:
* Цикл <code>while</code> исполняется до тех пор, пока условие (здесь: <code>b < 10</code>) остается истиной. В Python, также как и в C, любое ненулевое значение является истиной (<code>true</code>); ноль является ложью (<code>false</code>). Условием может быть строка или значение списка, вообще любая последовательность; все, что имеет не-нулевую длину является истиной, пустые последовательности являются ложью. Проверка, использованная в примере — простое условие. Стандартные операторы сравнения записываются также как и в C: <code><</code> (меньше чем), <code>></code> (больше чем), <code>==</code> (равно, идентично), <code><=</code> (меньше или равно), <code>>=</code> (больше или равно) и <code>!=</code> (не равно).
 
* ''Тело'' цикла описано ''с использованием отступа'' (<tt>indented</tt>): Отступы — это способ группировки выражений в Python. Python (пока!) не имеет какого-либо разумного и удобного средства для редактирования строк ввода, поэтому вам нужно использовать табуляцию или пробел(ы) для отступа в каждой строке. На практике вы будете подготавливать более сложный ввод для Python в текстовом редакторе, а большинство из них имеют сервис авто-отступа. По окончанию ввода составного выражения в интерактивном режиме, необходимо закончить его пустой строкой — признаком завершения (поскольку парсер не может угадать, когда вами была введена последняя строка). Обратите внимание, что размер отступа в каждой строке основного блока должен быть одним и тем же<ref>''(Прим. перев.)'' Размер отступа для блока не унифицирован - табуляция может чередоваться с пробелами, это может быть один пробел или же пять — главное, чтобы у всего блока он был одинаковым и был больше по величине чем у внешнего (обрамляющего) блока. Тем не менее, чаще всего программисты на Python устанавливают в редакторах режим замены табуляции четырьмя пробелами и при наборе кода вложенность блока обозначают отступом с соответствующим количеством нажатий клавиш табуляции. Благодаря этому код остается читабельным во всех текстовых редакторах и в большинстве браузеров (или, в редких случаях, требует минимального форматирования для корректного отображения)).''</ref>.
 
* Оператор <code>print</code> выводит значения переданного(-ных) ему выражения(-ний). Это поведение отличается от обычного вывода выражения (как происходило выше в примерах с калькулятором) тем, каким способом обрабатываются ряды выражений и строки. Строки выводятся без кавычек и между элементами вставляются пробелы, благодаря чему форматирование вывода становится более удобным — как, например, здесь:
<big><source lang="python">>>> i = 256*256
>>> print ('Значением i является', i)
Значением i является 65536</source>
Строка 671:
... a, b = b, a+b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987</source></big>
:Обратите внимание на то, что интерпретатор вставляет новую строку перед тем как выводит следующее приглашение, если последняя строка не была завершена.
 
Строка 682:
Возможно наиболее широко известный тип выражения &#151; оператор <code>if</code>. Пример:
 
<big><source lang="python">>>> x = int(raw_input("Введите, пожалуйста, целое число: "))
Введите, пожалуйста, целое число: 42
>>> if x < 0:
Строка 694:
... print 'Больше'
...
Больше</source></big>
 
Блоков <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>, которые можно встретить в других языках.
Строка 702:
Оператор <code>for</code> в Python немного отличается от того, какой вы, возможно, использовали в C или Pascal. Вместо неизменного прохождения по арифметической прогрессии из чисел (как в Pascal) или предоставления пользователю возможности указать шаг итерации и условие останова (как в С), оператор <code>for</code> в Python проходит по всем элементам любой последовательности (списка или строки) в том порядке, в котором они в ней располагаются. Например (игра слов не подразумевалась):<ref>''(Прим. перев.)'' Defenestrate{{ref-en}} — выкидывать кого-либо из окна с целью покалечить. Другие слова — «кошка» и «окно».</ref>
 
<big><source lang="python">>>> # Измерим несколько строк:
... a = ['cat', 'window', 'defenestrate']
>>> for x in a:
Строка 709:
cat 3
window 6
defenestrate 12</source></big>
 
Изменять содержимое последовательности, по которой проходит цикл, небезопасно (это можно сделать только для изменяемых типов последовательностей, таких как списки).
Строка 715:
Нотация срезов делает это практически безболезненным:
 
<big><source lang="python">>>> for x in a[:]: # создать срез-копию всего списка
... if len(x) > 6: a.insert(0, x)
...
>>> a
['defenestrate', 'cat', 'window', 'defenestrate']</source></big>
 
=== Функция <code>range()</code> ===
Строка 725:
Если вам нужно перебрать последовательность чисел, встроенная функция <code>range()</code> придёт на помощь. Она генерирует списки, содержащие арифметические прогрессии:
 
<big><source lang="python">>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]</source></big>
 
Указанная точка завершения никогда не оказывается частью сгенерированного списка; вызов <code>range(10)</code> генерирует список из десяти значений — потенциальные индексы для элементов последовательности длиной 10. Позволено установить начало списка на другое число или указать другую величину инкремента (даже негативную; иногда её называют ''шагом'' (<tt>step</tt>)).
 
<big><source lang="python">>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]</source></big>
 
Чтобы пройти по всем индексам какой-либо последовательности, совместите вызовы <code>range()</code> и <code>len()</code> следующим образом:
 
<big><source lang="python">>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
... print i, a[i]
Строка 747:
2 a
3 little
4 lamb</source></big>
 
Однако в большинстве таких случаев удобно использовать функцию <code>enumerate()</code>.
Строка 760:
Операторы циклов могут иметь ветвь <code>else</code>; она исполняется, когда цикл прекращает сквозной анализ списка (в случае <code>for</code>) или когда условие становится ложным (в случае <code>while</code>), но не в тех случаях, когда цикл прерывается по <code>break</code>. Это поведение иллюстрируется следующим примером, в котором производится поиск простых чисел:
 
<big><source lang="python">>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
Строка 776:
7 - простое число
8 равно 2 * 4
9 равно 3 * 3</source></big>
 
=== Оператор <code>pass</code> ===
Строка 784:
Например:
 
<big><source lang="python">>>> while True:
... pass # Ожидание прерывания c клавиатуры (Ctrl+C) в режиме занятости
...</source></big>
 
Этот оператор часто используется для создания минималистичных классов, к примеру ''исключений'' (<tt>exceptions<tt>), или для игнорирования нежелательных исключений:
Строка 839:
При определении функции её имя также помещается в текущую таблицу символов. Тип значения, связанного с именем функции, распознается интерпретатором как функция, определённая пользователем (<tt>user-defined function</tt>). Само значение может быть присвоено другому имени, которое затем может также использоваться в качестве функции. Эта система работает в виде основного механизма переименования:
 
<big><source lang="python">>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
1 1 2 3 5 8 13 21 34 55 89</source></big>
 
Если вы использовали в работе другие языки программирования, вы можете возразить, что <code>fib</code> — это не функция, а процедура, поскольку не возвращает никакого значения. На самом деле, даже функции без ключевого слова <code>return</code> возвращают значение, хотя и более скучное. Такое значение именуется <code>None</code> (это встроенное имя). Описание значения <code>None</code> обычно придерживается за интерпретатором, если оно оказывается единственным значением, которое нужно вывести. Вы можете проследить за этим процессом, если действительно хотите, используя оператор <code>print</code>:
 
<big><source lang="python">>>> fib(0)
>>> print fib(0)
None</source></big>
 
Довольно легко написать функцию, которая возвращает список чисел из ряда Фибоначчи, вместо того, чтобы выводить их:
 
<big><source lang="python">>>> def fib2(n): # вернуть числа Фибоначчи меньшие (вплоть до) n
... """Возвращает список чисел ряда Фибоначчи, ограниченный n."""
... result = []
Строка 864:
>>> f100 = fib2(100) # вызываем
>>> f100 # выводим результат
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]</source></big>
 
Этот пример, как уже привычно, демонстрирует некоторые новые возможности Python:
Строка 890:
(''Refusenik''{{ref-en}} — [[w:ru:Отказник|Отказник]]). Ниже: «...<code>спросить_подтверждения('Вы действительно хотите выйти?')</code> или так: <code>спросить_подтверждения('Согласны ли вы перезаписать файл?', 2)</code>...»</ref>:
 
<big><source lang="python">def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while True:
ok = raw_input(prompt)
Строка 897:
retries = retries - 1
if retries < 0: raise IOError, 'refusenik user'
print complaint</source></big>
 
Эта функция может быть вызвана, например, так: <code>ask_ok('Do you really want to quit?')</code> или так: <code>ask_ok('OK to overwrite the file?', 2)</code>.
Строка 905:
Значения по умолчанию вычисляются в точке определения функции — в ''определяющей'' области, поэтому код
 
<big><source lang="python">i = 5
 
def f(arg=i):
Строка 911:
 
i = 6
f()</source></big>
 
выведет 5.
Строка 917:
'''Важное предупреждение:''' Значение по умолчанию вычисляется лишь единожды. Это имеет вес, когда значением по умолчанию является изменяемый объект, такой как список, словарь (<tt>dictionary</tt>) или экземляры большинства классов. Например, следующая функция накапливает переданные ей аргументы с последовательными вызовами:
 
<big><source lang="python">def f(a, L=[]):
L.append(a)
return L
Строка 923:
print f(1)
print f(2)
print f(3)</source></big>
 
Она выведет
 
<big><source lang="python">[1]
[1, 2]
[1, 2, 3]</source></big>
 
Если вы не хотите, чтобы значение по умолчанию распределялось между последовательными вызовами, вместо предыдущего варианта вы можете использовать такой способ:
 
<big><source lang="python">def f(a, L=None):
if L is None:
L = []
L.append(a)
return L</source></big>
 
==== Именованные аргументы <ref>''(Прим. перев.)'' В оригинале — Keyword Arguments — аргументы по ключевым словам, ключевые аргументы (далее используется слово ''keywords'' для набора имён параметров непостоянного количества. ''Ключевые'' - возможно, корректнее, но как мне показалось — менее понятно ([http://www.infocity.kiev.ua/prog/python/content/sempit_14.phtml альтернативный перевод]))</ref> ====
Строка 1135:
* При возможности располагайте комментарий на отдельной строке.
* Используйте строки документации (''док-строки'')
* Применяйте пробелы вокруг операторов и после запятых, но не добавляйте их в конструкции со скобками:
<code><source lang="python">spam(ham[1], {eggs: 2}, 3, 4) #правильно
spam( ham[ 1 ], { eggs: 2 }, 3 , 4 ) #неправильно</source></code>
Строка 1224:
==== Инструменты функционального программирования ====
 
Есть три встроенных функции, которые очень удобно использовать в сочетании со списками: <code>filter()</code>, <code>map()</code> и <code>reduce()</code>.
 
<code>filter(''функция'', ''последовательность'')</code> возвращает последовательность, состоящую из тех элементов ''последовательности'', для которых ''функция''(''элемент'') является истиной. Если последовательность — строка (<tt>string</tt>) или кортеж (<tt>tuple</tt>), результат будет иметь тот же тип; в других случаях — это всегда список. Например, чтобы найти несколько простых чисел:
Строка 1241:
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]</source>
 
Можно передать более чем одну последовательность; тогда функция должна иметь столько аргументов, сколько передано последовательностей и вызывается для каждого соответствующего элемента каждой последовательности (или <code>None</code>, если одна из последовательностей короче другой). Например:
 
<source lang="python">>>> seq = range(8) # seq - числа от 0 до 7
Строка 2089:
Вторая строка файла</source>
 
Альтернативный способ проще, но не предоставляет тонкого контроля над происходящим. Поскольку оба этих способа работают с буферизацией строк по разному, не следует их смешивать.
 
<code>f.write(''строка'')</code> записывает содержимое ''строки'' в файл и возвращает <code>None</code>.
Строка 2095:
<source lang="python">>>> f.write('Это тест\n')</source>
 
Чтобы записать в файл нечто отличное от строки, предварительно это нечто нужно в строку сконвертировать<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>:
 
<source lang="python">>>> value = ('ответ', 42)
Строка 2101:
>>> f.write(s)</source>
 
<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>, используя начало файла в качестве точки отсчёта.
 
<source lang="python">>>> f = open('/tmp/workfile', 'r+')
Строка 2248:
В блоке <code>except</code> можно указать переменную, следующую за именем исключения (или кортежем). Переменная связывается с экземпляром исключения, аргументы которого хранятся в <code>instance.args</code>. Для удобства, экземпляр исключения определяет методы <code>__getitem__</code> и <code>__str__</code>, так что доступ к аргументам или их вывод могут быть произведены явно, без необходимости отсылки к <code>.args</code>.
 
Использование <code>.args</code> в целом не одобряется. Вместо этого, рекомендуемый способ использования — это передача исключению единственного аргумента (который может быть кортежем, если требуется несколько аргументов) и его связь с атрибутом <code>message</code>. Таким образом можно создать экземпляр исключения перед его ''порождением'' (<tt>raising</tt>) и добавить любые атрибуты по желанию.
 
<source lang="python">>>> try:
Строка 2444:
Кстати, слово ''атрибут'' (<tt>attribute</tt>) я применяю к любому имени, следующему за точкой, — например, в выражении <code>z.real</code>, <code>real</code> — это атрибут объекта <code>z</code>. Строго говоря, ссылки на имена в модуле являются ссылками на атрибуты: в выражении <code>''имя_модуля''.''имя_функции''</code> под ''имя_модуля'' скрывается объект модуля, а под ''имя_функции'' — его атрибут. В таком случае обнаруживается прямолинейная связь между атрибутами модуля и глобальными именами, определёнными в модуле: они разделяют между собой одно и тоже пространство имён<ref>Исключая одну тонкость. У объектов модулей есть скрытый, только для чтения, атрибут под именем <code>__dict__</code>, возвращающий словарь, использовавшийся для формирования пространства имён модуля; имя <code>__dict__</code> является атрибутом, но не глобальным именем. Очевидно, что всё это нарушает абстракцию реализации пространства имён и его использование следует ограничить вещами вроде посмертных отладчиков</ref>.
 
Запись в атрибуты может быть запрещена (''атрибут только для чтения'', <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>).
Строка 2691:
raise экземпляр</source>
 
В первой форме, ''<code>экземпляр</code>'' должен быть экземпляром ''<code>Класса</code>'', или класса, производного от него. Вторая форма является краткой записью следующего кода:
 
<source lang="python">raise экземпляр.__class__, экземпляр</source>