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

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

Вы можете переключить отображение подсказок и вывода, нажав на кнопку >>> в правом верхнем углу окна с примером. Если вы скроете подсказки и вывод для примера, то сможете легко скопировать и вставить строки ввода в интерпретатор.

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

Некоторые примеры:

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

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

Давайте попробуем выполнить несколько простых команд 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. Подробнее о числовых типах мы поговорим позже.

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

>>> 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 также имеет встроенную поддержку complex numbers и использует суффикс 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

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

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

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'

Строки могут быть индексированными (subscripted), при этом первый символ имеет индекс 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 не могут быть изменены - они immutable. Поэтому присвоение индексированной позиции в строке приводит к ошибке:

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

См.также

Тип текстовой последовательности — str

Строки являются примерами типов последовательностей и поддерживают общие операции, поддерживаемые такими типами.

Строковые методы

Строки поддерживают большое количество методов для базовых преобразований и поиска.

f-струны

Строковые литералы, содержащие встроенные выражения.

Синтаксис строки форматирования

Информация о форматировании строк с помощью str.format().

Форматирование строк в стиле printf

Старые операции форматирования, вызываемые, когда строки являются левым операндом оператора %, более подробно описаны здесь.

3.1.3. Списки

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

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

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

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

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

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

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

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

3.2. Первые шаги на пути к программированию

Конечно, мы можем использовать Python и для более сложных задач, чем сложение двух и двух вместе. Например, мы можем записать начальную подпоследовательность Fibonacci series следующим образом:

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while a < 10:
...     print(a)
...     a, b = b, a+b
...
0
1
1
2
3
5
8

В этом примере представлено несколько новых функций.

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

  • Цикл while выполняется до тех пор, пока условие (здесь: a < 10) остается истинным. В Python, как и в C, любое ненулевое целое значение является истинным; ноль - ложь. Условие также может быть строкой или списком, фактически любой последовательностью; все, что имеет ненулевую длину, является истинным, пустые последовательности - ложными. Тест, используемый в примере, представляет собой простое сравнение. Стандартные операторы сравнения записываются так же, как и в 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 a < 1000:
...     print(a, end=',')
...     a, b = b, a+b
...
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Сноски