Неформальное введение в 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 также имеет встроенную поддержку для комплексных чисел, и использует суффикс
Строки
Помимо чисел, 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 , имеют тот же смысл и с одинарными('...' ), и с двойными ("..." ) кавычками.
Единственная разница между ними — что внутри одинарных кавычек вам нужно экранировать " (но вам придется экранировать \' ), и наоборот. |