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

3.1.1. Числа

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

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating-point number
1.6

Целые числа (например, 2, 4, 20) имеют тип int, а числа с дробной частью (например, 5.0, 1.6) имеют тип float. Позже в этом руководстве мы подробнее рассмотрим числовые типы.

Деление (/) всегда возвращает число с плавающей точкой. Для выполнения целочисленного деления с округлением вниз и получения целого результата можно использовать оператор //; для вычисления остатка можно использовать %:

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # floored quotient * divisor + remainder
17

В Python для вычисления степеней можно использовать оператор ** [1]:

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

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

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

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

>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

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

>>> 4 * 3.75 - 1
14.0

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

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

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

Помимо int и float, Python поддерживает и другие числовые типы, например Decimal и Fraction. В Python также есть встроенная поддержка комплексных чисел; для обозначения мнимой части используется суффикс j или J (например, 3+5j).

3.1.2. Текст

Python умеет обрабатывать текст (представленный типом str, так называемые «строки») так же, как и числа. Это могут быть символы «!», слова «rabbit», имена «Paris», предложения «Got your back.» и т. д. «Yay! :)». Строки можно заключать в одинарные ('...') или двойные кавычки ("..."); результат будет одинаковым [2].

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!"  # double quotes
'Paris rabbit got your back :)! Yay!'
>>> '1975'  # digits and numerals enclosed in quotes are also strings
'1975'

Чтобы заключить кавычку в кавычки, нужно её «экранировать», поставив перед ней \. В качестве альтернативы можно использовать кавычки другого типа:

>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

В оболочке Python определение строки и вывод этой строки могут выглядеть по-разному. Функция print() выводит более удобочитаемый результат: она опускает окружающие кавычки и выводит экранированные и специальные символы:

>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), special characters are included in the string
'First line.\nSecond line.'
>>> print(s)  # with print(), special characters are interpreted, so \n produces new line
First line.
Second line.

Если вы не хотите, чтобы символы, перед которыми стоит \, интерпретировались как специальные, можно использовать необработанные строки, добавив r перед первой кавычкой:

>>> print('C:\some\name')  # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name')  # note the r before the quote
C:\some\name

У необработанных строк есть одна тонкость: такая строка не может заканчиваться нечётным количеством символов \; дополнительную информацию и возможные решения см. в ответе на часто задаваемый вопрос.

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

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

>>>

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

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

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

>>> 'Py' 'thon'
'Python'

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

>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

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

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  File "<stdin>", line 1
    prefix 'thon'
           ^^^^^^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  File "<stdin>", line 1
    ('un' * 3) 'ium'
               ^^^^^
SyntaxError: invalid syntax

Для объединения переменных или переменной с литералом используйте +:

>>> prefix + 'thon'
'Python'

Строки можно индексировать (обращаться к элементам по индексу); индекс первого символа равен 0. Отдельного типа символов нет: символ — это просто строка длиной в один символ:

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

Индексы также могут быть отрицательными числами; в этом случае отсчёт ведётся справа:

>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

Обратите внимание: поскольку -0 равно 0, отрицательные индексы начинаются с -1.

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

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

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

>>> word[:2]   # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]   # characters from position 4 (included) to the end
'on'
>>> word[-2:]  # characters from the second-last (included) to the end
'on'

Обратите внимание: начальный индекс всегда включается, а конечный всегда исключается. Благодаря этому s[:i] + s[i:] всегда равно s:

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

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

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

В первой строке чисел указаны позиции индексов 0…6 в строке; во второй строке приведены соответствующие отрицательные индексы. Срез от i до j состоит из всех символов между границами с метками i и j соответственно.

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

Попытка использовать слишком большой индекс приведёт к ошибке:

>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

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

>>> word[4:42]
'on'
>>> word[42:]
''

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

>>> word[0] = 'J'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Если нужна другая строка, создайте новую:

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

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

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

3.1.3. Списки

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

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

Как и строки (и все остальные встроенные типы последовательностей), списки можно индексировать и нарезать:

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

Списки также поддерживают такие операции, как объединение:

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

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

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

Новые элементы также можно добавлять в конец списка с помощью метода list.append() (подробнее о методах мы поговорим позже):

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

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

>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> id(rgb) == id(rgba)  # they reference the same object
True
>>> rgba.append("Alph")
>>> rgb
["Red", "Green", "Blue", "Alph"]

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

>>> correct_rgba = rgba[:]
>>> correct_rgba[-1] = "Alpha"
>>> correct_rgba
["Red", "Green", "Blue", "Alpha"]
>>> rgba
["Red", "Green", "Blue", "Alph"]

Также можно присваивать значения срезам; это может даже изменить размер списка или полностью очистить его:

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

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

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

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

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'