После того как вы установите рабочую копию Python 3, можете использовать ее, чтобы запускать как программы, приведенные в этой книге, так и собственный код. Как же запустить программу, написанную на языке Python? Существует два основных способа.

• Интерактивный интерпретатор, который поставляется вместе с Python, дает возможность экспериментировать с небольшими программами. Вы вводите команды строка за строкой и мгновенно видите результат. Благодаря тесному связыванию между печатанием и просмотром можете проводить эксперименты быстрее. Я буду использовать интерактивный интерпретатор, чтобы продемонстрировать возможности языка, а вы можете вводить те же команды в собственной среде Python.

• Для всего прочего сохраняйте программы в виде текстовых файлов с расширением. py, а затем запускайте их, введя python и имена этих файлов.

Попробуем воспользоваться обоими методами.

Для большинства примеров кода в этой книге используется интерактивный интерпретатор. Когда вы вводите команды, которые видите в примерах, и получаете те же результаты, вы знаете, что идете по правильному пути.

Интерпретатор запускается путем ввода имени основной программы Python для вашего компьютера: python, python3 или чего-то похожего. В дальнейшем мы будем предполагать, что она называется python. Если ваша программа называется по-другому, то для ее запуска вам следует ввести именно это имя.

Интерактивный интерпретатор работает практически так же, как и интерпретатор для файлов, но с одним исключением: когда вы вводите обычное значение, интерактивный интерпретатор автоматически выведет его на экран. Например, если вы запустите Python и введете в интерпретатор число 61, оно будет продублировано в терминале.

Если вы запишете в файл число 61 и запустите этот файл с помощью Python, он выполнится, но на экране ничего не появится. В обычных неинтерактивных программах для Python вам нужно вызвать функцию print, чтобы вывести что-то на экран, как показано в следующем фрагменте кода:

print(61)

Создадим файл программы Python и запустим его.

1. Откройте текстовый редактор.

2. Введите в него строку print(61), как показано ранее.

3. Сохраните этот файл с именем 61.py. Убедитесь, что вы сохранили его как простой текст, а не в формате вроде RTF или DOC. Вы не обязаны использовать расширение. py для файлов программ Python, но оно поможет вам запомнить предназначение файла.

4. Если вы пользуетесь графическим пользовательским интерфейсом — это касается практически каждого, — откройте окно терминала[1].

5. Запустите программу, введя следующую строку:

$ python 61.py

Вы должны увидеть такую строку:

61

Сработало? Если да, то примите мои поздравления по поводу того, что вы запустили свою первую автономную программу для Python.

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

Самый простой способ разработки программы на Python — применение простого текстового редактора и окна терминала. В рамках этой книги я использую именно такие редакторы, иногда показывая интерактивные сессии работы с терминалом, а иногда — фрагменты файлов. Вам следует знать, что существует множество интегрированных сред разработки (Integrated Development Environment, IDE) для Python. Они могут предоставлять вам графические пользовательские интерфейсы, помогающие в редактировании текста, и экраны помощи. Более подробно вы прочитаете о них в главе 12.

Python имеет встроенную поддержку целых чисел (наподобие 5 и 1 000 000 000) и чисел с плавающей точкой (вроде 3,1416, 14,99 и 1,87е4). Вы можете вычислять комбинации чисел с помощью простых математических операторов, приведенных в таблице.

На нескольких следующих страницах я покажу вам простые примеры того, как Python можно использовать в качестве очень сложного калькулятора.

Любая последовательность цифр в Python считается целым числом:

>>> 5

5

Можно использовать и простой ноль (0):

>>> 0

0

Но не ставьте его перед другими цифрами:

>>> 05

··File "<stdin>", line 1

····05

·····^

SyntaxError: invalid token

Рассмотрим, что получится, если ввести следующее:

>>> 2 + 3 * 4

Если выполнить сложение первым, 2 + 3 равно 5, а 5 * 4 равно 20. Но если выполнить первым умножение, 3 * 4 равно 12, а 2 + 12 равно 14. В Python, как и в большинстве других языков, умножение имеет больший приоритет, нежели сложение, поэтому вы увидите ответ, совпадающий со второй версией:

>>> 2 + 3 * 4

14

Как узнать приоритет той или иной операции? В приложении Е приводится огромная таблица, в которой перечислены все приоритеты, но я обнаружил, что на практике никогда не смотрю в эти правила. Гораздо проще добавить пару скобок, чтобы сгруппировать код и вычисления так, как нужно:

>>> 2 + (3 * 4)

14

Это поможет любому человеку, читающему код, точно определить его предназначение.

Предполагается, что целые числа указываются в десятичной системе счисления, если только вы не укажете какую-либо другую. Вам может никогда не понадобиться использовать другие системы счисления, но иногда они будут встречаться в коде.

Как правило, у нас десять пальцев на руках и ногах (у одного из моих котов их немного больше, но он редко использует их для счета), поэтому мы считаем: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. После этого у нас заканчиваются цифры и мы переносим единицу на место десятки и ноль — на место единицы: 10 означает «одна десятка и ноль единиц». У нас нет одной цифры, которая представляла бы собой 10. Далее мы считаем: 11, 12… 19, переносим единицу, чтобы сделать 20 (две десятки и ноль единиц), и т. д.

Система счисления указывает, сколько цифр вы можете использовать до того, как перенести единицу. В двоичной (бинарной) системе счисления единственными цифрами являются 0 и 1. Двоичные 0 и 1 точно такие же, как и десятичные. Однако, если в этой системе сложить 1 и 1, вы получите 10 (одна десятичная двойка плюс ноль десятичных единиц).

В Python вы можете выразить числа в трех системах счисления помимо десятичной:

• 0b или 0B для двоичной системы (основание 2);

• 0o или 0O для восьмеричной системы (основание 8);

• 0x или 0X для шестнадцатеричной системы (основание 16).

Интерпретатор выведет эти числа как десятичные. Попробуем воспользоваться каждой из систем счисления. Первой выберем старое доброе десятичное число 10, которое означает «одна десятка и ноль единиц»:

>>> 10

10

Теперь возьмем двоичную (основание 2), что означает «одна (десятичная) двойка и ноль единиц»:

>>> 0b10

2

Восьмеричная (основание 8) означает «одна (десятичная) восьмерка и ноль единиц»:

>>> 0°10

8

Шестнадцатеричная (основание 16) означает «одна (десятичное) 16 и ноль единиц»:

>>> 0x10

16

Если вам интересно, какие «цифры» использует шестнадцатеричная система счисления, взгляните на них: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e и f. 0ха равно десятичной 10, а 0xf — десятичному 15. Добавьте 1 к 0xf, и вы получите 0х10 (десятичное 16).

Зачем использовать другие системы счисления, отличные от десятичной? Это полезно для битовых операций, которые описаны в главе 7 наряду с детальной информацией о преобразовании чисел из одной системы счисления в другую.

Для того чтобы изменить другие типы данных на целочисленный тип, следует использовать функцию int(). Она сохраняет целую часть числа и отбрасывает любой остаток.

Простейший тип данных в Python — булевы переменные, значениями этого типа могут быть только True или False. При преобразовании в целые числа они представляют собой значения 1 и 0:

>>> int(True)

1

>>> int(False)

0

Преобразование числа с плавающей точкой в целое число просто отсекает все, что находится после десятичной запятой[2]:

>>> int(98.6)

98

>>> int(1.0e4)

10000

Наконец, рассмотрим пример преобразования текстовой строки (со строками вы познакомитесь через несколько страниц), которая содержит только цифры и, возможно, знаки + и —:

>>> int('99')

99

>>> int('-23')

-23

>>> int('+12')

12

Преобразование целого числа в целое число ничего не меняет и совсем не вредит:

>>> int(12345)

12345

Если вы попробуете преобразовать что-то непохожее на число, сгенерируется исключение:

>>> int('99 bottles of beer on the wall')

Traceback (most recent call last):

··File "<stdin>", line 1, in <module>

ValueError: invalid literal for int() with base 10: '99 bottles of beer on the wall'

>>> int('')

Traceback (most recent call last):

··File "<stdin>", line 1, in <module>

ValueError: invalid literal for int() with base 10: ''

Текстовая строка в предыдущем примере начинается с корректных символов-цифр (99), но продолжается теми символами, которые функция int() обработать не может.

В Python 2 размер переменной типа int был ограничен 32 битами. Этого было достаточно для того, чтобы сохранить любое целое число в диапазоне от –2 147 483 648 до 2 147 483 647.

Для переменных типа long выделялось еще больше места — 64 бита, что позволяло хранить значения в диапазоне от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807. В Python 3 тип long отсутствует, а переменная типа int может быть любого размера — даже больше 64 бит. Поэтому вы можете выполнить арифметические действия наподобие следующих (10**100 называется гугол (googol), компания Google называлась так до того, как решила сменить свое название на более простое):

>>>

>>> googol = 10**100

>>> googol

100000000000000000000000000000000000000000000000000000000000000000000000000000

00000000000000000000000

>>> googol * googol

100000000000000000000000000000000000000000000000000000000000000000000000000000

000000000000000000000000000000000000000000000000000000000000000000000000000000

000000000000000000000000000000000000000000000

Во многих языках программирования этот пример вызовет так называемое переполнение целочисленного значения, когда числу нужно больше места, чем компьютер может предоставить, что приведет к разным нежелательным эффектам. Python обрабатывает огромные целые числа без всяких проблем. Одно очко для Python.

Значениями целочисленного типа являются целые числа, но числа с плавающей точкой (в Python они называются float) имеют десятичную запятую. Числа с плавающей точкой обрабатываются так же, как и целые: вы можете использовать операторы +, —, *, /, //, **, % и функцию divmod().

Для того чтобы преобразовать другие типы в тип float, следует использовать функцию float(). Как и ранее, булевы значения обрабатываются как небольшие числа:

>>> float(True)

1.0

>>> float(False)

0.0

Преобразование значения типа int в тип float лишь создаст счастливого обладателя десятичной запятой:

>>> float(98)

98.0

>>> float('99')

99.0

Вы также можете преобразовывать строки, содержащие символы, которые являются корректным числом с плавающей точкой (цифры, знаки, десятичная запятая или е, за которой следует экспонента):

>>> float('98.6')

98.6

>>> float('-1.5')

-1.5

>>> float('1.0e4')

10000.0

Python имеет привычный набор математических функций вроде квадратного корня, косинуса и т. д. Мы рассмотрим их в приложении В, где также обсудим применение Python в науке.

Непрограммисты думают, что программисты хорошо разбираются в математике, потому что работают с числами. На самом деле большинство программистов работают с текстовыми строками гораздо чаще, чем с числами. Логическое (и креативное!) мышление для них зачастую гораздо важнее математических навыков.

Благодаря поддержке стандарта Unicode Python 3 может содержать символы любого языка мира, а также многие другие символы. Необходимость работы с этим стандартом была одной из причин изменения Python 2. Это хорошая причина использовать версию 3. Я буду применять стандарт Unicode лишь иногда, поскольку это может показаться сложным. В следующих примерах я буду использовать строки формата ASCII.

Строки являются первым примером последовательностей в Python. В частности, они представляют собой последовательности символов.

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

Скоро вы узнаете, как это делается.

Строка в Python создается заключением символов в одинарные или двойные кавычки, как показано в следующем примере:

>>> 'Snap'

'Snap'

>>> "Crackle"

'Crackle'

Интерактивный интерпретатор выводит на экран строки в одинарных кавычках, но все они обрабатываются одинаково.

Зачем иметь два вида кавычек? Основная идея заключается в том, что вы можете создавать строки, содержащие кавычки. Внутри одинарных кавычек можно расположить двойные и наоборот:

>>> "'Nay,' said the naysayer."

"'Nay,' said the naysayer."

>>> 'The rare double quote in captivity: ".'

'The rare double quote in captivity: ".'

>>> 'A "two by four" is actually 1 1/2" × 3 1/2".'

'A "two by four is" actually 1 1/2" × 3 1/2".'

>>> "'There's the man that shot my paw!' cried the limping hound."

"'There's the man that shot my paw!' cried the limping hound."

Можно также использовать три одинарные (''') или три двойные кавычки ("""):

>>> '''Boom!'''

'Boom'

>>> """Eek!"""

'Eek!'

Тройные кавычки не очень полезны для таких коротких строк. Они обычно используются для того, чтобы создать многострочные строки, наподобие следующего классического стихотворения Эдварда Леара (Edward Lear):

>>> poem =··'''There was a Young Lady of Norway,

… Who casually sat in a doorway;

… When the door squeezed her flat,

… She exclaimed, "What of that?"

… This courageous Young Lady of Norway.'''

>>>

(Это стихотворение было введено в интерактивный интерпретатор, который поприветствовал нас символами >>> в первой строке и выводил символы … до тех пор, пока мы не ввели последние тройные кавычки и не перешли к следующей строке.)

Если бы вы попробовали создать стихотворение с помощью одинарных кавычек, Python начал бы волноваться, когда бы вы перешли к следующей строке:

>>> poem = 'There was a young lady of Norway,

··File "<stdin>", line 1

····poem = 'There was a young lady of Norway,

············································^

SyntaxError: EOL while scanning string literal

>>>

Если внутри тройных кавычек располагается несколько строк, символы конца строки будут сохранены внутри нее. Если перед строкой или после нее находятся пробелы, они также будут сохранены:

>>> poem2 = '''I do not like thee, Doctor Fell.

…·····The reason why, I cannot tell.

…·····But this I know, and know full well:

…·····I do not like thee, Doctor Fell.

… '''

>>> print(poem2)

I do not like thee, Doctor Fell.

····The reason why, I cannot tell.

····But this I know, and know full well:

····I do not like thee, Doctor Fell.

>>>

Кстати, существует разница между выводом на экран с помощью функции print() и автоматическим выводом на экран с помощью интерактивного интерпретатора:

>>> poem2

'I do not like thee, Doctor Fell.\n····The reason why, I cannot tell.\n····But

this I know, and know full well: \n····I do not like thee, Doctor Fell.\n'

Функция print() извлекает кавычки из строк и выводит на экран их содержимое. Она предназначена для удобства пользователя. Эта функция любезно добавляет пробел между каждым выводимым объектом, а также символ новой строки в конце:

>>> print(99, 'bottles', 'would be enough.')

99 bottles would be enough.

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

Интерпретатор выводит строку с одинарными кавычками и управляющими символами вроде \n, что объясняется в подразделе «Создаем управляющие символы с помощью символа \» далее в текущем разделе.

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

>>> ''

''

>>> ""

''

>>> ''''''

''

>>> """"""

''

>>>

Зачем может понадобиться пустая строка? Иногда приходится компоновать строку из других строк и для этого нужно начать с чистого листа, то есть с пустой строки.

>>> bottles = 99

>>> base = ''

>>> base += 'current inventory: '

>>> base += str(bottles)

>>> base

'current inventory: 99'

Вы можете преобразовывать другие типы данных Python в строки с помощью функции str():

>>> str(98.6)

'98.6'

>>> str(1.0e4)

'10000.0'

>>> str(True)

'True'

В Python функция str() также используется для внутренних нужд, когда вы вызываете функцию print() для объектов, которые не являются строками, и при выполнении интерполяции строк, с которой вы познакомитесь в главе 7.

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

>>> palindrome = 'A man,\nA plan,\nA canal: \nPanama.'

>>> print(palindrome)

A man,

A plan,

A canal:

Panama.

Вы также увидите последовательность \t (табуляция), которая используется для выравнивания текста:

>>> print('\tabc')

····abc

>>> print('a\tbc')

a····bc

>>> print('ab\tc')

ab······c

>>> print('abc\t')

abc

В последней строке табуляция стоит в конце, ее вы, конечно, увидеть не можете.

Кроме того, вам могут понадобиться последовательности \' или \", чтобы поместить в строку одинарные или двойные кавычки, которые окружены таким же символом:

>>> print('\tabc')

····abc

>>> print('a\tbc')

a····bc

>>> print('ab\tc')

ab······c

>>> print('abc\t')

abc

А если вам нужен обратный слеш, просто напечатайте два:

>>> speech = 'Today we honor our friend, the backslash: \\.'

>>> print(speech)

Today we honor our friend, the backslash: \.

Вы можете объединить строки или строковые переменные в Python с помощью оператора +, как показано далее:

>>> 'Release the kraken! ' + 'At once!'

'Release the kraken! At once!'

Можно также объединять строки (не переменные), просто расположив одну перед другой:

>>> "My word! " "A gentleman caller!"

'My word! A gentleman caller!'

Python не добавляет пробелы за вас при конкатенации строк, поэтому в предыдущем примере нужно явно добавить пробелы. Далее мы добавляем пробелы между каждым аргументом выражения print(), а также символ новой строки в конце:

>>> a = 'Duck.'

>>> b = a

>>> c = 'Grey Duck!'

>>> a + b + c

'Duck.Duck.Grey Duck!'

Оператор * можно использовать для того, чтобы размножить строку. Попробуйте ввести в интерактивный интерпретатор следующие строки и посмотреть, что получится:

>>> start = 'Na ' * 4 + '\n'

>>> middle = 'Hey ' * 3 + '\n'

>>> end = 'Goodbye.'

>>> print(start + start + middle + end)

Для того чтобы получить один символ строки, задайте смещение внутри квадратных скобок после имени строки. Смещение первого (крайнего слева) символа равно 0, следующего — 1 и т. д. Смещение последнего (крайнего справа) символа может быть выражено как –1, поэтому вам не придется считать, в таком случае смещение последующих символов будет равно –2, –3 и т. д.:

>>> letters = 'abcdefghijklmnopqrstuvwxyz'

>>> letters[0]

'a'

>>> letters[1]

'b'

>>> letters[-1]

'z'

>>> letters[-2]

'y'

>>> letters[25]

'z'

>>> letters[5]

'f'

Если вы укажете смещение, равное длине строки или больше (помните, смещения лежат в диапазоне от 0 до длины строки –1), сгенерируется исключение:

>>> letters[100]

Traceback (most recent call last):

··File "<stdin>", line 1, in <module>

IndexError: string index out of range

Индексирование работает и для других типов последовательностей (списков и кортежей), которые мы рассмотрим в главе 3.

Поскольку строки неизменяемы, вы не можете вставить символ непосредственно в строку или изменить символ по заданному индексу. Попробуем изменить слово Henny на слово Penny и посмотрим, что произойдет:

>>> name = 'Henny'

>>> name[0] = 'P'

Traceback (most recent call last):

··File "<stdin>", line 1, in <module>

TypeError: 'str' object does not support item assignment

Вместо этого вам придется использовать комбинацию строковых функций вроде replace() или slice (ее вы увидите совсем скоро):

>>> name = 'Henny'

>>> name.replace('H', 'P')

'Penny'

>>> 'P' + name[1:]

'Penny'

Из строки можно извлечь подстроку (часть строки) с помощью функции slice. Вы определяете slice с помощью квадратных скобок, смещения начала подстроки start и конца подстроки end, а также опционального размера шага step. Некоторые из этих параметров могут быть исключены. В подстроку будут включены символы, расположенные начиная с точки, на которую указывает смещение start, и заканчивая точкой, на которую указывает смещение end.

• Оператор [: ] извлекает всю последовательность от начала до конца.

• Оператор [start: ] извлекает последовательность с точки, на которую указывает смещение start, до конца.

• Оператор [: end] извлекает последовательность от начала до точки, на которую указывает смещение end минус 1.

• Оператор [start: end] извлекает последовательность с точки, на которую указывает смещение start, до точки, на которую указывает смещение end минус 1.

• Оператор [start: end: step] извлекает последовательность с точки, на которую указывает смещение start, до точки, на которую указывает смещение end минус 1, опуская символы, чье смещение внутри подстроки кратно step.

Как и ранее, смещение слева направо определяется как 0, 1 и т. д., а справа налево — как -1, -2 и т. д. Если вы не укажете смещение start, функция будет использовать в качестве его значения 0 (начало строки). Если вы не укажете смещение end, функция будет использовать конец строки.

Создадим строку, содержащую английские буквы в нижнем регистре:

>>> letters = 'abcdefghijklmnopqrstuvwxyz'

Использование простого двоеточия аналогично использованию последовательности 0: (целая строка):

>>> letters[: ]

'abcdefghijklmnopqrstuvwxyz'

Вот так можно получить все символы, начиная с 20-го и заканчивая последним:

>>> letters[20:]

'uvwxyz'

А теперь — начиная с 10-го и заканчивая последним:

>>> letters[10:]

'klmnopqrstuvwxyz'

А теперь получим символы с 12-го по 14-й (Python не включает символ, расположенный под номером, который указан последним):

>>> letters[12:15]

'mno'

Последние три символа:

>>> letters[-3:]

'xyz'

В следующем примере мы начинаем со смещения 18 и идем до четвертого с конца символа. Обратите внимание на разницу с предыдущим примером, где старт с позиции -3 получал символ х. В этом примере конец диапазона -3 означает, что последним будет символ по адресу -4 — w:

>>> letters[18:-3]

'stuvw'

В следующем примере мы получаем символы, начиная с шестого с конца и заканчивая третьим с конца:

>>> letters[-6:-2]

'uvwx'

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

Каждый седьмой символ с начала до конца:

>>> letters[::7]

'ahov'

Каждый третий символ, начиная со смещения 4 и заканчивая 19-м символом:

>>> letters[4:20:3]

'ehknqt'

Каждый четвертый символ, начиная с 19-го:

>>> letters[19::4]

'tx'

Каждый пятый символ от начала до 20-го:

>>> letters[:21:5]

'afkpu'

Опять же значение end должно быть на единицу больше, чем реальное смещение.

И это еще не все! Если задать отрицательный шаг, любезный Python будет двигаться в обратную сторону. В следующем примере движение начинается с конца и заканчивается в начале, ни один символ не пропущен:

>>> letters[-1::-1]

'zyxwvutsrqponmlkjihgfedcba'

Оказывается, можно добиться того же результата, использовав такой пример:

>>> letters[::-1]

'zyxwvutsrqponmlkjihgfedcba'

Операция slice более мягко относится к неправильным смещениям, чем поиск по индексу. Если указать смещение меньшее, чем начало строки, оно будет обрабатываться как 0, а если указать смещение большее, чем конец строки, оно будет обработано как –1. Это показано в следующих примерах.

Начиная с –50-го символа и до конца:

>>> letters[-50:]

'abcdefghijklmnopqrstuvwxyz'

Начиная с –51-го символа и заканчивая –50-м:

>>> letters[-51:-50]

''

От начала до 69-го символа:

>>> letters[:70]

'abcdefghijklmnopqrstuvwxyz'

Начиная с 70-го символа и заканчивая 70-м:

>>> letters[70:71]

''

До этого момента мы использовали специальные знаки препинания вроде +, чтобы манипулировать строками. Но существует не так уж много подобных функций. Теперь мы начнем использовать некоторые встроенные функции Python: именованные фрагменты кода, которые выполняют определенные операции.

Функция len() подсчитывает символы в строке:

>>> len(letters)

26

>>> empty = ""

>>> len(empty)

0

Вы можете использовать функцию len() и для других типов последовательностей, что показано в главе 3.

В отличие от функции len() некоторые функции характерны только для строк. Для того чтобы использовать строковую функцию, введите имя строки, точку, имя функции и аргументы, которые нужны функции: строка. функция(аргументы). Более подробно о функциях мы будем говорить в разделе «Функции» главы 4.

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

>>> todos = 'get gloves,get mask,give cat vitamins,call ambulance'

>>> todos.split(',')

['get gloves', 'get mask', 'give cat vitamins', 'call ambulance']

В предыдущем примере строка имела имя todos, а строковая функция называлась split() и получала один аргумент ','. Если вы не укажете разделитель, функция split() будет использовать любую последовательность пробелов, а также символы новой строки и табуляцию:

>>> todos.split()

['get', 'gloves,get', 'mask,give', 'cat', 'vitamins,call', 'ambulance']

Если вы вызываете функцию split без аргументов, вам все равно нужно добавлять круглые скобки — именно так Python узнает, что вы вызываете функцию.

Для вас не должен стать великим открытием тот факт, что функция join() является противоположностью функции split(): она объединяет список строк в одну строку. Вызов функции выглядит немного запутанно, поскольку сначала вы указываете строку, которая объединяет остальные, а затем — список строк для объединения: string.join(list). Для того чтобы объединить список строк lines, разделив их символами новой строки, вам нужно написать '\n'.join(lines). В следующем примере мы объединим несколько имен в список, разделенный запятыми и пробелами:

>>> crypto_list = ['Yeti', 'Bigfoot', 'Loch Ness Monster']

>>> crypto_string = ', '.join(crypto_list)

>>> print('Found and signing book deals:', crypto_string)

Found and signing book deals: Yeti, Bigfoot, Loch Ness Monster

Python содержит большой набор функций для работы со строками. Рассмотрим принцип работы самых распространенных из них. Объектом для тестов станет следующая строка, содержащая текст бессмертного стихотворения What Is Liquid? Маргарет Кэвендиш (Margaret Cavendish), графини Ньюкасл:

>>> poem = '''All that doth flow we cannot liquid name

Or else would fire and water be the same;

But that is liquid which is moist and wet

Fire that property can never get.

Then 'tis not cold that doth the fire put out

But 'tis the wet that makes it die, no doubt.'''

Для начала получим первые 13 символов (их смещения лежат в диапазоне от 0 до 12):

>>> poem[:13]

'All that doth'

Сколько символов содержит это стихотворение? (Пробелы и символы новой строки учитываются.)

>>> len(poem)

250

Начинается ли стихотворение с буквосочетания All?

>>> poem.startswith('All')

True

Заканчивается ли оно буквосочетанием That's all, folks!?

>>> poem.endswith('That\'s all, folks!')

False

Найдем смещение первого включения слова the:

>>> word = 'the'

>>> poem.find(word)

73

А теперь — последнего:

>>> poem.rfind(word)

214

Сколько раз встречается трехбуквенное сочетание the?

>>> poem.count(word)

3

Являются ли все символы стихотворения буквами или цифрами?

>>> poem.isalnum()

False

Нет, в стихотворении имеются еще и знаки препинания.

В этом разделе мы рассмотрим еще несколько примеров использования встроенных функций. В качестве подопытной выберем следующую строку:

>>> setup = 'a duck goes into a bar…'

Удалим символ «.» с обоих концов строки:

>>> setup.strip('.')

'a duck goes into a bar'

Вы можете использовать функцию replace() для того, чтобы заменить одну подстроку другой. Вы передаете в эту функцию старую подстроку, новую подстроку и количество включений старой подстроки, которое нужно заменить. Если вы опустите последний аргумент, будут заменены все включения. В этом примере совпадает с заданным значением и заменяется следующая строка:

>>> setup.replace('duck', 'marmoset')

'a marmoset goes into a bar…'

Заменим максимум 100 включений:

>>> setup.replace('a ', 'a famous ', 100)

'a famous duck goes into a famous bar…'

Если вы точно знаете, какую подстроку или подстроки хотите изменить, функция replace() станет для вас хорошим выбором. Но будьте осторожны. Во втором примере, если бы мы заменили строку из одного символа 'а', а не строку из двух символов "а " (после а идет пробел), мы бы заменили символы 'а' и в середине слов:

>>> setup.replace('a', 'a famous', 100)

'a famous duck goes into a famous ba famousr…'

Иногда вам нужно убедиться, что подстрока является целым словом, началом слова и т. д. В этих случаях понадобятся регулярные выражения. Они подробно описаны в главе 7.

В Python имеется гораздо больше функций для работы со строками, чем я сейчас описал. Некоторые из них мы рассмотрим в следующих главах, но вы можете найти описания их всех в стандартной документации (http://bit.ly/py-docs-strings).

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

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

>>> empty_list = []

>>> weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

>>> big_birds = ['emu', 'ostrich', 'cassowary']

>>> first_names = ['Graham', 'John', 'Terry', 'Terry', 'Michael']

Кроме того, с помощью функции list() можно создать пустой список:

>>> another_empty_list = list()

>>> another_empty_list

[]

Функция list() преобразует другие типы данных в списки. В следующем примере строка преобразуется в список, состоящий из односимвольных строк:

>>> list('cat')

['c', 'a', 't']

В этом примере кортеж (этот тип мы рассмотрим сразу после списков) преобразуется в список:

>>> a_tuple = ('ready', 'fire', 'aim')

>>> list(a_tuple)

['ready', 'fire', 'aim']

Как я упоминал в подразделе «Разделяем строку с помощью функции split()» раздела «Строки» главы 2, можно использовать функцию split(), чтобы преобразовать строку в список, указав некую строку-разделитель:

>>> birthday = '1/6/1952'

>>> birthday.split('/')

['1', '6', '1952']

Что, если в оригинальной строке содержится несколько включений строки-разделителя подряд? В этом случае в качестве элемента списка вы получите пустую строку:

>>> splitme = 'a/b//c/d///e'

>>> splitme.split('/')

['a', 'b', '', 'c', 'd', '', '', 'e']

Если бы вы использовали разделитель //, состоящий из двух символов, то получили бы следующий результат:

>>> splitme = 'a/b//c/d///e'

>>> splitme.split('//')

>>>

['a/b', 'c/d', '/e']

Как и для строк, вы можете извлечь одно значение из списка, указав его смещение:

>>> marxes = ['Groucho', 'Chico', 'Harpo']

>>> marxes[0]

'Groucho'

>>> marxes[1]

'Chico'

>>> marxes[2]

'Harpo'

Опять же, как и в случае со строками, отрицательные индексы отсчитываются с конца строки:

>>> marxes[-1]

'Harpo'

>>> marxes[-2]

'Chico'

>>> marxes[-3]

'Groucho'

>>>

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

>>> small_birds = ['hummingbird', 'finch']

>>> extinct_birds = ['dodo', 'passenger pigeon', 'Norwegian Blue']

>>> carol_birds = [3, 'French hens', 2, 'turtledoves']

>>> all_birds = [small_birds, extinct_birds, 'macaw', carol_birds]

Как же будет выглядеть список списков all_birds?

>>> all_birds

[['hummingbird', 'finch'], ['dodo', 'passenger pigeon', 'Norwegian Blue'], 'macaw',

[3, 'French hens', 2, 'turtledoves']]

Взглянем на его первый элемент:

>>> all_birds[0]

['hummingbird', 'finch']

Первый элемент является списком — это список small_birds, он указан как первый элемент списка all_birds. Вы можете догадаться, чем является второй элемент:

>>> all_birds[1]

['dodo', 'passenger pigeon', 'Norwegian Blue']

Это второй указанный нами элемент, extinct_birds. Если нужно получить первый элемент списка extinct_birds, мы можем извлечь его из списка all_birds, указав два индекса:

>>> all_birds[1][0]

'dodo'

Индекс [1] ссылается на второй элемент списка all_birds, а [0] — на первый элемент внутреннего списка.

По аналогии с получением значения списка с помощью его смещения вы можете изменить это значение:

>>> marxes = ['Groucho', 'Chico', 'Harpo']

>>> marxes[2] = 'Wanda'

>>> marxes

['Groucho', 'Chico', 'Wanda']

Опять же смещение должно быть корректным для заданного списка.

Вы не можете изменить таким способом символ в строке, поскольку строки неизменяемы. Списки же можно изменить. Можете изменить количество элементов в списке, а также сами элементы.

Можно извлечь из списка подпоследовательность, использовав разделение списка:

>>> marxes = ['Groucho', 'Chico,' 'Harpo']

>>> marxes[0:2]

['Groucho', 'Chico']

Такой фрагмент списка также является списком.

Как и в случае со строками, при разделении можно пропускать некоторые значения. В следующем примере мы извлечем каждый нечетный элемент:

>>> marxes[::2]

['Groucho', 'Harpo']

Теперь начнем с последнего элемента и будем смещаться влево на 2:

>>> marxes[::-2]

['Harpo', 'Groucho']

И наконец, рассмотрим прием инверсии списка:

>>> marxes[::-1]

['Harpo', 'Chico', 'Groucho']

Традиционный способ добавления элементов в список — вызов метода append(), чтобы добавить их в конец списка. В предыдущих примерах мы забыли о Zeppo, но ничего страшного не случилось, поскольку список можно изменить. Добавим его прямо сейчас:

>>> marxes.append('Zeppo')

>>> marxes

['Groucho', 'Chico', 'Harpo', 'Zeppo']

Можно объединить один список с другим с помощью метода extend(). Предположим, что добрый человек дал нам новый список братьев Маркс, который называется others, и мы хотим добавить его в основной список marxes:

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> others = ['Gummo', 'Karl']

>>> marxes.extend(others)

>>> marxes

['Groucho', 'Chico', 'Harpo', 'Zeppo', 'Gummo', 'Karl']

Можно также использовать оператор +=:

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> others = ['Gummo', 'Karl']

>>> marxes += others

>>> marxes

['Groucho', 'Chico', 'Harpo', 'Zeppo', 'Gummo', 'Karl']

Если бы мы использовали метод append(), список others был бы добавлен как один элемент списка, вместо того чтобы объединить его элементы со списком marxes:

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> others = ['Gummo', 'Karl']

>>> marxes.append(others)

>>> marxes

['Groucho', 'Chico', 'Harpo', 'Zeppo', ['Gummo', 'Karl']]

Это снова демонстрирует, что список может содержать элементы разных типов. В этом случае — четыре строки и список из двух строк.

Функция append() добавляет элементы только в конец списка. Когда вам нужно добавить элемент в заданную позицию, используйте функцию insert(). Если вы укажете позицию 0, элемент будет добавлен в начало списка. Если позиция находится за пределами списка, элемент будет добавлен в конец списка, как и в случае с функцией append(), поэтому вам не нужно беспокоиться о том, что Python сгенерирует исключение:

>>> marxes.insert(3, 'Gummo')

>>> marxes

['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']

>>> marxes.insert(10, 'Karl')

>>> marxes

['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo', 'Karl']

Наши консультанты только что проинформировали нас о том, что Гуммо (Gummo) был одним из братьев Маркс, а Карл (Karl) — не был. Отменим последний ввод:

>>> del marxes[-1]

>>> marxes

['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']

Когда вы удаляете заданный элемент, все остальные элементы, которые идут следом за ним, смещаются, чтобы занять место удаленного элемента, а длина списка уменьшается на единицу. Если вы удалите 'Harpo' из последней версии списка, то получите такой результат:

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']

>>> marxes[2]

'Harpo'

>>> del marxes[2]

>>> marxes

['Groucho', 'Chico', 'Gummo', 'Zeppo']

>>> marxes[2]

'Gummo'

Если вы не знаете точно или вам все равно, в какой позиции находится элемент, используйте функцию remove(), чтобы удалить его по значению. Прощай, Гуммо:

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']

>>> marxes.remove('Gummo')

>>> marxes

['Groucho', 'Chico', 'Harpo', 'Zeppo']

Вы можете получить элемент из списка и в то же время удалить его с помощью функции pop(). Если вызовете функцию pop() и укажете некоторое смещение, она возвратит элемент, находящийся в заданной позиции; если аргумент не указан, будет использовано значение –1. Так, вызов pop(0) вернет головной (начальный) элемент списка, а вызов pop() или pop(-1) — хвостовой (конечный) элемент, как показано далее:

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> marxes.pop()

'Zeppo'

>>> marxes

['Groucho', 'Chico', 'Harpo']

>>> marxes.pop(1)

'Chico'

>>> marxes

['Groucho', 'Harpo']

Если вы хотите узнать смещение элемента в списке по его значению, используйте функцию index():

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> marxes.index('Chico')

1

В Python наличие элемента в списке проверяется с помощью оператора in:

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> 'Groucho' in marxes

True

>>> 'Bob' in marxes

False

Одно и то же значение может встретиться больше одного раза. До тех пор пока оно находится в списке хотя бы в единственном экземпляре, оператор in будет возвращать значение True:

>>> words = ['a', 'deer', 'a' 'female', 'deer']

>>> 'deer' in words

True

Чтобы определить, сколько раз какое-либо значение встречается в списке, используйте функцию count():

>>> marxes = ['Groucho', 'Chico', 'Harpo']

>>> marxes.count('Harpo')

1

>>> marxes.count('Bob')

0

>>> snl_skit = ['cheeseburger', 'cheeseburger', 'cheeseburger']

>>> snl_skit.count('cheeseburger')

3

В подразделе «Объединяем строки с помощью функции join()» раздела «Строки» главы 2 функция join() рассматривается более подробно, но взгляните еще на один пример того, что можно сделать с ее помощью:

>>> marxes = ['Groucho', 'Chico', 'Harpo']

>>> ', '.join(marxes)

'Groucho, Chico, Harpo'

Но погодите, вам может показаться, что нужно делать все наоборот. Функция join() предназначается для строк, а не для списков. Вы не можете написать marxes.join(', '), несмотря на то что интуитивно это кажется правильным. Аргументом для функции join() является эта строка или любая итерабельная последовательность строк, включая список, и она возвращает строку. Если бы функция join() была только методом списка, вы не смогли бы использовать ее для других итерабельных объектов вроде кортежей и строк. Если вы хотите, чтобы она работала с любым итерабельным типом, нужно написать особый код для каждого типа, чтобы обработать объединение. Будет полезно запомнить: join() противоположна split(), как показано здесь:

>>> friends = ['Harry', 'Hermione', 'Ron']

>>> separator = ' * '

>>> joined = separator.join(friends)

>>> joined

'Harry * Hermione * Ron'

>>> separated = joined.split(separator)

>>> separated

['Harry', 'Hermione', 'Ron']

>>> separated == friends

True

Вам часто нужно будет изменять порядок элементов по их значениям, а не по смещениям. Для этого Python предоставляет две функции:

• функцию списка sort(), которая сортирует сам список;

• общую функцию sorted(), которая возвращает отсортированную копию списка.

Если элементы списка являются числами, они по умолчанию сортируются по возрастанию. Если они являются строками, то сортируются в алфавитном порядке:

>>> marxes = ['Groucho', 'Chico', 'Harpo']

>>> sorted_marxes = sorted(marxes)

>>> sorted_marxes

['Chico', 'Groucho', 'Harpo']

sorted_marxes — это копия, ее создание не изменило оригинальный список:

>>> marxes

['Groucho', 'Chico', 'Harpo']

Но вызов функции списка sort() для marxes изменит этот список:

>>> marxes.sort()

>>> marxes

['Chico', 'Groucho', 'Harpo']

Если все элементы вашего списка одного типа (в списке marxes находятся только строки), функция sort() отработает корректно. Иногда можно даже смешать типы — например, целые числа и числа с плавающей точкой, — поскольку в рамках выражений они конвертируются автоматически:

>>> numbers = [2, 1, 4.0, 3]

>>> numbers.sort()

>>> numbers

[1, 2, 3, 4.0]

По умолчанию список сортируется по возрастанию, но вы можете добавить аргумент reverse=True, чтобы отсортировать список по убыванию:

>>> numbers = [2, 1, 4.0, 3]

>>> numbers.sort(reverse=True)

>>> numbers

[4.0, 3, 2, 1]

Функция len() возвращает количество элементов списка:

>>> marxes = ['Groucho', 'Chico', 'Harpo']

>>> len(marxes)

3

Если вы присваиваете один список более чем одной переменной, изменение списка в одном месте повлечет за собой его изменение в остальных, как показано далее:

>>> a = [1, 2, 3]

>>> a

[1, 2, 3]

>>> b = a

>>> b

[1, 2, 3]

>>> a[0] = 'surprise'

>>> a

['surprise', 2, 3]

Что же находится в переменной b? Ее значение все еще равно [1, 2, 3] или изменилось на ['surprise', 2, 3]? Проверим:

>>> b

['surprise', 2, 3]

Помните аналогию со стикерами в главе 2? b просто ссылается на тот же список объектов, что и а, поэтому, независимо от того, с помощью какого имени мы изменяем содержимое списка, изменение отразится на обеих переменных:

>>> b

['surprise', 2, 3]

>>> b[0] = 'I hate surprises'

>>> b

['I hate surprises', 2, 3]

>>> a

['I hate surprises', 2, 3]

Вы можете скопировать значения в независимый новый список с помощью одного из следующих методов:

• функции copy();

• функции преобразования list();

• разбиения списка [: ].

Оригинальный список снова будет присвоен переменной а. Мы создадим b с помощью функции списка copy(), c — с помощью функции преобразования list(), а d — с помощью разбиения списка:

>>> a = [1, 2, 3]

>>> b = a.copy()

>>> c = list(a)

>>> d = a[: ]

Опять же b, c и d являются копиями a — это новые объекты, имеющие свои значения, не связанные с оригинальным списком объектов [1, 2, 3], на который ссылается a. Изменение a не повлияет на копии b, c и d:

>>> a[0] = 'integer lists are boring'

>>> a

['integer lists are boring', 2, 3]

>>> b

[1, 2, 3]

>>> c

[1, 2, 3]

>>> d

[1, 2, 3]

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

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

Начнем с создания пустого кортежа с помощью оператора ():

>>> empty_tuple = ()

>>> empty_tuple

()

Чтобы создать кортеж, содержащий один элемент или более, ставьте после каждого элемента запятую. Это вариант для кортежей с одним элементом:

>>> one_marx = 'Groucho',

>>> one_marx

('Groucho',)

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

>>> marx_tuple = 'Groucho', 'Chico', 'Harpo'

>>> marx_tuple

('Groucho', 'Chico', 'Harpo')

При отображении кортежа Python выводит на экран скобки. Вам они совсем не нужны — кортеж определяется запятыми, — однако не повредят. Вы можете окружить ими значения, что позволяет сделать кортежи более заметными:

>>> marx_tuple = ('Groucho', 'Chico', 'Harpo')

>>> marx_tuple

('Groucho', 'Chico', 'Harpo')

Кортежи позволяют вам присвоить несколько переменных за один раз:

>>> marx_tuple = ('Groucho', 'Chico', 'Harpo')

>>> a, b, c = marx_tuple

>>> a

'Groucho'

>>> b

'Chico'

>>> c

'Harpo'

Иногда это называется распаковкой кортежа.

Вы можете использовать кортежи, чтобы обменять значения с помощью одного выражения, без применения временной переменной:

>>> password = 'swordfish'

>>> icecream = 'tuttifrutti'

>>> password, icecream = icecream, password

>>> password

'tuttifrutti'

>>> icecream

'swordfish'

>>>

Функция преобразования tuple() создает кортежи из других объектов:

>>> marx_list = ['Groucho', 'Chico', 'Harpo']

>>> tuple(marx_list)

('Groucho', 'Chico', 'Harpo')

Вы можете использовать кортежи вместо списков, но они имеют меньше возможностей — у них нет функций append(), insert() и т. д., поскольку кортеж не может быть изменен после создания. Почему же не применять везде списки вместо кортежей?

• Кортежи занимают меньше места.

• Вы не сможете уничтожить элементы кортежа по ошибке.

• Вы можете использовать кортежи как ключи словаря (см. следующий раздел).

• Именованные кортежи (см. пункт «Именованные кортежи» раздела «Когда лучше использовать классы и объекты, а когда — модули» главы 6) могут служить более простой альтернативой объектам.

• Аргументы функции передаются как кортежи (см. раздел «Функции» главы 4).

Более детально рассматривать кортежи я не буду. При решении повседневных задач вы будете чаще использовать списки и словари. И это хороший повод перейти к следующей теме.

Словарь очень похож на список, но порядок элементов в нем не имеет значения, и они выбираются не с помощью смещения. Вместо этого для каждого значения вы указываете связанный с ним уникальный ключ. Таким ключом в основном служит строка, но он может быть объектом одного из неизменяемых типов: булевой переменной, целым числом, числом с плавающей точкой, кортежем, строкой и другими объектами, которые вы увидите далее. Словари можно изменять, что означает, что вы можете добавить, удалить и изменить их элементы, которые имеют вид «ключ — значение».

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

Чтобы создать словарь, вам нужно обернуть в фигурные скобки ({}) разделенные запятыми пары ключ: значение. Самым простым словарем является пустой словарь, не содержащий ни ключей, ни значений:

>>> empty_dict = {}

>>> empty_dict

{}

Создадим небольшой словарь, включающий цитаты из «Словаря сатаны» Амброза Бирса:

>>> bierce = {

…·····"day": "A period of twenty-four hours, mostly misspent",

…·····"positive": "Mistaken at the top of one's voice",

…·····"misfortune": "The kind of fortune that never misses",

…·····}

>>>

Ввод имени словаря в интерактивный интерпретатор выведет все его ключи и значения:

>>> bierce

{'misfortune': 'The kind of fortune that never misses',

'positive': "Mistaken at the top of one's voice",

'day': 'A period of twenty-four hours, mostly misspent'}

Вы можете использовать функцию dict(), чтобы преобразовывать последовательности из двух значений в словари. (Вы иногда можете столкнуться с последовательностями «ключ — значение» вида «Стронций, 90, углерод, 14» или «Vikings, 20, Packers, 7».) Первый элемент каждой последовательности применяется как ключ, а второй — как значение.

Для начала рассмотрим небольшой пример, использующий lol (список, содержащий списки, которые состоят из двух элементов):

>>> lol = [['a', 'b'], ['c', 'd'], ['e', 'f']]

>>> dict(lol)

{'c': 'd', 'a': 'b', 'e': 'f'}

Добавить элемент в словарь довольно легко. Нужно просто обратиться к элементу по его ключу и присвоить ему значение. Если ключ уже существует в словаре, имеющееся значение будет заменено новым. Если ключ новый, он и указанное значение будут добавлены в словарь. Здесь, в отличие от списков, вам не нужно волноваться о том, что Python сгенерирует исключение во время присваивания нового элемента, если вы укажете, что этот индекс находится вне существующего диапазона.

Создадим словарь, содержащий большинство членов Monty Python, используя их фамилии в качестве ключей, а имена — в качестве значений:

>>> pythons = {

…·····'Chapman': 'Graham',

…·····'Cleese': 'John',

…·····'Idle': 'Eric',

…·····'Jones': 'Terry',

…·····'Palin': 'Michael',

…·····}

>>> pythons

{'Cleese': 'John', 'Jones': 'Terry', 'Palin': 'Michael',

'Chapman': 'Graham', 'Idle': 'Eric'}

Здесь не хватает одного участника — уроженца Америки Терри Гиллиама. Перед вами попытка анонимного программиста добавить его, однако он ошибся, когда вводил имя:

>>> pythons['Gilliam'] = 'Gerry'

>>> pythons

{'Cleese': 'John', 'Gilliam': 'Gerry', 'Palin': 'Michael',

'Chapman': 'Graham', 'Idle': 'Eric', 'Jones': 'Terry'}

А вот код другого программиста, который исправил эту ошибку:

>>> pythons['Gilliam'] = 'Terry'

>>> pythons

{'Cleese': 'John', 'Gilliam': 'Terry', 'Palin': 'Michael',

'Chapman': 'Graham', 'Idle': 'Eric', 'Jones': 'Terry'}

Используя один и тот же ключ ('Gilliam'), мы заменили исходное значение 'Gerry' на 'Terry'.

Помните, что ключи в словаре должны быть уникальными. Именно поэтому мы в качестве ключей использовали фамилии, а не имена — двух участников Monty Python зовут Терри. Если вы применяете ключ более одного раза, победит последнее значение:

>>> some_pythons = {

…·····'Graham': 'Chapman',

…·····'John': 'Cleese',

…·····'Eric': 'Idle',

…·····'Terry': 'Gilliam',

…·····'Michael': 'Palin',

…·····'Terry': 'Jones',

…·····}

>>> some_pythons

{'Terry': 'Jones', 'Eric': 'Idle', 'Graham': 'Chapman',

'John': 'Cleese', 'Michael': 'Palin'}

Сначала мы присвоили значение 'Gilliam' ключу 'Terry', а затем заменили его на 'Jones'.

Вы можете использовать функцию update(), чтобы скопировать ключи и значения из одного словаря в другой.

Определим словарь pythons, содержащий имена всех участников:

>>> pythons = {

…·····'Chapman': 'Graham',

…·····'Cleese': 'John',

…·····'Gilliam': 'Terry',

…·····'Idle': 'Eric',

…·····'Jones': 'Terry',

…·····'Palin': 'Michael',

·····}

>>> pythons

{'Cleese': 'John', 'Gilliam': 'Terry', 'Palin': 'Michael',

'Chapman': 'Graham', 'Idle': 'Eric', 'Jones': 'Terry'}

Кроме того, у нас есть другой словарь, содержащий имена других юмористов и называющийся others:

>>> others = { 'Marx': 'Groucho', 'Howard': 'Moe' }

Теперь появляется еще один анонимный программист, который считает, что члены словаря others должны быть членами Monty Python:

>>> pythons.update(others)

>>> pythons

{'Cleese': 'John', 'Howard': 'Moe', 'Gilliam': 'Terry',

'Palin': 'Michael', 'Marx': 'Groucho', 'Chapman': 'Graham',

'Idle': 'Eric', 'Jones': 'Terry'}

Что произойдет, если во втором словаре будут находиться такие же ключи, что и в первом? Победит значение из второго словаря:

>>> first = {'a': 1, 'b': 2}

>>> second = {'b': 'platypus'}

>>> first.update(second)

>>> first

{'b': 'platypus', 'a': 1}

Код нашего анонимного программиста был корректным — технически. Но он не должен был его писать! Члены словаря others, несмотря на свою известность и чувство юмора, не участвовали в Monty Python. Отменим добавление последних двух элементов:

>>> del pythons['Marx']

>>> pythons

{'Cleese': 'John', 'Howard': 'Moe', 'Gilliam': 'Terry',

'Palin': 'Michael', 'Chapman': 'Graham', 'Idle': 'Eric',

'Jones': 'Terry'}

>>> del pythons['Howard']

>>> pythons

{'Cleese': 'John', 'Gilliam': 'Terry', 'Palin': 'Michael',

'Chapman': 'Graham', 'Idle': 'Eric', 'Jones': 'Terry'}

Чтобы удалить все ключи и значения из словаря, вам следует использовать функцию clear() или просто присвоить пустой словарь заданному имени:

>>> pythons.clear()

>>> pythons

{}

>>> pythons = {}

>>> pythons

{}

Если вы хотите узнать, содержится ли в словаре какой-то ключ, используйте ключевое слово in. Снова определим словарь pythons, но на этот раз опустим одного-двух участников:

>>> pythons = {'Chapman': 'Graham', 'Cleese': 'John',

'Jones': 'Terry', 'Palin': 'Michael'}

Теперь проверим, кого мы добавили:

>>> 'Chapman' in pythons

True

>>> 'Palin' in pythons

True

Вспомнили ли мы о Терри Гиллиаме на этот раз?

>>> 'Gilliam' in pythons

False

Черт.

Этот вариант использования словаря — самый распространенный. Вы указываете словарь и ключ, чтобы получить соответствующее значение:

>>> pythons['Cleese']

'John'

Если ключа в словаре нет, будет сгенерировано исключение:

>>> pythons['Marx']

Traceback (most recent call last):

··File "<stdin>", line 1, in <module>

KeyError: 'Marx'

Есть два хороших способа избежать возникновения этого исключения. Первый из них — проверить, имеется ли заданный ключ, с помощью ключевого слова in, что вы уже видели в предыдущем разделе:

>>> 'Marx' in pythons

False

Второй способ — использовать специальную функцию словаря get(). Вы указываете словарь, ключ и опциональное значение. Если ключ существует, вы получите связанное с ним значение:

>>> pythons.get('Cleese')

'John'

Если такого ключа нет, получите опциональное значение, если указывали его:

>>> pythons.get('Marx', 'Not a Python')

'Not a Python'

В противном случае будет возвращен объект None (интерактивный интерпретатор не выведет ничего):

>>> pythons.get('Marx')

>>>

Вы можете использовать функцию keys(), чтобы получить все ключи словаря. Для следующих примеров мы берем другой словарь:

>>> signals = {'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera'}

>>> signals.keys()

dict_keys(['green', 'red', 'yellow'])

Чтобы получить все значения словаря, используйте функцию values():

>>> list(signals.values())

['go', 'smile for the camera', 'go faster']

Когда вам нужно получить все пары «ключ — значение» из словаря, используйте функцию items():

>>> list(signals.items())

[('green', 'go'), ('red', 'smile for the camera'), ('yellow', 'go faster')]

Каждая пара будет возвращена как кортеж вроде ('green', 'go').

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

>>> signals = {'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera'}

>>> save_signals = signals

>>> signals['blue'] = 'confuse everyone'

>>> save_signals

{'blue': 'confuse everyone', 'green': 'go',

'red': 'smile for the camera', 'yellow': 'go faster'}

Чтобы скопировать ключи и значения из одного словаря в другой и избежать этого, вы можете воспользоваться функцией copy():

>>> signals = {'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera'}

>>> original_signals = signals.copy()

>>> signals['blue'] = 'confuse everyone'

>>> signals

{'blue': 'confuse everyone', 'green': 'go',

'red': 'smile for the camera', 'yellow': 'go faster'}

>>> original_signals

{'green': 'go', 'red': 'smile for the camera', 'yellow': 'go faster'}

Множество похоже на словарь, значения которого опущены. Он имеет только ключи. Как и в случае со словарем, ключи должны быть уникальны. Если вам нужно прикрепить к ключу некую информацию, воспользуйтесь словарем.

Раньше кое-где теорию множеств преподавали в начальной школе наряду с основами математики. Если в вашей школе такого не было (или было, но вы в это время смотрели в окно, как и я), на рис. 3.1 можете увидеть объединения и пересечения множеств.

Предположим, вы хотите объединить два множества, которые содержат несколько общих ключей. Поскольку множество должно содержать только уникальные значения, объединение двух множеств будет содержать лишь одно включение каждого ключа. Пустое множество — это множество, содержащее ноль элементов. Основываясь на рис. 3.1, можно сказать, что пустым будет множество, которое содержит женские имена, начинающиеся с буквы «Х».

Рис. 3.1. Распространенные операции с множествами

Чтобы создать множество, вам следует использовать функцию set() или разместить в фигурных скобках одно или несколько разделенных запятыми значений, как показано здесь:

>>> empty_set = set()

>>> empty_set

set()

>>> even_numbers = {0, 2, 4, 6, 8}

>>> even_numbers

{0, 8, 2, 4, 6}

>>> odd_numbers = {1, 3, 5, 7, 9}

>>> odd_numbers

{9, 3, 1, 5, 7}

Как и в случае со словарем, порядок ключей в множестве не имеет значения.

Вы можете создать множество из списка, строки, кортежа или словаря, потеряв все повторяющиеся значения.

Для начала взглянем на строку, которая содержит более чем одно включение некоторых букв:

>>> set('letters')

{'l', 'e', 't', 'r', 's'}

Обратите внимание на то, что множество содержит только одно включение букв «e» или «t», несмотря на то, что в слове letters по два включения каждой из них.

Создадим множество из списка:

>>> set(['Dasher', 'Dancer', 'Prancer', 'Mason-Dixon'])

{'Dancer', 'Dasher', 'Prancer', 'Mason-Dixon'}

А теперь из кортежа:

>>> set(('Ummagumma', 'Echoes', 'Atom Heart Mother'))

{'Ummagumma', 'Atom Heart Mother', 'Echoes'}

Когда вы передаете функции set() словарь, она возвращает только ключи:

>>> set({'apple': 'red', 'orange': 'orange', 'cherry': 'red'})

{'apple', 'cherry', 'orange'}

Такое использование множеств самое распространенное. Мы создадим словарь, который называется drinks. Каждый ключ будет названием коктейля, а соответствующие значения — множествами ингредиентов:

>>> drinks = {

…·····'martini': {'vodka', 'vermouth'},

…·····'black russian': {'vodka', 'kahlua'},

…·····'white russian': {'cream', 'kahlua', 'vodka'},

…·····'manhattan': {'rye', 'vermouth', 'bitters'},

…·····'screwdriver': {'orange juice', 'vodka'}

…·····}

Несмотря на то что и словарь, и множества окружены фигурными скобками ({ и }), множество — это всего лишь последовательность значений, а словарь — это набор пар «ключ — значение».

Какой из коктейлей содержит в себе водку? (Обратите внимание на то, что для выполнения этих проверок я заранее демонстрирую использование ключевых слов for, if, and и or, которые будут рассмотрены только в следующей главе.)

>>> for name, contents in drinks.items():

…·····if 'vodka' in contents:

…·········print(name)

…

screwdriver

martini

black russian

white russian

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

>>> for name, contents in drinks.items():

…·····if 'vodka' in contents and not ('vermouth' in contents or

…·········'cream' in contents):

…·········print(name)

…

screwdriver

black russian

Перепишем этот пример чуть более сжато в следующем разделе.

Что, если вам нужно проверить наличие сразу нескольких значений множества? Предположим, вы хотите найти любой напиток, содержащий апельсиновый сок или вермут. Для этого мы используем оператор пересечения множеств (&):

>>> for name, contents in drinks.items():

…·····if contents & {'vermouth', 'orange juice'}:

…·········print(name)

…

screwdriver

martini

manhattan

Результатом работы оператора & является множество, содержащее все элементы, которые находятся в обоих сравниваемых списках. Если ни один из заданных ингредиентов не содержится в предлагаемых коктейлях, оператор & вернет пустое множество. Этот результат можно считать равным False.

Теперь перепишем пример из предыдущего раздела, в котором мы хотели водки, не смешанной со сливками или вермутом:

>>> for name, contents in drinks.items():

…·····if 'vodka' in contents and not contents & {'vermouth', 'cream'}:

…·········print(name)

…

screwdriver

black russian

Сохраним множества ингредиентов для этих двух напитков в переменных, чтобы нам не пришлось набирать много текста в дальнейших примерах:

>>> bruss = drinks['black russian']

>>> wruss = drinks['white russian']

В следующих примерах демонстрируется использование операторов множеств. В одних из них демонстрируется применение особой пунктуации, в других — особых функций, в третьих — и того и другого. Мы будем использовать тестовые множества а (содержит элементы 1 и 2) и b (содержит элементы 2 и 3):

>>> a = {1, 2}

>>> b = {2, 3}

Пересечение множеств (члены обоих множеств) можно получить с помощью особого пунктуационного символа & или функции множества intersection(), как показано здесь:

>>> a & b

{2}

>>> a.intersection(b)

{2}

В этом фрагменте используются сохраненные нами переменные:

>>> bruss & wruss

{'kahlua', 'vodka'}

В этом примере мы получаем объединение (члены обоих множеств), используя оператор | или функцию множества union():

>>> a | b

{1, 2, 3}

>>> a.union(b)

{1, 2, 3}

Алкогольная версия:

>>> bruss | wruss

{'cream', 'kahlua', 'vodka'}

Разность множеств (члены только первого множества, но не второго) можно получить с помощью символа — или функции difference():

>>> a — b

{1}

>>> a.difference(b)

{1}

>>> bruss — wruss

set()

>>> wruss — bruss

{'cream'}

Самыми распространенными операциями с множествами являются объединение, пересечение и разность. Для полноты картины я включил в этот раздел и остальные операции, но вы, возможно, никогда не будете их использовать.

Для выполнения исключающего ИЛИ (элементы или первого, или второго множества, но не общие) используйте оператор ^ или функцию symmetric_difference():

>>> a ^ b

{1, 3}

>>> a.symmetric_difference(b)

{1, 3}

В этом примере определяется эксклюзивный ингредиент для русских напитков:

>>> bruss ^ wruss

{'cream'}

Вы можете проверить, является ли одно множество подмножеством другого (все члены первого множества являются членами второго), с помощью оператора <= или функции issubset():

>>> a <= b

False

>>> a.issubset(b)

False

Добавление сливок в коктейль «черный русский» сделает его «белым русским», поэтому wruss является подмножеством bruss:

>>> bruss <= wruss

True

Является ли любое множество подмножеством самого себя? Ага.

>>> a <= a

True

>>> a.issubset(a)

True

Для того чтобы стать собственным подмножеством, второе множество должно содержать все члены первого и несколько других. Определяется это с помощью оператора <:

>>> a < b

False

>>> a < a

False

>>> bruss < wruss

True

Множество множеств противоположно подмножеству (все члены второго множества являются также членами первого). Для определения этого используется оператор >= или функция issuperset():

>>> a >= b

False

>>> a.issuperset(b)

False

>>> wruss >= bruss

True

Любое множество является множеством множеств самого себя:

>>> a >= a

True

>>> a.issuperset(a)

True

И наконец, вы можете найти собственное множество множеств (первое множество содержит все члены второго и несколько других) с помощью оператора >:

>>> a > b

False

>>> wruss > bruss

True

Множество не может быть собственным множеством множеств самого себя:

>>> a > a

False

Проверки с помощью if, elif и else выполняются последовательно. Иногда нам нужно выполнить какие-то операции более чем один раз. Нам нужен цикл, и простейшим вариантом циклов в Python является while. Попробуйте запустить с помощью интерактивного интерпретатора следующий пример — это простейший цикл, который выводит на экран значения от 1 до 5:

>>> count = 1

>>> while count <= 5:

…·····print(count)

…·····count += 1

…

1

2

3

4

5

>>>

Сначала мы присваиваем значение 1 переменной count. Цикл while сравнивает значение переменной count с числом 5 и продолжает работу, если значение переменной count меньше или равно 5. Внутри цикла мы выводим значение переменной count, а затем увеличиваем его на 1 с помощью выражения count += 1. Python возвращается к верхушке цикла и снова сравнивает значение переменной count с числом 5. Значение переменной count теперь равно 2, поэтому содержимое цикла while выполняется снова и переменная count увеличивается до 3.

Это продолжается до тех пор, пока переменная count не будет увеличена с 5 до 6 в нижней части цикла. Во время очередного возврата наверх цикла проверка count <= 5 вернет значение False и цикл while закончится. Python перейдет к выполнению следующих строк.

Если вы хотите, чтобы цикл выполнялся до тех пор, пока что-то не произойдет, но вы не знаете точно, когда это событие случится, можете воспользоваться бесконечным циклом, содержащим оператор break. В этот раз мы считаем строку с клавиатуры с помощью функции input(), а затем выведем ее на экран, сделав первую букву прописной. Мы прервем цикл, когда будет введена строка, содержащая только букву «q»:

>>> while True:

…·····stuff = input("String to capitalize [type q to quit]: ")

…·····if stuff == "q":

…·········break

…·····print(stuff.capitalize())

…

String to capitalize [type q to quit]: test

Test

String to capitalize [type q to quit]: hey, it works

Hey, it works

String to capitalize [type q to quit]: q

>>>

Иногда вам нужно не прерывать весь цикл, а только пропустить по какой-то причине одну итерацию. Рассмотрим воображаемый пример: считаем целое число, выведем на экран его значение в квадрате, если оно четное, и пропустим его, если оно нечетное. Мы даже добавим несколько комментариев. И вновь для выхода из цикла используем строку "q":

>>> while True:

…·····value = input("Integer, please [q to quit]: ")

…·····if value == 'q':······# выход

…·········break

…·····number = int(value)

…·····if number % 2 == 0:···# нечетное число

…········continue

…·····print(number, "squared is", number*number)

…

Integer, please [q to quit]: 1

1 squared is 1

Integer, please [q to quit]: 2

Integer, please [q to quit]: 3

3 squared is 9

Integer, please [q to quit]: 4

Integer, please [q to quit]: 5

5 squared is 25

Integer, please [q to quit]: q

>>>

Если цикл while завершился нормально (без вызова break), управление передается в опциональный блок else. Вы можете использовать его в цикле, где выполняете некоторую проверку и прерываете цикл, как только проверка успешно выполняется. Блок else выполнится в том случае, если цикл while будет пройден полностью, но искомый объект не будет найден:

>>> numbers = [1, 3, 5]

>>> position = 0

>>> while position < len(numbers):

…·····number = numbers[position]

…·····if number % 2 == 0:

…·········print('Found even number', number)

…·········break

…·····position += 1

… else:··# break not called

…·····print('No even number found')

…

No even number found

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

Вполне возможно пройти по последовательности таким образом:

>>> rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

>>> current = 0

>>> while current < len(rabbits):

…·····print(rabbits[current])

…·····current += 1

…

Flopsy

Mopsy

Cottontail

Peter

Однако существует более характерный для Python способ решения этой задачи:

>>> for rabbit in rabbits:

…·····print(rabbit)

…

Flopsy

Mopsy

Cottontail

Peter

Списки вроде rabbits являются одними из итерабельных объектов в Python наряду со строками, кортежами, словарями и некоторыми другими элементами. Итерирование по кортежу или списку возвращает один элемент за раз. Итерирование по строке возвращает один символ за раз, как показано здесь:

>>> word = 'cat'

>>> for letter in word:

…·····print(letter)

…

c

a

t

Итерирование по словарю (или его функции keys()) возвращает ключи. В этом примере ключи являются типами карт в настольной игре Clue (за пределами Северной Америки она называется CluedoAmerica):

>>> accusation = {'room': 'ballroom', 'weapon': 'lead pipe',

··················'person': 'Col. Mustard'}

>>> for card in accusation:··#··или for card in accusation.keys():

…·····print(card)

…

room

weapon

person

Чтобы итерировать по значениям, а не по ключам, следует использовать функцию values():

>>> for value in accusation.values():

…·····print(value)

…

ballroom

lead pipe

Col. Mustard

Чтобы вернуть как ключ, так и значение кортежа, вы можете использовать функцию items():

>>> for item in accusation.items():

…·····print(item)

…

('room', 'ballroom')

('weapon', 'lead pipe')

('person', 'Col. Mustard')

Помните, что можете присвоить значение кортежу за один шаг. Для каждого кортежа, возвращенного функцией items(), присвойте первое значение (ключ) переменной card, а второе (значение) — переменной contents:

>>> for card, contents in accusation.items():

…·····print('Card', card, 'has the contents', contents)

…

Card weapon has the contents lead pipe

Card person has the contents Col. Mustard

Card room has the contents ballroom

Ключевое слово break в цикле for прерывает этот цикл точно так же, как и цикл while.

Добавление ключевого слова continue в цикл for позволяет перейти на следующую итерацию цикла, как и в случае с циклом while.

Как и в цикле while, в for имеется опциональный блок else, который проверяет, выполнился ли цикл for полностью. Если ключевое слово break не было вызвано, будет выполнен блок else.

Это полезно, если вам нужно убедиться в том, что предыдущий цикл выполнился полностью, вместо того чтобы рано прерваться. Цикл for в следующем примере выводит на экран название сыра и прерывается, если сыра в магазине не найдется:

>>> cheeses = []

>>> for cheese in cheeses:

…·····print('This shop has some lovely', cheese)

…·····break

… else:··# отсутствие прерывания означает, что сыра нет

…·····print('This is not much of a cheese shop, is it?')

…

This is not much of a cheese shop, is it?

Существует еще один полезный прием — параллельное итерирование по нескольким последовательностям с помощью функции zip():

>>> days = ['Monday', 'Tuesday', 'Wednesday']

>>> fruits = ['banana', 'orange', 'peach']

>>> drinks = ['coffee', 'tea', 'beer']

>>> desserts = ['tiramisu', 'ice cream', 'pie', 'pudding']

>>> for day, fruit, drink, dessert in zip(days, fruits, drinks, desserts):

…·····print(day, ": drink", drink, "eat", fruit, "enjoy", dessert)

…

Monday: drink coffee — eat banana — enjoy tiramisu

Tuesday: drink tea — eat orange — enjoy ice cream

Wednesday: drink beer — eat peach — enjoy pie

Функция zip() прекращает свою работу, когда выполняется самая короткая последовательность. Один из списков (desserts) оказался длиннее остальных, поэтому никто не получит пудинг, пока мы не увеличим остальные списки.

В разделе «Словари» главы 3 показывается, как с помощью функции dict() можно создавать словари из последовательностей, содержащих два элемента, вроде кортежей, списков или строк. Вы можете использовать функцию zip(), чтобы пройти по нескольким последовательностям и создать кортежи из элементов с одинаковыми смещениями. Создадим два кортежа из соответствующих друг другу английских и французских слов:

>>> english = 'Monday', 'Tuesday', 'Wednesday'

>>> french = 'Lundi', 'Mardi', 'Mercredi'

Теперь используем функцию zip(), чтобы объединить эти кортежи в пару. Значение, возвращаемое функцией zip(), само по себе не является списком или кортежем, но его можно преобразовать в любую из этих последовательностей:

>>> list(zip(english, french))

[('Monday', 'Lundi'), ('Tuesday', 'Mardi'), ('Wednesday', 'Mercredi')]

Передайте результат работы функции zip() непосредственно функции dict() — и у нас готов небольшой англо-французский словарь!

>>> dict(zip(english, french))

{'Monday': 'Lundi', 'Tuesday': 'Mardi', 'Wednesday': 'Mercredi'}

Функция range() возвращает поток чисел в заданном диапазоне без необходимости создавать и сохранять крупную структуру данных вроде списка или кортежа. Это позволяет вам создавать большие диапазоны, не использовав всю память компьютера и не обрушив программу.

Вы можете применять функцию range() аналогично slice(): range(start, stop, step). Если опустите значение start, диапазон начнется с 0. Необходимым является лишь значение stop: как и в случае со slice(), оно определяет последнее значение, которое будет создано прямо перед остановкой функции. Значение по умолчанию step равно 1, но вы можете изменить его на -1.

Как и zip(), функция range() возвращает итерабельный объект, поэтому вам нужно пройти по значениям с помощью конструкции for … in или преобразовать объект в последовательность вроде списка. Создадим диапазон 0, 1, 2:

>>> for x in range(0,3):

…·····print(x)

…

0

1

2

>>> list(range(0, 3))

[0, 1, 2]

Вот так можно создать диапазон от 2 до 0:

>>> for x in range(2, -1, -1):

…·····print(x)

…

2

1

0

>>> list(range(2, -1, -1))

[2, 1, 0]

В следующем фрагменте кода используется шаг 2, чтобы получить все четные числа от 0 до 10:

>>> list(range(0, 11, 2))

[0, 2, 4, 6, 8, 10]

В главе 8 рассматривается итерирование по файлам. В главе 6 вы сможете увидеть, как использовать итерирование для объектов, которые сами определили.

Включение — это компактный способ создать структуру данных из одного или более итераторов. Включения позволяют вам объединять циклы и условные проверки, не используя при этом громоздкий синтаксис. Если вы применяете включение, то можно сказать, что уже неплохо знаете Python. Иными словами, это одна из характерных особенностей данного языка.

Вы можете создать список целых чисел от 1 до 5, добавляя их туда по одному за раз, например, так:

>>> number_list = []

>>> number_list.append(1)

>>> number_list.append(2)

>>> number_list.append(3)

>>> number_list.append(4)

>>> number_list.append(5)

>>> number_list

[1, 2, 3, 4, 5]

Или же вы могли бы использовать итератор и функцию range():

>>> number_list = []

>>> for number in range(1, 6):

…·····number_list.append(number)

…

>>> number_list

[1, 2, 3, 4, 5]

Или же преобразовать в список сам результат работы функции range():

>>> number_list = list(range(1, 6))

>>> number_list

[1, 2, 3, 4, 5]

Все эти подходы абсолютно корректны с точки зрения Python и сгенерируют одинаковый результат. Однако более характерным для Python является создание списка с помощью включения списка. Простейшая форма такого включения выглядит так:

[выражение for элемент in итерабельный объект]

Вот так выглядит включение списка целых чисел:

>>> number_list = [number for number in range(1,6)]

>>> number_list

[1, 2, 3, 4, 5]

В первой строке вам нужно, чтобы первая переменная number сформировала значения для списка: следует разместить результат работы цикла в переменной number_list. Вторая переменная number является частью цикла for. Чтобы показать, что первая переменная number является выражением, попробуем такой вариант:

>>> number_list = [number-1 for number in range(1,6)]

>>> number_list

[0, 1, 2, 3, 4]

Включение списка перемещает цикл в квадратные скобки. Этот пример включения ненамного проще предыдущего, но это еще не все. Включение списка может содержать условное выражение, которое выглядит примерно так:

[выражение for элемент in итерабельный объект if условие]

Создадим новое включение, которое создает список, состоящий только из четных чисел, расположенных в диапазоне от 1 до 5 (помните, что выражение number % 2 имеет значение True для четных чисел и False для нечетных):

>>> a_list = [number for number in range(1,6) if number % 2 == 1]

>>> a_list

[1, 3, 5]

Теперь включение выглядит чуть более компактно, чем его традиционный аналог:

>>> a_list = []

>>> for number in range(1,6):

…·····if number % 2 == 1:

…·········a_list.append(number)

…

>>>··a_list

[1, 3, 5]

Наконец, точно так же, как и в случае вложенных циклов, можно написать более чем один набор операторов for… в соответствующем выделении. Чтобы продемонстрировать это, сначала создадим старый добрый вложенный цикл и выведем на экран результат:

>>> rows = range(1,4)

>>> cols = range(1,3)

>>> for row in rows:

…·····for col in cols:

…·········print(row, col)

…

1 1

1 2

2 1

2 2

3 1

3 2

Теперь воспользуемся включением и присвоим его переменной cells, создавая тем самым список кортежей (row, col):

>>> rows = range(1,4)

>>> cols = range(1,3)

>>> cells = [(row, col) for row in rows for col in cols]

>>> for cell in cells:

…·····print(cell)

…

(1, 1)

(1, 2)

(2, 1)

(2, 2)

(3, 1)

(3, 2)

Кстати, вы можете воспользоваться распаковкой кортежа, чтобы выдернуть значения row и col из каждого кортежа по мере итерирования по списку cells:

>>> for row, col in cells:

…·····print(row, col)

…

1 1

1 2

2 1

2 2

3 1

3 2

Фрагменты for row… и for col… во включении также могут иметь свои проверки if.

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

{ выражение_ключа: выражение_значения for выражение in итерабельный объект }

Как и в случае с включениями списка, выделения словарей также имеют проверки if и несколько операторов for:

>>> word = 'letters'

>>> letter_counts = {letter: word.count(letter) for letter in word}

>>> letter_counts

{'l': 1, 'e': 2, 't': 2, 'r': 1, 's': 1}

Мы запускаем цикл, проходя по каждой из семи букв в строке letters, и считаем, сколько раз появляется эта буква. Два наших вызова word.count(letter) — это лишь пустая трата времени, поскольку нам нужно подсчитать буквы «e» и «t» два раза. Но когда мы считаем буквы «e» во второй раз, то не причиняем вреда, поскольку лишь заменяем уже существующую запись в словаре; то же относится и к подсчету букв «t». Следующий способ решения задачи более характерен для Python:

>>> word = 'letters'

>>> letter_counts = {letter: word.count(letter) for letter in set(word)}

>>> letter_counts

{'t': 2, 'l': 1, 'e': 2, 'r': 1, 's': 1}

Ключи словаря располагаются в ином, чем в предыдущем примере, порядке, поскольку итерирование по результату работы функции set(word) возвращает буквы в другом порядке, нежели итерирование по строке word.

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

{ выражение for выражение in итерабельный объект}

Более длинные версии (проверки if, множественные операторы for) также доступны для множеств:

>>> a_set = {number for number in range(1,6) if number % 3 == 1}

>>> a_set

{1, 4}

Для кортежей не существует включений. Вы могли подумать, что замена квадратных скобок у выделения списка на круглые создаст включение кортежа. Может даже показаться, что это работает, поскольку исключение не будет сгенерировано, если вы напишете следующее:

>>> number_thing = (number for number in range(1, 6))

В круглые скобки заключено включение генератора, оно возвращает объект генератора:

>>> type(number_thing)

<class 'generator'>

Сами генераторы мы рассмотрим более детально позже в данной главе. Применение генераторов — это один из способов предоставить данные итератору.

Вы можете итерировать непосредственно по этому объекту генератора, как показано здесь:

>>> for number in number_thing:

…·····print(number)

…

1

2

3

4

5

Или же вы можете обернуть вызов list() вокруг включения генератора, чтобы заставить его работать как включение списка:

>>> number_list = list(number_thing)

>>> number_list

[1, 2, 3, 4, 5]

До этого момента все наши примеры кода представляли собой небольшие фрагменты. Они годятся для решения небольших задач, но никто не хочет набирать эти фрагменты раз за разом. Нам нужен какой-то способ организовать большой фрагмент кода в более удобные фрагменты.

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

С функцией можно сделать две вещи:

• определить;

• вызвать.

Чтобы определить функцию, вам нужно написать def, имя функции, входные параметры, заключенные в скобки, и, наконец, двоеточие (:). Имена функций подчиняются тем же правилам, что и имена переменных (они должны начинаться с буквы или _ и содержать только буквы, цифры или _).

Давайте действовать пошагово. Сначала определим и вызовем функцию, которая не имеет параметров. Перед вами пример простейшей функции:

>>> def do_nothing():

…·····pass

Даже если функции не нужны параметры, вам все равно придется указать круглые скобки и двоеточие в ее определении. Следующую строку необходимо выделить пробелами точно так же, как если бы это был оператор if. Python требует использовать выражение pass, чтобы показать, что функция ничего не делает. Это эквивалентно утверждению «Эта страница специально оставлена пустой» (несмотря на то что теперь это не так).

Функцию можно вызвать, просто написав ее имя и скобки. Она сработает так, как я и обещал, вполне успешно не сделав ничего:

>>> do_nothing()

>>>

Теперь определим и вызовем другую функцию, которая не имеет параметров и выводит на экран одно слово:

>>> def make_a_sound():

…·····print('quack')

…

>>> make_a_sound()

quack

Когда вы вызываете функцию make_a_sound(), Python выполняет код, расположенный внутри ее описания. В этом случае он выводит одно слово и возвращает управление основной программе.

Попробуем написать функцию, которая не имеет параметров, но возвращает значение:

>>> def agree():

…····return True

…

Вы можете вызвать эту функцию и проверить возвращаемое ею значение с помощью if:

>>> if agree():

…·····print('Splendid!')

… else:

…·····print('That was unexpected.')

…

Splendid!

Только что вы сделали большой шаг. Комбинация функций с проверками вроде if и циклами вроде while позволяет вам делать ранее недоступные вещи.

Теперь пришло время поместить что-нибудь в эти скобки. Определим функцию echo(), имеющую один параметр anything. Она использует оператор return, чтобы отправить значение anything вызывающей стороне дважды, разделив их пробелом:

>>> def echo(anything):

…····return anything + ' ' + anything

…

>>>

Теперь вызовем функцию echo(), передав ей строку 'Rumplestiltskin':

>>> echo('Rumplestiltskin')

'Rumplestiltskin Rumplestiltskin'

Значения, которые вы передаете в функцию при вызове, называются аргументами. Когда вы вызываете функцию с аргументами, значения этих аргументов копируются в соответствующие параметры внутри функций. В предыдущем примере функции echo() передавалась строка 'Rumplestiltskin'. Это значение копировалось внутри функции echo() в параметр anything, а затем возвращалось (в этом случае оно удваивалось и разделялось пробелом) вызывающей стороне.

Эти примеры функций довольно просты. Напишем функцию, которая принимает аргумент и что-то с ним делает. Мы адаптируем предыдущий фрагмент кода, который комментировал цвета. Назовем его commentary и сделаем так, чтобы он принимал в качестве аргумента строку color. Сделаем так, чтобы он возвращал описание строки вызывающей стороне, которая может решить, что с ним делать дальше:

>>> def commentary(color):

…·····if color == 'red':

…·········return "It's a tomato."

…·····elif color == "green":

…·········return "It's a green pepper."

…·····elif color == 'bee purple':

…·········return "I don't know what it is, but only bees can see it."

…·····else:

…·········return "I've never heard of the color "··+ color +··"."

…

>>>

Вызовем функцию commentary(), передав ей в качестве аргумента строку 'blue'.

>>> comment = commentary('blue')

Функция сделает следующее:

• присвоит значение 'blue' параметру функции color;

• пройдет по логической цепочке if-elif-else;

• вернет строку;

• присвоит строку переменной comment.

Что мы получим в результате?

>>> print(comment)

I've never heard of the color blue.

Функция может принимать любое количество аргументов (включая нуль) любого типа. Она может возвращать любое количество результатов (также включая нуль) любого типа. Если функция не вызывает return явно, вызывающая сторона получит результат None.

>>> print(do_nothing())

None

None может быть полезным

None — это специальное значение в Python, которое заполняет собой пустое место, если функция ничего не возвращает. Оно не является булевым значением False, несмотря на то что похоже на него при проверке булевой переменной. Рассмотрим пример:

>>> thing = None

>>> if thing:

…·····print("It's some thing")

… else:

…·····print("It's no thing")

…

It's no thing

Для того чтобы понять важность отличия None от булева значения False, используйте оператор is:

>>> if thing is None:

…·····print("It's nothing")

… else:

…·····print("It's something")

…

It's nothing

Разница кажется небольшой, однако она важна в Python. None потребуется вам, чтобы отличить отсутствующее значение от пустого. Помните, что целочисленные нули, нули с плавающей точкой, пустые строки (''), списки ([]), кортежи ((,)), словари ({}) и множества (set()) все равны False, но не равны None.

Напишем небольшую функцию, которая выводит на экран проверку на равенство None:

>>> def is_none(thing):

…·····if thing is None:

…·········print("It's None")

…·····elif thing:

…·········print("It's True")

…·····else:

…·········print("It's False")

…

Теперь выполним несколько проверок:

>>> is_none(None)

It's None

>>> is_none(True)

It's True

>>> is_none(False)

It's False

>>> is_none(0)

It's False

>>> is_none(0.0)

It's False

>>> is_none(())

It's False

>>> is_none([])

It's False

>>> is_none({})

It's False

>>> is_none(set())

It's False

Python довольно гибко обрабатывает аргументы функций в сравнении с многими языками программирования. Наиболее распространенный тип аргументов — это позиционные аргументы, чьи значения копируются в соответствующие параметры согласно порядку следования.

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

>>> def menu(wine, entree, dessert):

…·····return {'wine': wine, 'entree': entree, 'dessert': dessert}

…

>>> menu('chardonnay', 'chicken', 'cake')

{'dessert': 'cake', 'wine': 'chardonnay', 'entree': 'chicken'}

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

>>> menu('beef', 'bagel', 'bordeaux')

{'dessert': 'bordeaux', 'wine': 'beef', 'entree': 'bagel'}

Для того чтобы избежать путаницы с позиционными аргументами, вы можете указать аргументы с помощью имен соответствующих параметров. Порядок следования аргументов в этом случае может быть иным:

>>> menu(entree='beef', dessert='bagel', wine='bordeaux')

{'dessert': 'bagel', 'wine': 'bordeaux', 'entree': 'beef'}

Вы можете объединять позиционные аргументы и аргументы — ключевые слова. Сначала выберем вино, а для десерта и основного блюда используем аргументы — ключевые слова.

>>> menu('frontenac', dessert='flan', entree='fish')

{'entree': 'fish', 'dessert': 'flan', 'wine': 'frontenac'}

Если вы вызываете функцию, имеющую как позиционные аргументы, так и аргументы — ключевые слова, то позиционные аргументы необходимо указывать первыми.

Вы можете указать значения по умолчанию для параметров. Значения по умолчанию используются в том случае, если вызывающая сторона не предоставила соответствующий аргумент. Эта приятная особенность может оказаться довольно полезной. Воспользуемся предыдущим примером:

>>> def menu(wine, entree, dessert='pudding'):

…·····return {'wine': wine, 'entree': entree, 'dessert': dessert}

В этот раз мы вызовем функцию menu(), не передав ей аргумент dessert:

>>> menu('chardonnay', 'chicken')

{'dessert': 'pudding', 'wine': 'chardonnay', 'entree': 'chicken'}

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

>>> menu('dunkelfelder', 'duck', 'doughnut')

{'dessert': 'doughnut', 'wine': 'dunkelfelder', 'entree': 'duck'}

Если вы работали с языками программирования C или C++, то можете предположить, что астериск (*) в Python как-то относится к указателям. Это не так, Python не имеет указателей.

Если символ * будет использован внутри функции с параметром, произвольное количество позиционных аргументов будет сгруппировано в кортеж. В следующем примере args является кортежем параметров, который был создан из аргументов, переданных в функцию print_args():

>>> def print_args(*args):

…·····print('Positional argument tuple:', args)

…

Если вы вызовете функцию без аргументов, то получите пустой кортеж:

>>> print_args()

Positional argument tuple: ()

Все аргументы, которые вы передадите, будут выведены на экран как кортеж args:

>>> print_args(3, 2, 1, 'wait!', 'uh…')

Positional argument tuple: (3, 2, 1, 'wait!', 'uh…')

Это полезно при написании функций вроде print(), которые принимают произвольное количество аргументов. Если в вашей функции имеются также обязательные позиционные аргументы, *args отправится в конец списка и получит все остальные аргументы:

>>> def print_more(required1, required2, *args):

…·····print('Need this one:', required1)

…·····print('Need this one too:', required2)

…·····print('All the rest:', args)

…

>>> print_more('cap', 'gloves', 'scarf', 'monocle', 'mustache wax')

Need this one: cap

Need this one too: gloves

All the rest: ('scarf', 'monocle', 'mustache wax')

При использовании * вам не нужно обязательно называть кортеж параметров args, однако это распространенная идиома в Python.

Вы можете использовать два астериска (**), чтобы сгруппировать аргументы — ключевые слова в словарь, где имена аргументов станут ключами, а их значения — соответствующими значениями в словаре. В следующем примере определяется функция print_kwargs(), в которой выводятся ее аргументы — ключевые слова:

>>> def print_kwargs(**kwargs):

…·····print('Keyword arguments:', kwargs)

…

Теперь попробуйте вызвать ее, передав несколько аргументов:

>>> print_kwargs(wine='merlot', entree='mutton', dessert='macaroon')

Keyword arguments: {'dessert': 'macaroon', 'wine': 'merlot', 'entree': 'mutton'}

Внутри функции kwargs является словарем.

Если вы используете позиционные аргументы и аргументы — ключевые слова (*args и **kwargs), они должны следовать в этом же порядке. Как и в случае с args, вам не обязательно называть этот словарь kwargs, но это опять же является распространенной практикой.

Дзен Python гласит: удобочитаемость имеет значение. Вы можете прикрепить документацию к определению функции, включив строку в начало ее тела. Она называется строкой документации:

>>> def echo(anything):

…·····'echo returns its input argument'

…·····return anything

Вы можете сделать строку документации довольно длинной и даже, если хотите, применить к ней форматирование, что показано в следующем примере:

def print_if_true(thing, check):

····'''

····Prints the first argument if a second argument is true.

····The operation is:

········1. Check whether the *second* argument is true.

········2. If it is, print the *first* argument.

····'''

····if check:

········print(thing)

Для того чтобы вывести строку документации некоторой функции, вам следует вызвать функцию help(). Передайте ей имя функции, чтобы получить список всех аргументов и красиво отформатированную строку документации:

>>> help(echo)

Help on function echo in module __main__:

echo(anything)

····echo returns its input argument

Если вы хотите увидеть только строку документации без форматирования:

>>> print(echo.__doc__)

echo returns its input argument

Подозрительно выглядящая строка __doc__ является внутренним именем строки документации как переменной внутри функции. В пункте «Использование _ и __ в именах» в разделе «Пространства имен и область определения» данной главы объясняется причина появления всех этих нижних подчеркиваний.

Я уже упоминал мантру Python: объектами является все, включая числа, строки, кортежи, списки, словари и даже функции. Функции в Python являются объектами первого класса. Вы можете присвоить их переменным, использовать как аргументы для других функций и возвращать из функций. Это дает вам возможность решать с помощью Python такие задачи, справиться с которыми средствами многих других языков сложно, если не невозможно.

Для того чтобы убедиться в этом, определим простую функцию answer(), которая не имеет аргументов и просто выводит число 42:

>>> def answer():

…·····print(42)

Вы знаете, что получите в качестве результата, если запустите эту функцию:

>>> answer()

42

Теперь определим еще одну функцию с именем run_something. Она имеет один аргумент, который называется func и представляет собой функцию, которую нужно запустить. Эта функция просто вызывает другую функцию:

>>> def run_something(func):

…·····func()

Если мы передадим answer в функцию run_something(), то используем ее как данные, прямо как и другие объекты:

>>> run_something(answer)

42

Обратите внимание: вы передали строку answer, а не answer(). В Python круглые скобки означают «вызови эту функцию». Если скобок нет, Python относится к функции как к любому другому объекту. Это происходит потому, что, как и все остальное в Python, функция является объектом:

>>> type(run_something)

<class 'function'>

Попробуем запустить функцию с аргументами. Определим функцию add_args(), которая выводит на экран сумму двух числовых аргументов, arg1 и arg2:

>>> def add_args(arg1, arg2):

…·····print(arg1 + arg2)

Чем является add_args()?

>>> type(add_args)

<class 'function'>

Теперь определим функцию, которая называется run_something_with_args() и принимает три аргумента:

• func — функция, которую нужно запустить;

• arg1 — первый аргумент функции func;

• arg2 — второй аргумент функции func:

>>> def run_something_with_args(func, arg1, arg2):

…·····func(arg1, arg2)

Когда вы вызываете функцию run_something_with_args(), та функция, что передается вызывающей стороной, присваивается параметру func, а переменные arg1 и arg2 получают значения, которые следуют далее в списке аргументов. Вызов func(arg1, arg2) выполняет данную функцию с этими аргументами, потому что круглые скобки указывают Python сделать это.

Проверим функцию run_something_with_args(), передав ей имя функции add_args и аргументы 5 и 9:

>>> run_something_with_args(add_args, 5, 9)

14

Внутри функции run_something_with_args() аргумент add_args, представляющий собой имя функции, был присвоен параметру func, 5 — параметру arg1, а 9 — параметру arg2. В итоге получается следующая конструкция:

add_args(5, 9)

Вы можете объединить этот прием с использованием *args и **kwargs.

Определим тестовую функцию, которая принимает любое количество позиционных аргументов, определяет их сумму с помощью функции sum() и возвращает ее:

>>> def sum_args(*args):

…····return sum(args)

Я не упоминал функцию sum() ранее. Это встроенная в Python функция, которая высчитывает сумму значений итерабельного числового (целочисленного или с плавающей точкой) аргумента.

Мы определим новую функцию run_with_positional_args(), принимающую функцию и произвольное количество позиционных аргументов, которые нужно будет передать в нее:

>>> def run_with_positional_args(func, *args):

…····return func(*args)

Теперь вызовем ее:

>>> run_with_positional_args(sum_args, 1, 2, 3, 4)

10

Вы можете использовать функции как элементы списков, кортежей, множеств и словарей. Функции неизменяемы, поэтому вы можете даже применять их как ключи для словарей.

Вы можете определить функцию внутри другой функции:

>>> def outer(a, b):

…·····def inner(c, d):

…·········return c + d

…·····return inner(a, b)

…

>>>

>>> outer(4, 7)

11

Внутренние функции могут быть полезны при выполнении некоторых сложных задач более одного раза внутри другой функции. Это позволит избежать использования циклов или дублирования кода. Рассмотрим пример работы со строкой, когда внутренняя функция добавляет текст к своему аргументу:

>>> def knights(saying):

…·····def inner(quote):

…·········return "We are the knights who say: '%s'" % quote

…·····return inner(saying)

…

>>> knights('Ni!')

"We are the knights who say: 'Ni!'"

Внутренняя функция может действовать как замыкание. Замыкание — это функция, которая динамически генерируется другой функцией, и они обе могут изменяться и запоминать значения переменных, которые были созданы вне функции.

Следующий пример создан на основе предыдущего примера knights(). Назовем новую функцию knights2(), поскольку у нас нет воображения, и превратим функцию inner() в замыкание, которое называется inner2(). Различия заключаются в следующем.

• inner2() использует внешний параметр saying непосредственно, вместо того чтобы получить его как аргумент.

• knights2() возвращает имя функции inner2, вместо того чтобы вызывать ее:

>>> def knights2(saying):

…·····def inner2():

…·········return "We are the knights who say: '%s'" % saying

…·····return inner2

…

Функция inner2() знает значение переменой saying, которое было передано в функцию, и запоминает его. Строка inner2 возвращает эту особую копию функции inner2, но не вызывает ее. Это и есть замыкание: динамически созданная функция, которая запоминает, откуда она появилась.

Вызовем функцию knights2() два раза с разными аргументами:

>>> a = knights2('Duck')

>>> b = knights2('Hasenpfeffer')

О’кей, чем являются a и b?

>>> type(a)

<class 'function'>

>>> type(b)

<class 'function'>

Они являются функциями, а также замыканиями:

>>> a

<function knights2.<locals>.inner2 at 0x10193e158>

>>> b

<function knights2.<locals>.inner2 at 0x10193e1e0>

Если мы вызовем их, они запомнят значение переменной saying, которое было использовано, когда они были созданы функцией knights2:

>>> a()

"We are the knights who say: 'Duck'"

>>> b()

"We are the knights who say: 'Hasenpfeffer'"

В Python лямбда-функция — это анонимная функция, выраженная одним выражением. Вы можете использовать ее вместо обычной маленькой функции.

Для того чтобы проиллюстрировать анонимные функции, сначала создадим пример, в котором используются обычные функции. Для начала мы определим функцию edit_story(). Она имеет следующие аргументы:

• words — список слов;

• func — функция, которая должна быть применена к каждому слову в списке words:

>>> def edit_story(words, func):

…·····for word in words:

…·········print(func(word))

Теперь нам нужны список слов и функция, которую требуется к ним применить. В качестве слов я возьму список звуков (гипотетических), которые мог бы издать мой кот, если бы (гипотетически) он не заметил одну из лестниц:

>>> stairs = ['thud', 'meow', 'thud', 'hiss']

Функция же запишет с большой буквы каждое слово и добавит к нему восклицательный знак, что идеально подойдет для заголовка какой-нибудь желтой кошачьей газетенки:

>>> def enliven(word):···# больше эмоций!

…·····return word.capitalize() + '!'

Смешаем наши ингредиенты:

>>> edit_story(stairs, enliven)

Thud!

Meow!

Thud!

Hiss!

Наконец переходим к лямбде. Функция enliven() была такой короткой, что мы можем заменить ее лямбдой:

>>>

>>> edit_story(stairs, lambda word: word.capitalize() + '!')

Thud!

Meow!

Thud!

Hiss!

>>>

Лямбда принимает один аргумент, который в этом примере назван word. Все, что находится между двоеточием и закрывающей скобкой, является определением функции.

Часто использование настоящих функций вроде enliven() гораздо прозрачнее, чем использование лямбд. Лямбды наиболее полезны в случаях, когда вам нужно определить множество мелких функций и запомнить все их имена. В частности, вы можете использовать лямбды в графических пользовательских интерфейсах, чтобы определить функции внешнего вызова. Примеры вы можете найти в приложении А.

Мы собираемся перейти на новый уровень — создание и использование кода более чем из одного файла. Модуль — это всего лишь файл, содержащий код Python.

Текст этой книги организован в иерархию: слова, предложения, абзацы и главы. В противном случае он стал бы нечитаемым спустя пару страниц. У кода имеется подобная организация: типы данных похожи на слова, операторы и выражения — это предложения, функции — это абзацы, а модули — это главы. Продолжу аналогию: когда я говорю, что что-то будет более подробно рассмотрено в главе 8, в программировании это было бы похоже на отсылку к коду другого модуля.

Мы ссылаемся на код других модулей с помощью оператора import. Оно позволяет получить доступ к коду и переменным этого модуля из вашей программы.

Простейший вариант использования оператора import выглядит как import модуль, где модуль — это имя другого файла Python без расширения. py. Симулируем работу метеостанции и выведем на экран отчет о погоде. Основная программа выведет на экран отчет, а отдельный модуль, содержащий одну функцию, вернет описание погоды, которое будет использовано в отчете.

Основная программа выглядит так (назовем ее weatherman.py):

import report

description = report.get_description()

print("Today's weather: ", description)

А ее модуль (report.py) — так:

def get_description():··# смотрите строку документации

····"""Return random weather, just like the pros"""

····from random import choice

····possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows']

····return choice(possibilities)

Если вы поместите оба этих файла в один каталог и укажете Python запустить файл weatherman.py в качестве основной программы, он обратится к модулю report и запустит его функцию get_description(). Мы написали эту версию функции get_description() так, чтобы она возвращала случайную строку из списка, которую выведет на экран основная программа:

$ python weatherman.py

Today's weather: who knows

$ python weatherman.py

Today's weather: sun

$ python weatherman.py

Today's weather: sleet

Мы использовали оператор import в двух местах.

• В основной программе weatherman.py, импортируемой модулем report.

• В файле модуля report.py функция get_description() импортирует функцию choice из стандартного модуля Python random.

Мы также использовали эти операторы двумя разными способами.

• Основная программа делала вызов import report и затем вызывала функцию report.get_description().

• Функция get_description() из модуля report.py содержит вызовы from random import choice и choice(possibilities).

В первом случае мы импортировали модуль report целиком, при этом нам нужно было добавить префикс report., чтобы вызвать функцию get_description(). После этого оператора import все содержимое файла report.py становится доступным основной программе, нужно лишь ставить перед именем вызываемой функции префикс report.. Путем уточнения содержимого модуля с помощью его имени мы избегаем возникновения неприятных конфликтов именования. В каком-то другом модуле также может быть функция get_descpirtion(), и мы не вызовем ее по ошибке.

Во втором случае мы находимся внутри функции и знаем, что существует только одна функция с именем choice, поэтому импортируем функцию choice() непосредственно из модуля random. Мы могли бы написать функцию как следующий сниппет, который возвращает случайный результат:

def get_description():

····import random

····possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows']

····return random.choice(possibilities)

Как и для многих других аспектов программирования, выбирайте стиль, который кажется вам наиболее прозрачным. Имя функции, перед которым стоит имя модуля (random.choice), использовать безопаснее, однако из-за этого придется набирать немного больше текста.

Эти примеры применения функции get_description() продемонстрировали варианты того, что можно импортировать, но не показали, где следует выполнять импортирование, — в них import вызывался изнутри функции. Мы могли бы импортировать random из другой функции:

>>> import random

>>> def get_description():

…····possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows']

…····return random.choice(possibilities)

…

>>> get_description()

'who knows'

>>> get_description()

'rain'

Вам следует рассмотреть возможность импортировать код вне функции, если импортируемый код может быть использован более одного раза, и изнутри функции, если вы знаете, что использование кода будет ограничено. Некоторые люди предпочитают размещать все операторы import в верхней части файла, чтобы явно обозначить все зависимости их кода. Оба варианта работают.

В нашей основной программе weatherman.py мы делали вызов import report. Но что, если у вас есть другой модуль с таким же именем или вы хотите использовать более короткое или простое имя? В такой ситуации можете выполнить импорт с помощью псевдонима. Используем псевдоним wr:

import report as wr

description = wr.get_description()

print("Today's weather: ", description)

С помощью Python вы можете импортировать одну или несколько частей модуля. Каждая часть может сохранить свое оригинальное имя, или же вы можете дать ей alias. Для начала импортируем функцию get_description() из модуля report с помощью его оригинального имени:

from report import get_description

description = get_description()

print("Today's weather: ", description)

Теперь импортируем ее как do_it:

from report import get_description as do_it

description = do_it()

print("Today's weather: ", description)

Где Python ищет файлы для импорта? Он использует список имен каталогов и ZIP-архив, хранящийся в стандартном модуле sys, как переменную path. Вы можете получить доступ к этому списку и изменить его. Вот так выглядит значение переменной sys.path в Python 3.3 в моей версии операционной системы Mac:

>>> import sys

>>> for place in sys.path:

…·····print(place)

…

/Library/Frameworks/Python.framework/Versions/3.3/lib/python33.zip

/Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3

/Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/plat-darwin

/Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/lib-dynload

/Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/site-packages

Пустое место в начале вывода содержит в себе строку '', которая символизирует текущий каталог. Если строка '' находится первой в sys.path, Python сначала выполнит поиск в текущем каталоге, когда вы попробуете что-то импортировать: import report выглядит как report.py.

Будет использован первый найденный модуль. Это означает, что, если вы определите модуль с именем random и он будет найден раньше оригинального модуля, вы не получите доступ к стандартной библиотеке random.

Одно из основных преимуществ Python заключается в том, что у него есть собственный «запас мощности» — большая стандартная библиотека модулей, которые выполняют множество полезных задач и располагаются отдельно друг от друга, чтобы избежать разрастания ядра языка. Когда вы собираетесь писать код, зачастую сначала стоит проверить, существует ли стандартный модуль, который уже делает то, что вы хотите. Удивительно, как часто вы будете встречать эти небольшие жемчужины в стандартной библиотеке. Python также предоставляет авторитетную документацию для модулей наряду с руководством для пользователей (http://docs.python.org/3/library). Сайт Дага Хеллмана (Doug Hellmann) Python Module of the Week (http://bit.ly/py-motw) и его книга The Python Standard Library by Example («Стандартная библиотека Python в примерах»), выпущенная издательством Addison-Wesley Professional, также являются очень полезными руководствами.

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

Вы уже видели, что попытка получить доступ к словарю с помощью несуществующего ключа генерирует исключение. Использование функции словаря get() для того, чтобы вернуть значение по умолчанию, помогает этого избежать.

Функция setdefault() похожа на функцию get(), но она также присваивает элемент словарю, если заданный ключ отсутствует:

>>> periodic_table = {'Hydrogen': 1, 'Helium': 2}

>>> print(periodic_table)

{'Helium': 2, 'Hydrogen': 1}

Если ключа еще нет в словаре, будет использовано новое значение:

>>> carbon = periodic_table.setdefault('Carbon', 12)

>>> carbon

12

>>> periodic_table

{'Helium': 2, 'Carbon': 12, 'Hydrogen': 1}

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

>>> helium = periodic_table.setdefault('Helium', 947)

>>> helium

2

>>> periodic_table

{'Helium': 2, 'Carbon': 12, 'Hydrogen': 1}

Функция defaultdict() похожа на предыдущую, но она определяет значение по умолчанию для новых ключей заранее, при создании словаря. В этом примере мы передаем функцию int, которая будет вызываться как int(), и возвращаем значение 0:

>>> from collections import defaultdict

>>> periodic_table = defaultdict(int)

Теперь любое отсутствующее значение будет заменяться целым числом (int) 0:

>>> periodic_table['Hydrogen'] = 1

>>> periodic_table['Lead']

0

>>> periodic_table

defaultdict(<class 'int'>, {'Lead': 0, 'Hydrogen': 1})

Аргументом defaultdict() является функция, возвращающая значение, которое будет присвоено отсутствующему ключу. В следующем примере функция no_idea() будет вызываться всякий раз, когда нужно вернуть значение:

>>> from collections import defaultdict

>>>

>>> def no_idea():

…·····return 'Huh?'

…

>>> bestiary = defaultdict(no_idea)

>>> bestiary['A'] = 'Abominable Snowman'

>>> bestiary['B'] = 'Basilisk'

>>> bestiary['A']

'Abominable Snowman'

>>> bestiary['B']

'Basilisk'

>>> bestiary['C']

'Huh?'

Вы можете использовать функции int(), list() или dict(), чтобы возвращать пустые значения по умолчанию: int() возвращает 0, list() возвращает пустой список ([]) и dict() возвращает пустой словарь ({}). Если вы опустите аргумент, исходное значение нового ключа будет равно None.

Кстати, вы можете использовать lambda для того, чтобы определить функцию по умолчанию изнутри вызова:

>>> bestiary = defaultdict(lambda: 'Huh?')

>>> bestiary['E']

'Huh?'

Применение int — это один из способов создать ваш собственный прилавок:

>>> from collections import defaultdict

>>> food_counter = defaultdict(int)

>>> for food in ['spam', 'spam', 'eggs', 'spam']:

…·····food_counter[food] += 1

…

>>> for food, count in food_counter.items():

…·····print(food, count)

…

eggs 1

spam 3

В предыдущем примере, если бы food_counter был обычным словарем, а не defaultdict, Python генерировал бы исключение всякий раз, когда бы мы пытались увеличить элемент словаря food_counter[food], поскольку он был бы не инициализирован. Нам понадобилось бы сделать дополнительную работу, как показано здесь:

>>> dict_counter = {}

>>> for food in ['spam', 'spam', 'eggs', 'spam']:

…·····if not food in dict_counter:

…·········dict_counter[food] = 0

…·····dict_counter[food] += 1

…

>>> for food, count in dict_counter.items():

…·····print(food, count)

…

spam 3

eggs 1

Если говорить о счетчиках, то в стандартной библиотеке имеется счетчик, который решает задачу, показанную в предыдущем примере, и даже больше:

>>> from collections import Counter

>>> breakfast = ['spam', 'spam', 'eggs', 'spam']

>>> breakfast_counter = Counter(breakfast)

>>> breakfast_counter

Counter({'spam': 3, 'eggs': 1})

Функция most_common() возвращает все элементы в убывающем порядке или лишь те элементы, количество которых больше, чем заданный аргумент count:

>>> breakfast_counter.most_common()

[('spam', 3), ('eggs', 1)]

>>> breakfast_counter.most_common(1)

[('spam', 3)]

Счетчики можно объединять. Для начала снова взглянем на содержимое breakfast_counter:

>>> breakfast_counter

>>> Counter({'spam': 3, 'eggs': 1})

Теперь мы создадим новый список, который называется lunch, и счетчик, который называется lunch_counter:

>>> lunch = ['eggs', 'eggs', 'bacon']

>>> lunch_counter = Counter(lunch)

>>> lunch_counter

Counter({'eggs': 2, 'bacon': 1})

Счетчики можно объединить с помощью оператора +:

>>> breakfast_counter + lunch_counter

Counter({'spam': 3, 'eggs': 3, 'bacon': 1})

Как вы можете догадаться, счетчики можно вычитать друг из друга с помощью оператора —. Что мы будем есть на завтрак, но не на обед?

>>> breakfast_counter — lunch_counter

Counter({'spam': 3})

О’кей, теперь узнаем, что мы можем съесть на обед, но не можем на завтрак:

>>> lunch_counter — breakfast_counter

Counter({'bacon': 1, 'eggs': 1})

По аналогии с множествами, показанными в главе 4, вы можете получить общие элементы с помощью оператора пересечения &:

>>> breakfast_counter & lunch_counter

Counter({'eggs': 1})

В результате пересечения был получен общий элемент ('eggs') с низким значением счетчика. Это имеет смысл: на завтрак у нас было только одно яйцо, поэтому указанное количество является общим.

Наконец, вы можете получить все элементы с помощью оператора объединения |:

>>> breakfast_counter | lunch_counter

Counter({'spam': 3, 'eggs': 2, 'bacon': 1})

Элемент 'eggs' снова оказался общим для обоих счетчиков. В отличие от сложения объединение не складывает счетчики, а выбирает тот, который имеет наибольшее значение.

Многие примеры кода, показанные в первых главах этой книги, демонстрируют, что порядок ключей в словаре нельзя предсказать: вы можете добавить в определенном порядке ключи a, b и c, но функция keys() вернет результат "c, a, b". Рассмотрим модифицированный пример из главы 1:

>>> quotes = {

…·····'Moe': 'A wise guy, huh?',

…·····'Larry': 'Ow!',

…·····'Curly': 'Nyuk nyuk!',

…·····}

>>> for stooge in quotes:

…··print(stooge)

…

Larry

Curly

Moe

Словарь OrderedDict() запоминает порядок, в котором добавлялись ключи, и возвращает их в том же порядке с помощью итератора. Попробуем создать OrderedDict из последовательности кортежей вида «ключ — значение»:

>>> from collections import OrderedDict

>>> quotes = OrderedDict([

…·····('Moe', 'A wise guy, huh?'),

…·····('Larry', 'Ow!'),

…·····('Curly', 'Nyuk nyuk!'),

…·····])

>>>

>>> for stooge in quotes:

…·····print(stooge)

…

Moe

Larry

Curly

deque (произносится как «дэк») — это двухсторонняя очередь, которая имеет возможности стека и очереди. Она полезна, когда вы хотите добавить и удалить элементы с любого конца последовательности. В следующем примере мы будем двигаться с обоих концов слова к его середине, чтобы увидеть, является ли оно палиндромом. Функция popleft() удаляет крайний слева элемент deque и возвращает его, функция pop() удаляет крайний справа элемент и возвращает его. Вместе они двигаются с концов слова к его середине. Работа будет продолжаться до тех пор, пока крайние символы совпадают и пока не будет достигнута середина:

>>> def palindrome(word):

…·····from collections import deque

…·····dq = deque(word)

…·····while len(dq) > 1:

…········if dq.popleft()!= dq.pop():

…············return False

…·····return True

…

…

>>> palindrome('a')

True

>>> palindrome('racecar')

True

>>> palindrome('')

True

>>> palindrome('radar')

True

>>> palindrome('halibut')

False

Я воспользовался этим примером, чтобы было проще проиллюстрировать работу deque. Если вы действительно хотите создать программу, которая определяет палиндромы, гораздо проще было бы сравнивать строку с ее копией, вывернутой наизнанку. В Python строковой функции reverse() не существует, но можно обратить строку с помощью разбиения, как показано здесь:

>>> def another_palindrome(word):

…·····return word == word[::-1]

…

>>> another_palindrome('radar')

True

>>> another_palindrome('halibut')

False

itertools содержит особые функции итератора. Каждая из них возвращает один элемент при каждом вызове из цикла for … in и запоминает свое состояние между вызовами.

Функция chain() проходит по своим аргументам, как если бы они были единым итерабельным объектом:

>>> import itertools

>>> for item in itertools.chain([1, 2], ['a', 'b']):

…·····print(item)

…

1

2

a

b

Функция cycle() является бесконечным итератором, проходящим в цикле по своим аргументам:

>>> import itertools

>>> for item in itertools.cycle([1, 2]):

…·····print(item)

…

1

2

1

2

.

.

.

…и т. д.

Функция accumulate() подсчитывает накопленные значения. По умолчанию она высчитывает сумму:

>>> import itertools

>>> for item in itertools.accumulate([1, 2, 3, 4]):

…·····print(item)

…

1

3

6

10

В качестве второго аргумента функции accumulate() вы можете передать функцию, и она будет использована вместо сложения. Функция должна принимать два аргумента и возвращать одно значение. В этом примере высчитывается произведение:

>>> import itertools

>>> def multiply(a, b):

…·····return a * b

…

>>> for item in itertools.accumulate([1, 2, 3, 4], multiply):

…·····print(item)

…

1

2

6

24

Модуль itertools имеет еще много функций, он известен благодаря определенным комбинациям и преобразованиям, которые могут сохранить кучу времени, если в них появится необходимость.

Все наши примеры использовали функцию print() (или просто имя переменной в интерактивном интерпретаторе), чтобы выводить информацию на экран. Иногда результаты было трудно прочитать. Нам нужен pretty printer (красивый принтер) вроде pprint():

>>> from pprint import pprint

>>> quotes = OrderedDict([

…·····('Moe', 'A wise guy, huh?'),

…·····('Larry', 'Ow!'),

…·····('Curly', 'Nyuk nyuk!'),

…·····])

>>>

Старая добрая функция print() просто выводит всю информацию:

>>> print(quotes)

OrderedDict([('Moe', 'A wise guy, huh?'), ('Larry', 'Ow!'), ('Curly', 'Nyuk nyuk!')])

А функция pprint() пытается выровнять элементы для лучшей читаемости:

>>> pprint(quotes)

{'Moe': 'A wise guy, huh?',

'Larry': 'Ow!',

'Curly': 'Nyuk nyuk!'}

Текст является наиболее популярным типом данных для большинства читателей, поэтому мы начнем главу с рассмотрения мощных особенностей текстовых строк в Python.

Все текстовые примеры, показанные в книге до этого момента, имели формат ASCII. Этот формат был определен в 1960-х годах, когда компьютеры были размером с холодильник и выполняли вычисления немного лучше последнего. Основной единицей хранения информации был байт, который мог хранить 256 уникальных значений в своих 8 битах. По разным причинам формат ASCII использовал только 7 бит (128 уникальных значений): 26 символов верхнего регистра, 26 символов нижнего регистра, 10 цифр, некоторые знаки препинания, символы пробела и непечатаемые символы.

К сожалению, в мире существует больше букв, чем предоставляет формат ASCII. Вы могли заказать в кафе хот-дог, но не Gewürztraminer (название этого вина в Германии пишется через ü, а во Франции — без него). Было предпринято множество попыток добавить больше букв и символов, и время от времени вы будете встречать их. Вот некоторые из них:

• Latin-1 или ISO 8859-1;

• Windows code page 1252.

Каждый из этих форматов использует все 8 бит, но даже этого недостаточно, особенно когда вам нужно воспользоваться неевропейскими языками. Unicode — это действующий международный стандарт, определяющий символы всех языков мира плюс математические и другие символы.

«Unicode предоставляет уникальный номер каждому символу независимо от платформы, программы и языка» (Консорциум Unicode).

Страница Unicode Code Charts (http://www.unicode.org/charts) содержит ссылки на все определенные на данный момент наборы символов с изображениями. В последней версии (6.2) определяется более 110 000 символов, каждый из которых имеет уникальное имя и идентификационный номер. Символы разбиты на восьмибитные наборы, которые называются плоскостями. Первые 256 плоскостей называются основными многоязычными уровнями. Обратитесь к странице о плоскостях в «Википедии» (http://bit.ly/unicode-plane), чтобы получить более подробную информацию.

Строки в Python 3 являются строками формата Unicode, а не массивом байтов. Одним разграничением между обычными байтовыми строками и строками в формате Unicode Python 3 значительно отличается от Python 2.

Если вы знаете Unicode ID или название символа, то можете использовать его в строке Python. Вот несколько примеров.

• Символ \u, за которым располагаются четыре шестнадцатеричных числа (числа шестнадцатеричной системы счисления, содержащие символы от 0 до 9 и от A до F), определяют символ, находящийся в одной из 256 многоязычных плоскостей Unicode. Первые два числа являются номером плоскости (от 00 до FF), а следующие два — индексом символа внутри плоскости. Плоскость с номером 00 — это старый добрый формат ASCII, и позиции символов в нем такие же, как и в ASCII.

• Для символов более высоких плоскостей нужно больше битов. Управляющая последовательность для них выглядит как \U, за которым следуют восемь шестнадцатеричных символов, крайний слева из них должен быть равен 0.

• Для всех символов конструкция \N{ имя } позволяет указать символ с помощью его стандартного имени. Имена перечислены по адресу http://www.unicode.org/charts/charindex.html.

Модуль unicodedata содержит функции, которые преобразуют символы в обоих направлениях:

• lookup() принимает не зависящее от регистра имя и возвращает символ Unicode;

• name() принимает символ Unicode и возвращает его имя в верхнем регистре.

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

>>> def unicode_test(value):

…·····import unicodedata

…·····name = unicodedata.name(value)

…·····value2 = unicodedata.lookup(name)

…·····print('value="%s", name="%s", value2="%s"' % (value, name, value2))

…

Попробуем проверить несколько символов, начиная с простой буквы формата ASCII:

>>> unicode_test('A')

value="A", name="LATIN CAPITAL LETTER A", value2="A"

Знак препинания, доступный в ASCII:

>>> unicode_test('$')

value="$", name="DOLLAR SIGN", value2="$"

Символ валюты из Unicode:

>>> unicode_test('\u00a2')

value="¢", name="CENT SIGN", value2="¢"

Еще один символ валюты из Unicode:

>>> unicode_test('\u20ac')

value="€", name="EURO SIGN", value2="€"

Единственная проблема, с которой вы можете столкнуться, — это ограничения, накладываемые шрифтом. Ни в одном шрифте нет символов для всех символов Unicode, вместо них будет отображен символ-заполнитель. Например, так выглядит символ Unicode SNOWMAN, содержащийся в пиктографических шрифтах:

>>> unicode_test('\u2603')

value="☃", name="SNOWMAN", value2="☃"

Предположим, мы хотим сохранить в строке слово café. Одно из решений состоит в том, чтобы скопировать его из файла или с сайта и понадеяться, что это сработает:

>>> place = 'café'

>>> place

'café'

Это сработало, поскольку я скопировал это слово из источника, использующего кодировку UTF-8 (с которой вы познакомитесь далее), и вставил его.

Как же нам указать, что последний символ — это «é»? Если вы посмотрите на индекс символа «Е», вы увидите, что имя E WITH ACUTE, LATIN SMALL LETTER имеет индекс 00Е9. Рассмотрим функции name() и lookup(), с которыми мы только что работали. Сначала передадим код символа, чтобы получить его имя:

>>> unicodedata.name('\u00e9')

'LATIN SMALL LETTER E WITH ACUTE'

Теперь найдем код для заданного имени:

>>> unicodedata.lookup('E WITH ACUTE, LATIN SMALL LETTER')

Traceback (most recent call last):

··File "<stdin>", line 1, in <module>

KeyError: "undefined character name 'E WITH ACUTE, LATIN SMALL LETTER'"

До этого момента мы просто игнорировали форматирование текста. В главе 2 были показаны несколько функций для выравнивания строк, а в примерах кода использовалась простая функция print() или даже вывод информации на экран поручался интерактивному интерпретатору. Но теперь мы рассмотрим, как интерполировать данные в строки — другими словами, разместить значения внутри строк, — применяя разные форматы. Вы можете использовать эту возможность, чтобы создавать отчеты и другие документы, для которых нужно задать определенный внешний вид.

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

Старый стиль форматирования строк имеет форму строка % данные. Внутри строки находятся интерполяционные последовательности. В табл. 7.2 показано, что самая простая последовательность — это символ %, за которым следует буква, представляющая тип данных, который должен быть отформатирован.

В главе 2 немного рассматривались операции со строками. Вооружившись этой промежуточной информацией, вы, возможно, использовали простые шаблоны в командной строке, содержащие символ подстановки, вроде ls *.py, что означает «перечислить все имена файлов, заканчивающиеся на. py».

Пришло время рассмотреть более сложный механизм проверки на совпадение с шаблоном — регулярные выражения. Этот механизм поставляется в стандартном модуле re, который мы импортируем. Вы определяете строковый шаблон, совпадения для которого вам нужно найти, и строку-источник, в которой следует выполнить поиск. Простой пример использования выглядит так:

result = re.match('You', 'Young Frankenstein')

В этом примере строка 'You' является шаблоном, а 'Young Frankenstein' — источником, строкой, которую вы хотите проверить. Функция match() проверяет, начинается ли источник с шаблона.

Для более сложных проверок вам нужно скомпилировать шаблон, чтобы ускорить поиск:

youpattern = re.compile('You')

Далее вы можете выполнить проверку с помощью скомпилированного шаблона:

result = youpattern.match('Young Frankenstein')

Функция match() — это не единственный способ сравнить шаблон и источник, существует еще несколько методов.

• search() возвращает первое совпадение, если таковое имеется.

• findall() возвращает список всех непересекающихся совпадений, если таковые имеются.

• split() разбивает источник на совпадения с шаблоном и возвращает список всех фрагментов строки.

• sub() принимает аргумент для замены и заменяет все части источника, совпавшие с шаблоном, на значение этого аргумента.

Начинается ли строка 'Young Frankenstein' со слова 'You'? Рассмотрим пример кода с комментариями:

>>> import re

>>> source = 'Young Frankenstein'

>>> m = re.match('You', source)··# функция начинает работать с начала источника

>>> if m:··# функция возвращает объект; делайте это, чтобы увидеть, что совпало

…·····print(m.group())

…

You

>>> m = re.match('^You', source) # якорь в начале строки делает то же самое

>>> if m:

…·····print(m.group())

…

You

Как насчет 'Frank'?

>>> m = re.match('Frank', source)

>>> if m:

…·····print(m.group())

…

В этот раз функция match() не вернула ничего, и оператор if не запустил оператор print. Как я говорил ранее, функция match() работает только в том случае, если шаблон находится в начале источника. Но функция search() ищет шаблон в любом месте источника:

>>> m = re.search('Frank', source)

>>> if m:

…······print(m.group())

…

Frank

Изменим шаблон:

>>> m = re.match('.*Frank', source)

>>> if m:··# match returns an object

…·····print(m.group())

…

Young Frank

Кратко объясню, как работает наш новый шаблон:

• символ. означает любой символ;

• символ * означает любое количество предыдущих элементов. Если объединить символы.*, они будут означать любое количество символов (даже ноль);

• 'Frank' — это фраза, которую мы хотим найти в любом месте строки.

Функция match() вернула строку, в которой нашлось совпадение с шаблоном.*Frank: 'Young Frank'.

Вы можете использовать функцию search(), чтобы найти шаблон 'Frank' в любом месте строки-источника 'Young Frankenstein', не прибегая к использованию символа подстановки.*:

>>> m = re.search('Frank', source)

>>> if m:··# функция search возвращает объект

…·····print(m.group())

…

Frank

В предыдущих примерах мы искали только одно совпадение. Но что, если вы хотите узнать, сколько раз строка, содержащая один символ n, встречается в строке-источнике?

>>> m = re.findall('n', source)

>>> m···# findall returns a list

['n', 'n', 'n', 'n']

>>> print('Found', len(m), 'matches')

Found 4 matches

Как насчет строки 'n', за которой следует любой символ?

>>> m = re.findall('n.', source)

>>> m

['ng', 'nk', 'ns']

Обратите внимание на то, что в совпадения не была записана последняя строка 'n'. Нам нужно сказать, что символ после 'n' является опциональным, с помощью конструкции?:

>>> m = re.findall('n.?', source)

>>> m

['ng', 'nk', 'ns', 'n']

В следующем примере показано, как разбить строку на список с помощью шаблона, а не простой строки (как это делает метод split()):

>>> m = re.split('n', source)

>>> m····# функция split возвращает список

['You', 'g Fra', 'ke', 'stei', '']

Этот метод похож на метод replace(), но он ищет совпадения с шаблонами, а не простые строки:

>>> m = re.sub('n', '?', source)

>>> m···# sub returns a string

'You?g Fra?ke?stei?'

Многие описания регулярных выражений начинаются с деталей, касающихся того, как их определить. Я считаю, что это ошибка. Язык регулярных выражений не так уж мал сам по себе, слишком много деталей должно вместиться в вашу голову одновременно. Они используют так много знаков препинания, что это выглядит так, будто персонажи мультиков ругаются.

Теперь, когда вы знаете о нужных функциях (match(), search(), findall() и sub()), рассмотрим детали построения регулярных выражений. Создаваемые вами шаблоны подойдут к любой из этих функций.

Самые простые знаки вы уже видели.

• Совпадения с любыми неспециальными символами.

• Любой отдельный символ, кроме \n, — это символ..

• Любое число, включая 0, — это символ *.

• Опциональное значение (0 или 1) — это символ?.

Специальные символы показаны в табл. 7.3.