3. Неформальное введение в Python¶An Informal Introduction to Python

3.1.1. Числа¶Numbers

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

>>> 2+2
4
>>> # Это комментарий
... 2+2
4
>>> 2+2  # и комментарий в той же строке, что и код
4
>>> (50-5*6)/4
5.0
>>> 8/5 # Дробные части не теряются при делении целых чисел
1.6

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

Для целочисленного деления с получением целого результата (без дробной части) существует ещё один оператор //:

>>> # Целочисленное деление возвращает целую часть (пол):
... 7//3
2
>>> 7//-3
-3

Знак равенства ('=') используется для присваивания значения переменной. После этого результат не отображается до следующего интерактивного приглашения:

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

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

>>> x = y = z = 0  # Обнуление x, y и z
>>> x
0
>>> y
0
>>> z
0

Переменные должны быть «определены» (им присвоено значение) до использования, иначе возникнет ошибка:

>>> # попытка обращения к неопределённой переменной
... n
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

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

>>> 3 * 3.75 / 1.5
7.5
>>> 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 и z.imag.

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

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

>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)  # sqrt(a.real**2 + a.imag**2)
5.0

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

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

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

3.1.2. Строки¶Strings

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

>>> '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.'

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

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

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)

Обратите внимание, что символы новой строки всё равно нужно вставлять в строку с помощью \n – символ новой строки после завершающей обратной косой черты отбрасывается. Этот пример выведет следующее:

This is a rather long string containing
several lines of text just as you would do in C.
    Note that whitespace at the beginning of the line is significant.

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

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

Если сделать строковый литерал «сырым» (raw), последовательности \n не преобразуются в символы новой строки, но обратная косая черта в конце строки и символ новой строки в исходном коде включаются в строку как данные. Таким образом, пример:

hello = r"This is a rather long string containing\n\
several lines of text much as you would do in C."

print(hello)

выведет:

This is a rather long string containing\n\
several lines of text much as you would do in C.

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

>>> 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, in ?
    'str'.strip() 'ing'
                      ^
SyntaxError: invalid syntax

Строки можно индексировать (обращаться по индексу); как и в C, первый символ строки имеет индекс 0. Отдельного типа для символов нет; символ – это просто строка длины 1. Как и в языке программирования Icon, подстроки можно задавать с помощью нотации среза: два индекса, разделённые двоеточием.

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

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

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

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

>>> word[0] = 'x'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: 'str' object does not support item assignment
>>> word[:1] = 'Splat'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: 'str' object does not support slice assignment

Однако создать новую строку с объединённым содержимым легко и эффективно:

>>> 'x' + word[1:]
'xelpA'
>>> 'Splat' + word[4]
'SplatA'

Вот полезное инвариантное свойство операций со срезами: 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 (most recent call last):
  File "<stdin>", line 1, in ?
IndexError: string index out of range

Один из способов запомнить, как работают срезы – представлять индексы между символами, причём левый край первого символа имеет номер 0. Тогда правый край последнего символа строки из n символов имеет индекс n, например:

 +---+---+---+---+---+
 | 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

3.1.3. О Unicode¶About Unicode

Начиная с Python 3.0 все строки поддерживают Unicode (см. http://www.unicode.org/).

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

Если нужно включить в строку специальные символы, это можно сделать с помощью кодировки Unicode-Escape языка Python. Следующий пример показывает, как:

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

Последовательность экранирования \u0020 указывает на вставку символа Unicode с порядковым значением 0x0020 (символ пробела) в указанной позиции.

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

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

Для преобразования строки в последовательность байтов с использованием определённой кодировки строковые объекты предоставляют метод encode(), который принимает один аргумент – имя кодировки. Рекомендуется использовать строчные имена кодировок.

>>> "Äpfel".encode('utf-8')
b'\xc3\x84pfel'

3.1.4. Списки¶Lists

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

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

Как и индексы строк, индексы списков начинаются с 0, а списки можно срезать, объединять и так далее:

>>> 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] + ['Boo!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']

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

>>> 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]
>>> # Очистить список: заменить все элементы пустым списком
>>> a[:] = []
>>> a
[]

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

>>> a = ['a', 'b', 'c', 'd']
>>> len(a)
4

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

>>> 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']

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