Неформальное введение в 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

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

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

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'