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

В приведенных далее примерах, ввод и вывод различаются присутствием и отсутствием приглашений соответственно (приглашениями являются >>> и ...): чтобы воспроизвести пример — вам нужно ввести всё, что следует за приглашением, после его появления; строки, не начинающиеся с приглашений являются выводом интерпретатора. Обратите внимание, что строка, в которой содержится лишь вспомогательное приглашение («...») означает, что вам нужно ввести пустую строку — этот способ используется для завершения многострочных команд.

Большинство примеров в этом руководстве — даже те, которые вводятся в интерактивном режиме — содержат комментарии. Комментарии в Python начинаются с символа решетки # — и продолжаются до физического конца строки. Комментарии могут находиться как в начале строки, так и следовать за пробельными символами или кодом — но не содержаться внутри строки. Символ решётки в строке остаётся лишь символом решётки. Поскольку комментарии предназначены для того, чтобы сделать код более понятным, и не интерпретируются Python — при вводе примеров они могут быть опущены.

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

# это первый комментарий
spam = 1  # а это второй комментарий
          # ... а сейчас третий!
text = "# Это не комментарий, потому что он внутри кавычек."

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

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

Числа

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

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # деление всегда возвращает число с плавающей точкой
1.6

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

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

>>> 17 / 3  # классическое деление возвращает 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  # result * 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

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

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

В интерактивном режиме последнее распечатанное выражение присваивается переменной _. Это означает, что когда вы используете 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).

Строки

Помимо чисел, Python может работать со строками, которые, в свою очередь, могут быть описаны различными способами. Строки могут быть заключены в одинарные ('...') или двойные кавычки ("..."), без разницы [2]; \ может быть использован для экранирования кавычек:

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

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

>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print('"Isn\'t," she said.')
"Isn't," she said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s)  # with print(), \n produces a 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'

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

>>> prefix = 'Py'
>>> prefix 'thon'  # нельзя конкатенировать переменную и строковый литерал
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

Если вы хотите конкатенировать переменные или переменную или литерал, используйте +:

>>> prefix + 'thon'
'Python'

Эта функция особенно полезна, когда вы хотите разбить длинные строки:

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

К символам строки можно обращаться по индексу, первая буква имеет индекс нуль. Отдельного типа для символов нет; символ это просто строка размером 1:

>>> word = 'Python'
>>> word[0]  # символ с позицией 0
'P'
>>> word[5]  # символ с позицией 5
'n'

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

>>> word[-1]  # последний символ
'n'
>>> word[-2]  # предпоследний символ
'o'
>>> word[-6]
'P'

Заметьте, так как -0 это тоже 0, то негативные индексы начинаются с -1.

В дополнении к индексации, slicing/срезы также поддерживаются. В то время как индексация используется для получения отдельных символов, срез позволяет получить подстроку:

>>> word[0:2]  # символы с позициями от 0 (включительно) до 2 (не включая)
'Py'
>>> word[2:5]  # символы с позициями от 2 (включительно) до 5 (не включая)
'tho'

Заметьте, что начальный символ всегда включается, а конец — всегда исключается. Это гарантирует, что s[:i] + s[i:] всегда равно s:

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

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

>>> word[:2]   # символы с начала до позиции 2 (не включая)
'Py'
>>> word[4:]   # символы с позиции 4 (включительно) до конца
'on'
>>> word[-2:]  # символы с предпоследней позиции (включительно) до конца
'on'

Один из способов запомнить, как работают срезы — думать, что индексы указываются между символами, с левым краем первого символа, пронумерованным 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]  # в слове только 6 символов
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Однако, индексы срезов вне диапазона обрабатываются корректно при нарезании:

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

Python-строки не могут быть изменены — они являются immutable/иммутабельными. Поэтому присвоение по индексу строки приводит к ошибке:

>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
  ...
TypeError: 'str' object does not support item assignment

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

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

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

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

Смотрите также

Текстовый последовательный тип — str
Строки являются примерами последовательного типа, и поддерживают привычные для этих типов операции.
Строковые методы
Строки поддерживают большое количество методов для поиска и простых трансформаций.
Форматирование строковых литералов
Строковые литералы, имеющие встроенные выражения.
Синтаксис форматирования строк
Информация о форматировании строк с применением функции str.format()
printf-стиль форматирования строк
Старые операции форматирования, вызывающиеся тогда, когда обычные строки или строки в Unicode оказываются левым операндом относительно операции %, более детально рассмотрены здесь.

Списки

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

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

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

>>> squares[0]  # индексация возвращает элемент
1
>>> squares[-1]
25
>>> squares[-3:]  # срез возвращает новый список
[9, 16, 25]

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

>>> squares[:]
[1, 4, 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]  # что-то здесь не так
>>> 4 ** 3  # куб от 4 — 64, не 65!
64
>>> cubes[3] = 64  # заменить неправильное значение
>>> cubes
[1, 8, 27, 64, 125]

Вы также можете добавить новые элементы в конец списка, используя метод append() (позже мы узнаем больше о методах):

>>> cubes.append(216)  # добавить куб 6
>>> cubes.append(7 ** 3)  # и куб 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

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

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # заменить некоторые значения
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # теперь удалить их
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # очистить список заменой всех элементов пустым списком
>>> 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'

Первые шаги к программированию

Безусловно, Python можно использовать для более сложных задач, чем сложение двух чисел. Например, мы можем вывести начало последовательности чисел Фибоначчи таким образом:

>>> # последовательность Фибоначчи:
... # сумма двух элементов определяет следующий
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8

Этот пример показывает нам некоторые новые возможности.

  • Первая строка содержит множественное присваивание: переменные a и b параллельно получают новые значения — 0 и 1. В последней строке этот метод используется снова, демонстрируя тот факт, что выражения по правую сторону [от оператора присваивания] всегда вычисляются раньше каких бы то ни было присваиваний. Правая часть выражения оцениваются слева направо.

  • Цикл while (пока) исполняется до тех пор, пока условие (здесь: b < 10) остается истиной. В Python, также как и в C, любое ненулевое значение является истиной (True); ноль является ложью (False). Условием может быть строка, список или вообще любая последовательность; все, что имеет ненулевую длину, играет роль истины, пустые последовательности — лжи. Использованная в примере проверка — простое условие. Стандартные операции сравнения записываются так же, как и в C: < (меньше чем), > (больше чем), == (равно), <= (меньше или равно), >= (больше или равно) и != (не равно).

  • Тело цикла выделено отступом. Отступы — это средство группировки операторов в Python. В интерактивном режиме необходимо использовать табуляции или пробелы для отступа в каждой строке. На практике более сложный текст на Python готовится в текстовом редакторе, а большинство из них имеют функцию авто-отступа. По окончанию ввода составного выражения в интерактивном режиме, необходимо закончить его пустой строкой — признаком завершения (поскольку интерпретатор не может угадать, когда вами была введена последняя строка). Обратите внимание, что размер отступа в каждой строке основного блока должен быть одним и тем же.

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

    >>> i = 256*256
    >>> print('The value of i is', i)
    The value of i is 65536
    

    Для отключения перевода строки после вывода или завершения вывода другой строкой используется именованный параметр end:

    >>> a, b = 0, 1
    >>> while b < 1000:
    ...     print(b, end=',')
    ...     a, b = b, a+b
    ...
    1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
    

Сноски

[1]Так как ** имеет более высокий приоритет, чем -, то -3**2 будет интерпретирован как -(3**2) и поэтому приведет к -9. Чтобы избежать этого и получить 9, вы можете использовать (-3)**2.
[2]В отличие от других языков, специальные символы, такие как \n, имеют тот же смысл и с одинарными('...'), и с двойными ("...") кавычками. Единственная разница между ними — что внутри одинарных кавычек вам нужно экранировать " (но вам придется экранировать \'), и наоборот.