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

🕛 11.07.2009, 13:11

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

Многие примеры в книге, даже если они вводятся в интерактивном режиме, снабжены комментариями. Комментарии в языке Python начинаются с символа '#' и продолжаются до конца строки. Комментарий может начинаться в начале строки или после кода, но не внутри строковых выражений. Символ '#' в строковом выражении является всего лишь символом '#'.

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

# это первый комментарий
SPAM = 1 # а это второй # ... и, наконец, третий!
STRING = "# Это не комментарий."

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

Давайте испробуем несколько простых команд Python. Запустите интерпретатор и дождитесь появления первичного приглашения '>>> ' (это не должно занять много времени.)
3.1.1. Числа

Интерпретатор работает как простой калькулятор: Вы можете набрать выражение, и он выведет результат. Синтаксис выражений прост: операторы +, -, * и / работают, как и в большинстве других языков (например, в Pascal и C). Для группирования можно использовать скобки. Например:

>>> 2+2
4
>>> # Это комментарий
... 2+2
4
>>> 2+2 # Комментарий в той же строке, что и код
4
>>> (50-5*6)/4
5
>>> # При целочисленном делении результат округляется в
... # меньшую сторону:
... 7/3
2
>>> 7/-3
-3

Подобно С, знак равенства ('=') используется для присваивания значения переменной. Присвоенное значение при этом не выводится:

>>> width = 20
>>> height = 5*9
>>> width * height
900

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

>>> x = y = z = 0 # Переменным x, y и z присваивается 0
>>> x
0
>>> y
0
>>> z
0

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

>>> 4 * 2.5 / 3.3
3.0303030303030303
>>> 7.0 / 2
3.5

Также поддерживаются и комплексные числа. Мнимая часть записывается с суффиксом 'j' или 'J'. Комплексные числа записываются как '(real+imagj)' или могут быть созданы функцией 'complex(real, imag)'.

>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)

Комплексные числа представляются двумя числами с плавающей точкой - действительной и мнимой частью. Чтобы извлечь эти части из комплексного числа z, используйте z.real and z.imag.

>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5

Функции преобразования к целому числу и числу с плавающей точкой (int(), long() и float()) не работают для комплексных чисел - такое преобразование неоднозначно. Используйте abs(z) для получения абсолютного значения и z.real для получения вещественной части.

>>> a=1.5+0.5j
>>> float(a)
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use e.g.
abs(z)
>>> a.real
1.5
>>> abs(a)
1.5811388300841898

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

>>> tax = 17.5 / 100
>>> price = 3.50
>>> price * tax
0.61249999999999993
>>> price + _
4.1124999999999998
>>> print round(_, 2)
4.11

Пользователь должен обращаться с ней как с переменной, доступной только для чтения. Не присваивайте ей значение явно - Вы создадите независимую локальную переменную с таким же именем, сделав встроенную переменную недоступной.
3.1.2. Строки

Кроме чисел, Python также может работать со строками (string), которые могут быть записаны различными путями. В настоящее время Python считает печатными 7-битное подмножество символов. Представление же остальных символов выводится с использованием управляющих последовательностей, что делает работу в интерактивном режиме, например, с русским языком неудобной. По этой причине текст в некоторых примерах данной книги оставлен без перевода. Они могут быть заключены в одинарные или двойные кавычки:

>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

Длинные строковые выражения могут быть разбиты различными способами на несколько строк. Символ новой строки может быть "спрятан" с помощью обратной косой черты ('\'), например:

hello = "Это длинное строковое выражение, содержащее\n\
несколько строк текста, как Вы бы это сделали в C.\n\ Обратите внимание, что пробелы в\ начале строки\nимеют значение.\n"
print hello

Результат будет следующим:

Это длинное строковое выражение, содержащее
несколько строк текста, как Вы бы это сделали в C. Обратите внимание, что пробелы в начале строки
имеют значение.

По-другому, текст может быть заключен в утроенные кавычки: """ или '''. Концы строк не нужно "прятать" при использовании утроенных кавычек, но они будут включены в текст.

print """
Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to
"""

выведет следующее:

Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to

Интерпретатор выводит результат строковых операций в том же виде, в котором они могли бы быть набраны: в кавычках, обходя кавычки и другие специальные символы с помощью управляющих последовательностей, начинающихся с обратной косой черты ('\'). Текст заключается в двойные кавычки, если он не содержит двойные кавычки, во всех остальных случаях, он выводится в одинарных кавычках. Инструкция print, описанная ниже, может быть использована для вывода текста без кавычек и специальных последовательностей.

Существует также "необрабатываемый" режим ввода строк, задаваемый с помощью буквы 'r' или 'R' перед кавычками: в этом случае символ обратной косой черты также может быть использован для маскировки символов одинарной и двойной кавычек, если им предшествует нечетное число символов обратной косой черты, однако сам символ обратной косой черты остается частью строки. Даже в таком режиме строка не может заканчиваться нечетным количеством символов обратной косой черты. Необрабатываемый режим наиболее полезен в тех случаях, когда необходимо вводить значительное количество символов обратной косой черты, например, в регулярных выражениях.

Строки можно объединить (склеить) с помощью оператора + и размножить оператором *:

>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'

Две строки, записанные друг за другом, автоматически объединяются. Первая строка в приведенном примере может быть также записана как 'word = 'Help' 'A''. Такой метод работает только для строк записанных непосредственно, но не для произвольных строковых выражений.

>>> 'str' 'ing' # Правильно
'string'
>>> 'str'.strip() + 'ing' # Правильно
'string'
>>> 'str'.strip() 'ing' # Ошибка File "<stdin>", line 1 'str'.strip() 'ing' ^
SyntaxError: invalid syntax

Строка - последовательность символов с произвольным доступом, Вы можете получить любой символ строки по его индексу. Подобно C, первый символ имеет индекс 0. Нет отдельного типа для символа, символ - это просто строка единичной длины. Подобно Icon, подстрока может быть определена с помощью среза - двух индексов, разделенных двоеточием.

>>> word[4]
'A'
>>> word[0:2]
'He'
>>> word[2:4]
'lp'

Строки в языке Python невозможно изменить. Попытка изменить символ в определенной позиции или подстроку вызовет ошибку:

>>> word[0] = 'x'
Traceback (innermost last): File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
>>> word[:-1] = 'Splat'
Traceback (innermost last): File "<stdin>", line 1, in ?
TypeError: object doesn't support slice assignment

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

>>> word[:2] # Первые два символа
'He'
>>> word[2:] # Вся строка, кроме первых двух символов
'lpA'

Полезный инвариант операции среза: s[:i] + s[i:] равно s.

>>> word[:2] + word[2:]
'HelpA'
>>> word[:3] + word[3:]
'HelpA'

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

>>> word[1:100]
'elpA'
>>> word[10:]
''
>>> word[2:1]
''

Индексы могут иметь отрицательные значения, для отсчета с конца:

>>> word[-1] # Последний символ
'A'
>>> word[-2] # Преджпоследний символ
'p'
>>> word[-2:] # Последние два символа
'pA'
>>> word[:-2] # Кроме последних двух символов
'Hel'

Однако -0 обозначает то же самое, что и 0, то есть не будет отсчитываться с конца.

>>> word[-0] # (так как -0 равен 0)
'H'

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

>>> word[-100:]
'HelpA'
>>> word[-10] # Ошибка
Traceback (innermost last): File "<stdin>", line 1
IndexError: string index out of range

Лучший способ запомнить, как определяются индексы в срезе - считать их указывающими между символами, с номером 0 на левой границе первого символа. А правая граница последнего символа имеет индекс равный длине строки, например:
H e l p A 0 1 2 3 4 5
-5 -4 -3 -2 -1

Первая строка чисел показывает позиции в строке, на которые указывают индексы от 0 до 5, вторая - соответствующие отрицательные индексы. Срез от i до j включает в себя все символы между краями, помеченными i и j, соответственно.

Для неотрицательных индексов длина подстроки равняется разности индексов, если они оба не выходят за пределы диапазона, например, длина подстроки word[1:3] равна 2.

Встроенная функция len() возвращает длину строки:

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
Строки Unicode

Начиная с версии 1.6, в языке Python доступен новый тип данных для хранения текста - строка Unicode. Его можно использовать для работы с текстом, содержащим одновременно буквы и символы нескольких языков, доступных в Unicode (см. http://www.unicode.org). Строки Unicode полностью интегрируется с обычными строками, автоматически производя, где это необходимо, преобразование.

Unicode имеет значительное преимущество - предоставляет возможность использовать все символы, используемые в современных и древних текстах. Ранее мы могли использовать только 256 символов из определенной кодовой страницы, что приводило к большим затруднениям, особенно при интернационализации (internationalization, обычно записывается как i18n - i + 18 символов + n) программного обеспечения. Unicode решает эту проблему, определяя одну кодовую страницу для всех символов.

Создаются строки Unicode настолько же просто, как и обычные строки:

>>> u'Hello World !'
u'Hello World !'

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

>>> u'Hello\u0020World !'
u'Hello World !'

Управляющая последовательность \u0020 указывает, что необходимо вставить Unicode символ с порядковым номером в шестнадцатеричной системе исчисления 0x0020 (пробел).

Благодаря тому, что первые 256 символов Unicode те же, что и в стандартной кодировке Latin-1, ввод текста на большинстве языков, используемых в западных странах, сильно упрощается.

Как и для обычных строк, для строк Unicode существует "необрабатываемый" режим, задаваемый с помощью буквы 'r' или 'R' перед кавычками. Управляющими считаются только последовательности, которые применяются для обозначения символов Unicode, и только если используется нечетное количество символов обратной косой черты перед буквой 'u':

>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'

Кроме описанного выше метода, Python предоставляет возможность создать строку Unicode на основе строки в известной кодировке. Встроенная функция unicode() может работать с Latin-1, ASCII, UTF-8, UTF-16, с русскими кодировками ISO-8859-5, KOI8-R, CP1251, CP866 и Mac-cyrillic, и многими другими. Python по умолчанию использует кодировку ASCII (ASCII является общей частью для подавляющего большинства кодировок. Вы можете изменить кодировку по умолчанию с помощью функции sys.set_string_encoding(). Однако лучше все же указывать ее явно.), например, при выводе на экран инструкцией print и записи в файл. Если у Вас есть данные в определенной кодировке, для получения строки Unicode используйте встроенную функцию unicode(), указав кодировку в качестве второго аргумента:

>>> s = unicode("Привет", "KOI8-R")
>>> s
u'\u041F\u0440\u0438\u0432\u0435\u0442'

Если строка Unicode содержит символы с кодом больше 127, преобразование в ASCII не возможно:

>>> str(s)
Traceback (most recent call last): File "<stdin>", line 1, in ?
UnicodeError: ASCII encoding error: ordinal not in
range(128)

Метод encode() позволяет преобразовывать строки Unicode в обычные строки, содержащие текст в указанной кодировке:

>>> s.encode("KOI8-R")
'\360\322\311\327\305\324'
>>> s.encode("UTF-8")
'\320\237\321\200\320\270\320\262\320\265\321\202'

Списки

В Python имеется несколько типов данных, используемых для группирования вместе нескольких значений. Самым гибким является список (list), который может быть записан в виде списка значений (элементов), разделенных запятыми, заключенного в квадратные скобки. Совсем не обязательно, чтобы элементы списка были одного типа.

>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]

Как и для строк, для списков нумерация индексов начинается с нуля. Для списка можно получить срез, объединить несколько списков и так далее:

>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boe!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam',
'eggs', 100, 'Boe!']

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

>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]

Присваивание срезу также возможно, и это может привести к изменению размера списка:

>>> # Заменить несколько элементов:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # удалить:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Вставить:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> # Вставить копию самого себя в начало:
>>> a[:0] = a
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy',
1234]

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

>>> len(a)
8

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

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra')
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']

Как Вы уже, наверное, догадались, метод append() добавляет элемент в конец списка. Заметьте, что p[1] и q на самом деле ссылаются на один и тот же объект!