Давайте опробуем несколько простых команд Python. Запустите интерпретатор и дождитесь появления основного приглашения - >>>. (Это не должно занять много времени.)
Числа
Поведение интерпретатора сходно поведению калькулятора: вы вводите выражение, а в ответ он выводит значение. Синтаксис выражений привычен: операции +, -, * и / работают также как и в большинстве других языков (например, Паскале или C); для группировки можно использовать скобки. Например:
>>> 2+2
4
>>> # Это комментарий
... 2+2
4
>>> 2+2 # а вот комментарий на одной строке с кодом
4
>>> (50-5*6)/4
5.0
>>> 8/5 # При делении целых чисел дробные части не теряются
1.6000000000000001
Заметьте: Вы можете получить результат, несколько отличный от представленного: результаты деления с плавающей запятой могут различаться на разных системах. Позже мы расскажем о том, как контролировать вывод чисел с плавающей запятой. Здесь использован наиболее информативный вариант вывода этого значения, а не более легко-читаемый, какой возможен:
>>> print(8/5)
1.6
Чтобы учебник читался легче, мы будем показывать упрощённый вывод чисел с плавающей точкой и объясним позже, почему эти два способа отображения чисел с плавающей точкой стали различными. Обратитесь к приложению Арифметика с плавающей точкой: Проблемы и ограничения, чтобы ознакомится с подробным обсуждением.
Для получения целого результата при делении целых чисел, отсекая дробные результаты, предназначена другая операция:
//:
>>> # Деление целых чисел возвращает округлённое к минимальному значение:
... 7//3
2
>>> 7//-3
-3
Знак равенства ('=') используется для присваивания переменной какого-либо значения. После этого действия в интерактивном режиме ничего не выводится:
>>> width = 20
>>> height = 5*9
>>> width * height
900
Значение может быть присвоено нескольким переменным одновременно:
>>> x = y = z = 0 # Нулевые x, y и z
>>> x
0
>>> y
0
>>> z
0
Переменные должны быть определены (defined) (должны иметь присвоенное значение) перед использованием, иначе будет сгенерирована ошибка:
>>> # попытка получить доступ к неопределённой переменной
... n
Traceback (most recent call last):
File "", line 1, in
NameError: name 'n' is not defined
Присутствует полная поддержка операций с плавающей точкой; операции над операндами смешанного типа конвертируют целочисленный операнд в число с плавающей запятой:
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5
Поддерживаются и комплексные числа, добавлением к мнимым частям суффикса j или J. Комплексные числа с ненулевым вещественным компонентом записываются в виде (<вещественная_часть>+<мнимая_часть>j), или могут быть созданы с помощью функции complex(<вещественная_часть>, <мнимая_часть>).
>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0, 1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)
Комплексные числа всегда представлены в виде двух чисел с плавающей запятой - вещественной и мнимой частями. Для получения этих частей из комплексного числа z используется z.real и z.imag соответственно.
>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5
Функции конвертации (приведения) к вещественным и целым числам (float(), int()) не работают с комплексными числами, так как нет единственно правильного способа сконвертировать комплексное число в вещественное. Используйте функцию abs(z) чтобы получить модуль числа (в виде числа с плавающей точкой) или z.real чтобы получить его вещественную часть:
>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
File "", line 1, in ?
TypeError: can't convert complex to float; use abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a) # sqrt(a.real**2 + a.imag**2)
5.0
>>>
В интерактивном режиме последнее выведенное выражение сохраняется в переменной _. Это значит, что если вы используете Python в качестве настольного калькулятора - всегда есть способ продолжить вычисления с меньшими усилиями, например:
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
>>>
Эта переменная для пользователя должна иметь статус только для чтения. Не навязывайте ей значение собственноручно - вы создадите независимую переменную с таким же именем, скрывающую встроенную переменную вместе с её магическими свойствами.
Строки
Помимо чисел, Python может работать со строками, которые, в свою очередь, могут быть описаны различными способами. Строки могут быть заключены в одинарные или двойные кавычки:
>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
Интерпретатор выводит результаты операций над строками тем же способом, каким они были введены: обрамлённые кавычках, и, кроме того, экранируя обратными слэшами внутренние кавычки и другие забавные символы - для того, чтобы отобразить точное значение. Строка заключается в двойные кавычки если строка содержит одинарную кавычку и ни одной двойной, иначе она заключается в одинарные кавычки. Повторимся, функция print() предоставляет более читаемый вывод.
Строковые литералы могут быть разнесены на несколько строк различными способами. Могут быть использованы продолжающие строки, с обратным слэшем в качестве последнего символа строки, сообщающим о том, что следующая строка есть продолжение текущей:
hello = "This is a rather long string containing\n\
several lines of text just as you would do in C.\n\
Note that whitespace at the beginning of the line is\
significant."
print(hello)
Обратите внимание, что новые строки все ещё нужно подключать в строку через \n; новая строка, за которой следут обратный слэш - не обрабатывается. Запуск примера выведет следующее:
This is a rather long string containing
several lines of text just as you would do in C.
Note that whitespace at the beginning of the line is significant.
Если мы объявим строковой литерал сырым (raw) - символы \n не будут конвертированы в новые строки, но и обратный слэш в конце строки, и символ новой строки в исходном коде - будут добавлены в строку в виде данных. Следовательно, код из примера:
hello = r"This is a rather long string containing\n\
several lines of text much as you would do in C."
print(hello)
выведет:
This is a rather long string containing\n\ several lines of text much as you would do in C.
Или, строки могут быть обрамлены совпадающей парой тройных кавычек: """ или '''. Окончания строк не нужно завершать тройными кавычками - при этом будут включены в строку.
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
Строки могут конкатенироваться (склеиваться вместе) операцией + и быть повторенными операцией *:
>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
''
Два строковых литерала, расположенные друг за другом, автоматически конкатенируются; первая строка в предыдущем примере также могла быть записана как word = 'Help' 'A'; это работает только с двумя литералами - не с произвольными выражениями, содержащими строки.
>>> 'str' 'ing' # <- Так - верно
'string'
>>> 'str'.strip() + 'ing' # <- Так - верно
'string'
>>> 'str'.strip() 'ing' # <- Так - не верно
File "", line 1, in ?
'str'.strip() 'ing'
^
SyntaxError: invalid syntax
Строки могут быть проиндексированы; также как и в C, первый символ строки имеет индекс 0. Отсутствует отдельный тип для символов; символ является строкой с единичной длиной. Как и в языке программирования Icon, подстроки могут определены через нотацию срезов (slice): два индекса, разделенных двоеточием.
>>> word[4]
'A'
>>> word[0:2]
'He'
>>> word[2:4]
'lp'
Индексы срезов имеют полезные значения по умолчанию; опущенный первый индекс заменяется нулём, опущенный второй индекс подменяется размером срезаемой строки.
>>> word[:2] # Первые два символа
'He'
>>> word[2:] # Всё, исключая первые два символа
'lpA'
В отличие от строк в C, строки Python не могут быть изменены. Присваивание по позиции индекса строки вызывает ошибку:
>>> word[0] = 'x'
Traceback (most recent call last):
File "", line 1, in ?
TypeError: 'str' object doesn't support item assignment
>>> word[:1] = 'Splat'
Traceback (most recent call last):
File "", line 1, in ?
TypeError: 'str' object doesn't support slice assignment
Тем не менее, создание новой строки со смешанным содержимым - процесс легкий и очевидный:
>>> 'x' + word[1:]
'xelpA'
>>> 'Splat' + word[4]
'SplatA'
Полезный инвариант операции среза: s[:i] + s[i:] эквивалентно s.
>>> word[:2] + word[2:]
'HelpA'
>>> word[:3] + word[3:]
'HelpA'
Вырождения индексов срезов обрабатываются элегантно: чересчур большой индекс заменяется на размер строки, а верхняя граница меньшая нижней возвращает пустую строку.
>>> word[1:100]
'elpA'
>>> word[10:]
''
>>> word[2:1]
''
Индексы могут быть отрицательными числами, обозначая при этом отсчет справа налево. Например:
>>> word[-1] # Последний символ
'A'
>>> word[-2] # Предпоследний символ
'p'
>>> word[-2:] # Последние два символа
'pA'
>>> word[:-2] # Всё, кроме последних двух символов
'Hel'
Но обратите внимание, что -0 действительно эквивалентен 0 - это не отсчет справа.
>>> word[-0] # (поскольку -0 равен 0)
'H'
Отрицательные индексы вне диапазона обрезаются, но не советуем делать это с одно-элементными индексами (не-срезами):
>>> word[-100:]
'HelpA'
>>> word[-10] # ошибка
Traceback (most recent call last):
File "", line 1, in ?
IndexError: string index out of range
Один из способов запомнить, как работают срезы - думать о них, как об указателях на места между символами, где левый край первого символа установлен в ноль, а правый край последнего символа строки из n символов имеет индекс n, например:
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
Первый ряд чисел дает позицию индексов строки от 0 до 5; второй ряд описывает соответствующие отрицательные индексы. Срез от i до j состоит из всех символов между правым и левым краями, отмеченными, соответственно, через i и j.
Для всех не-негативных индексов длина среза - разность между индексами, при условии что оба индекса находятся в диапазоне. Например, длина word[1:3] - 2.
Встроенная функция len() возвращает длину строки[10]:
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
О Unicode
Начиная с Python версии 3.0, строковый тип поддерживает только Unicode (см. http://www.unicode.org/).
Преимущество набора Unicode состоит в том, что он предоставляет порядковый номер для любого символа из любой письменности, использовавшейся в современных или древнейших текстах. До этих пор для символов в сценарии было доступно лишь 256 номеров. Тексты обычно привязывались к кодовой странице, которая устанавливала в соответствие порядковые номера и символы сценария. Это приводило к серьезной путанице, особенно в том, что касалось интернационализации[12] программного продукта. Unicode решает эти проблемы, определяя единую кодовую страницу для всех письменностей.
Для вставки в строку специального символа можно использовать Unicode-экранирование (Python Unicode-Escape encoding). Следующий пример всё пояснит:
>>> 'Hello\u0020World !'
'Hello World !'
Экранированная последовательность \u0020 задаёт символ Unicode с порядковым номером 0x0020 (символ пробела).
Другие символы интерпретируются с использованием соответствующих им порядковых значений тем же способом, что и порядковые номера Unicode. Первые 128 символов кодировки Unicode полностью совпадают с 128 символами кодировки Latin-1, использующейся во многих западных странах.
Помимо стандартных способов кодирования, Python предоставляет целый набор различных способов создания Unicode-строк, основываясь на известной кодировке.
Для конвертирования Unicode-строки в последовательность байтов с использованием желаемой кодировки, строковые объекты предоставляют метод encode(), принимающий единственный параметр - название кодировки. Предпочитаются названия кодировок, записанные в нижнем регистре.
>>>"Äpfel".encode('utf-8')
b'\xc3\x84pfel'
Списки
В языке Python доступно некоторое количество составных типов данных, использующихся для группировки прочих значений вместе. Наиболее гибкий из них - список (list). Его можно выразить в тексте программы через разделённые запятыми значения (элементы), заключённые в квадратные скобки. Элементы списка могут быть разных типов.
>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]
Подобно индексам в строках, индексы списков начинаются с нуля, списки могут быть срезаны, объединены (конкатенированы) и так далее:
>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boo!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']
В отличие от строк, являющихся неизменяемыми, изменить индивидуальные элементы списка вполне возможно:
>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]
Присваивание срезу также возможно, и это действие может даже изменить размер списка или полностью его очистить:
>>> # Заменим некоторые элементы:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Удалим немного:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Вставим пару:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> # Вставим (копию) самого себя в начало
>>> a[:0] = a
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]
>>> # Очистка списка: замена всех значений пустым списком
>>> a[:] = []
>>> a
[]
Встроенная функция len() также применима к спискам:
>>> a = ['a', 'b', 'c', 'd']
>>> len(a)
4
Вы можете встраивать списки (создавать списки, содержащие другие списки), например так:
>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
Вы можете добавить что-нибудь в конец списка.
>>> p[1].append('xtra')
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']
Обратите внимание, что в последнем примере p[1] и q на самом деле ссылаются на один и тот же объект! Мы вернёмся к семантике объектов позже.
Назад
Вперед
8 8 8
| |
*
Обратная связь