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
. Подробнее о числовых типах мы поговорим позже в этом руководстве.
Деление (/
) всегда возвращает значение с плавающей точкой. Чтобы выполнить 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'
Строки могут быть индексированными (подписанными), при этом первый символ имеет индекс 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 известно несколько типов данных compound, используемых для группировки других значений. Наиболее универсальным является list, который может быть записан как список значений (элементов), разделенных запятыми, в квадратных скобках. Списки могут содержать элементы разных типов, но обычно все элементы имеют один и тот же тип.
>>> 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"]
Все операции с фрагментами возвращают новый список, содержащий запрошенные элементы. Это означает, что следующий фрагмент возвращает 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, любое ненулевое целое значение равно 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 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,
Сноски