Файл: Николай Прохоренок Владимир Дронов.pdf

Скачать файл
Заказать решение

ВУЗ: Не указан

Категория: Не указан

Дисциплина: Не указана

Добавлен: 05.12.2023

Просмотров: 815

Скачиваний: 3

ВНИМАНИЕ! Если данный файл нарушает Ваши авторские права, то обязательно сообщите нам.

СОДЕРЖАНИЕ

В этом случае мы получим число 17, как и должно быть. Однако если пользователь вместо числа введет строку, то программа завершится с фатальной ошибкой. Как обработать ошиб- ку, мы разберемся по мере изучения языка. 2.6. Удаление переменных Удалить переменную можно с помощью инструкции del: del <Переменная1>[, ..., <ПеременнаяN>] Глава 2. Переменные 51 Пример удаления одной переменной: >>> x = 10; x 10 >>> del x; x Traceback (most recent call last): File "", line 1, in del x; x NameError: name 'x' is not defined Пример удаления нескольких переменных: >>> x, y = 10, 20 >>> del x, y ГЛ А В А 3 Операторы Операторы позволяют произвести с данными определенные действия. Например, операто- ры присваивания служат для сохранения данных в переменной, математические операторы позволяют выполнить арифметические вычисления, а оператор конкатенации строк служит для соединения двух строк в одну. Рассмотрим операторы, доступные в Python 3, подробно. 3.1. Математические операторы Производить операции над числами позволяют математические операторы: + — сложение: >>> 10 + 5 # Целые числа 15 >>> 12.4 + 5.2 # Вещественные числа 17.6 >>> 10 + 12.4 # Целые и вещественные числа 22.4 - — вычитание: >>> 10 - 5 # Целые числа 5 >>> 12.4 - 5.2 # Вещественные числа 7.2 >>> 12 - 5.2 # Целые и вещественные числа 6.8 * — умножение: >>> 10 * 5 # Целые числа 50 >>> 12.4 * 5.2 # Вещественные числа 64.48 >>> 10 * 5.2 # Целые и вещественные числа 52.0 / — деление. Результатом деления всегда является вещественное число, даже если про- изводится деление целых чисел. Обратите внимание на эту особенность, если вы раньше Глава 3. Операторы 53 программировали на Python 2. В Python 2 при делении целых чисел остаток отбрасывал- ся и возвращалось целое число, в Python 3 поведение оператора изменилось: >>> 10 / 5 # Деление целых чисел без остатка 2.0 >>> 10 / 3 # Деление целых чисел с остатком 3.3333333333333335 >>> 10.0 / 5.0 # Деление вещественных чисел 2.0 >>> 10.0 / 3.0 # Деление вещественных чисел 3.3333333333333335 >>> 10 / 5.0 # Деление целого числа на вещественное 2.0 >>> 10.0 / 5 # Деление вещественного числа на целое 2.0 // — деление с округлением вниз. Вне зависимости от типа чисел остаток отбрасывается: >>> 10 // 5 # Деление целых чисел без остатка 2 >>> 10 // 3 # Деление целых чисел с остатком 3 >>> 10.0 // 5.0 # Деление вещественных чисел 2.0 >>> 10.0 // 3.0 # Деление вещественных чисел 3.0 >>> 10 // 5.0 # Деление целого числа на вещественное 2.0 >>> 10 // 3.0 # Деление целого числа на вещественное 3.0 >>> 10.0 // 5 # Деление вещественного числа на целое 2.0 >>> 10.0 // 3 # Деление вещественного числа на целое 3.0 % — остаток от деления: >>> 10 % 5 # Деление целых чисел без остатка 0 >>> 10 % 3 # Деление целых чисел с остатком 1 >>> 10.0 % 5.0 # Операция над вещественными числами 0.0 >>> 10.0 % 3.0 # Операция над вещественными числами 1.0 >>> 10 % 5.0 # Операция над целыми и вещественными числами 0.0 >>> 10 % 3.0 # Операция над целыми и вещественными числами 1.0 >>> 10.0 % 5 # Операция над целыми и вещественными числами 0.0 >>> 10.0 % 3 # Операция над целыми и вещественными числами 1.0 54 Часть I. Основы языка Python ** — возведение в степень: >>> 10 ** 2, 10.0 ** 2 (100, 100.0) унарный минус (–) и унарный плюс (+): >>> +10, +10.0, -10, -10.0, -(-10), -(-10.0) (10, 10.0, -10, -10.0, 10, 10.0) Как видно из примеров, операции над числами разных типов возвращают число, имеющее более сложный тип из типов, участвующих в операции. Целые числа имеют самый простой тип, далее идут вещественные числа и самый сложный тип — комплексные числа. Таким образом, если в операции участвуют целое число и вещественное, то целое число будет автоматически преобразовано в вещественное число, затем будет произведена операция над вещественными числами, а результатом станет вещественное число. При выполнении операций над вещественными числами следует учитывать ограничения точности вычислений. Например, результат следующей операции может показаться стран- ным: >>> 0.3 - 0.1 - 0.1 - 0.1 -2.7755575615628914e-17 Ожидаемым был бы результат 0.0, но, как видно из примера, мы получили совсем другой результат. Если необходимо производить операции с фиксированной точностью, следует использовать модуль decimal: >>> from decimal import Decimal >>> Decimal("0.3") - Decimal("0.1") - Decimal("0.1") - Decimal("0.1") Decimal('0.0') 3.2. Двоичные операторы Двоичные операторы предназначены для манипуляции отдельными битами. Язык Python поддерживает следующие двоичные операторы: — двоичная инверсия. Значение каждого бита заменяется на противоположное: >>> x = 100 # 01100100 >>> x = x # 10011011 & — двоичное И: >>> x = 100 # 01100100 >>> y = 75 # 01001011 >>> z = x & y # 01000000 >>> "{0:b} & {1:b} = {2:b}".format(x, y, z) '1100100 & 1001011 = 1000000' | — двоичное ИЛИ: >>> x = 100 # 01100100 >>> y = 75 # 01001011 >>> z = x | y # 01101111 >>> "{0:b} | {1:b} = {2:b}".format(x, y, z) '1100100 | 1001011 = 1101111' Глава 3. Операторы 55 ^ — двоичное исключающее ИЛИ: >>> x = 100 # 01100100 >>> y = 250 # 11111010 >>> z = x ^ y # 10011110 >>> "{0:b} ^ {1:b} = {2:b}".format(x, y, z) '1100100 ^ 11111010 = 10011110' << — сдвиг влево — сдвигает двоичное представление числа влево на один или более разрядов и заполняет разряды справа нулями: >>> x = 100 # 01100100 >>> y = x << 1 # 11001000 >>> z = y << 1 # 10010000 >>> k = z << 2 # 01000000 >> — сдвиг вправо — сдвигает двоичное представление числа вправо на один или более разрядов и заполняет разряды слева нулями, если число положительное: >>> x = 100 # 01100100 >>> y = x >> 1 # 00110010 >>> z = y >> 1 # 00011001 >>> k = z >> 2 # 00000110 Если число отрицательное, то разряды слева заполняются единицами: >>> x = -127 # 10000001 >>> y = x >> 1 # 11000000 >>> z = y >> 2 # 11110000 >>> k = z << 1 # 11100000 >>> m = k >> 1 # 11110000 3.3. Операторы для работы с последовательностями Для работы с последовательностями предназначены следующие операторы: + — конкатенация: >>> print("Строка1" + "Строка2") # Конкатенация строк Строка1Строка2 >>> [1, 2, 3] + [4, 5, 6] # Списки [1, 2, 3, 4, 5, 6] >>> (1, 2, 3) + (4, 5, 6) # Кортежи (1, 2, 3, 4, 5, 6) * — повторение: >>> "s" * 20 # Строки 'ssssssssssssssssssss' >>> [1, 2] * 3 # Списки [1, 2, 1, 2, 1, 2] >>> (1, 2) * 3 # Кортежи (1, 2, 1, 2, 1, 2) 56 Часть I. Основы языка Python in — проверка на вхождение. Если элемент входит в последовательность, то возвраща- ется логическое значение True: >>> "Строка" in "Строка для поиска" # Строки True >>> "Строка2" in "Строка для поиска" # Строки False >>> 2 in [1, 2, 3], 4 in [1, 2, 3] # Списки (True, False) >>> 2 in (1, 2, 3), 6 in (1, 2, 3) # Кортежи (True, False) not in — проверка на невхождение. Если элемент не входит в последовательность, воз- вращается True: >>> "Строка" not in "Строка для поиска" # Строки False >>> "Строка2" not in "Строка для поиска" # Строки True >>> 2 not in [1, 2, 3], 4 not in [1, 2, 3] # Списки (False, True) >>> 2 not in (1, 2, 3), 6 not in (1, 2, 3) # Кортежи (False, True) 3.4. Операторы присваивания Операторы присваивания предназначены для сохранения значения в переменной. Приведем перечень операторов присваивания, доступных в языке Python: = — присваивает переменной значение: >>> x = 5; x 5 += — увеличивает значение переменной на указанную величину: >>> x = 5; x += 10 # Эквивалентно x = x + 10 >>> x 15 Для последовательностей оператор += производит конкатенацию: >>> s = "Стр"; s += "ока" >>> print(s) Строка -= — уменьшает значение переменной на указанную величину: >>> x = 10; x -= 5 # Эквивалентно x = x — 5 >>> x 5 *= — умножает значение переменной на указанную величину: >>> x = 10; x *= 5 # Эквивалентно x = x * 5 >>> x 50 Глава 3. Операторы 57 Для последовательностей оператор *= производит повторение: >>> s = "*"; s *= 20 >>> s '********************' /= — делит значение переменной на указанную величину: >>> x = 10; x /= 3 # Эквивалентно x = x / 3 >>> x 3.3333333333333335 >>> y = 10.0; y /= 3.0 # Эквивалентно y = y / 3.0 >>> y 3.3333333333333335 //= — деление с округлением вниз и присваиванием: >>> x = 10; x //= 3 # Эквивалентно x = x // 3 >>> x 3 >>> y = 10.0; y //= 3.0 # Эквивалентно y = y // 3.0 >>> y 3.0 %= — деление по модулю и присваивание: >>> x = 10; x %= 2 # Эквивалентно x = x % 2 >>> x 0 >>> y = 10; y %= 3 # Эквивалентно y = y % 3 >>> y 1 **= — возведение в степень и присваивание: >>> x = 10; x **= 2 # Эквивалентно x = x ** 2 >>> x 100 3.5. Приоритет выполнения операторов В какой последовательности будет вычисляться приведенное далее выражение? x = 5 + 10 * 3 / 2 Это зависит от приоритета выполнения операторов. В данном случае последовательность вычисления выражения будет такой: 1. Число 10 будет умножено на 3, т. к. приоритет оператора умножения выше приоритета оператора сложения. 2. Полученное значение будет поделено на 2, т. к. приоритет оператора деления равен при- оритету оператора умножения (а операторы с равными приоритетами выполняются сле- ва направо), но выше, чем у оператора сложения. 58 Часть I. Основы языка Python 3. К полученному значению будет прибавлено число 5, т. к. оператор присваивания = имеет наименьший приоритет. 4. Значение будет присвоено переменной x>>> x = 5 + 10 * 3 / 2 >>> x 20.0 С помощью скобок можно изменить последовательность вычисления выражения: x = (5 + 10) * 3 / 2 Теперь порядок вычислений станет иным: 1. К числу 5 будет прибавлено 10. 2. Полученное значение будет умножено на 3. 3. Полученное значение будет поделено на 2. 4. Значение будет присвоено переменной x>>> x = (5 + 10) * 3 / 2 >>> x 22.5 Перечислим операторы в порядке убывания приоритета: 1. -x, +x, x, ** — унарный минус, унарный плюс, двоичная инверсия, возведение в сте- пень. Если унарные операторы расположены слева от оператора **, то возведение в сте- пень имеет больший приоритет, а если справа — то меньший. Например, выражение: -10 ** -2 эквивалентно следующей расстановке скобок: -(10 ** (-2)) 2. *, %, /, // — умножение (повторение), остаток от деления, деление, деление с округле- нием вниз. 3. +, – — сложение (конкатенация), вычитание. 4. <<, >> — двоичные сдвиги. 5. & — двоичное И. 6. ^ — двоичное исключающее ИЛИ. 7. | — двоичное ИЛИ. 8. =, +=, -=, *=, /=, //=, %=, **= — присваивание. ГЛ А В А 4 Условные операторы и циклы Условные операторы позволяют в зависимости от значения логического выражения выпол- нить отдельный участок программы или, наоборот, не выполнить его. Логические выраже- ния возвращают только два значения: True (истина) или False (ложь), которые ведут себя как целые числа 1 и 0 соответственно: >>> True + 2 # Эквивалентно 1 + 2 3 >>> False + 2 # Эквивалентно 0 + 2 2 Логическое значение можно сохранить в переменной: >>> x = True; y = False >>> x, y (True, False) Любой объект в логическом контексте может интерпретироваться как истина (True) или как ложь (False). Для определения логического значения можно использовать функцию bool()Значение True возвращает следующие объекты: любое число, не равное нулю: >>> bool(1), bool(20), bool(-20) (True, True, True) >>> bool(1.0), bool(0.1), bool(-20.0) (True, True, True) не пустой объект: >>> bool("0"), bool([0, None]), bool((None,)), bool({"x": 5}) (True, True, True, True) Следующие объекты интерпретируются как False: число, равное нулю: >>> bool(0), bool(0.0) (False, False) пустой объект: >>> bool(""), bool([]), bool(()) (False, False, False) 60 Часть I. Основы языка Python значение None: >>> bool(None) False 4.1. Операторы сравнения Операторы сравнения используются в логических выражениях. Приведем их перечень: == — равно: >>> 1 == 1, 1 == 5 (True, False) != — не равно: >>> 1 != 5, 1 != 1 (True, False) < — меньше: >>> 1 < 5, 1 < 0 (True, False) > — больше: >>> 1 > 0, 1 > 5 (True, False) <= — меньше или равно: >>> 1 <= 5, 1 <= 0, 1 <= 1 (True, False, True) >= — больше или равно: >>> 1 >= 0, 1 >= 5, 1 >= 1 (True, False, True) in — проверка на вхождение в последовательность: >>> "Строка" in "Строка для поиска" # Строки True >>> 2 in [1, 2, 3], 4 in [1, 2, 3] # Списки (True, False) >>> 2 in (1, 2, 3), 4 in (1, 2, 3) # Кортежи (True, False) Оператор in можно также использовать для проверки существования ключа словаря: >>> "x" in {"x": 1, "y": 2}, "z" in {"x": 1, "y": 2} (True, False) not in — проверка на невхождение в последовательность: >>> "Строка" not in "Строка для поиска" # Строки False >>> 2 not in [1, 2, 3], 4 not in [1, 2, 3] # Списки (False, True) Глава 4. Условные операторы и циклы 61 >>> 2 not in (1, 2, 3), 4 not in (1, 2, 3) # Кортежи (False, True) is — проверяет, ссылаются ли две переменные на один и тот же объект. Если перемен- ные ссылаются на один и тот же объект, оператор is возвращает значение True: >>> x = y = [1, 2] >>> x is y True >>> x = [1, 2]; y = [1, 2] >>> x is y False Следует заметить, что в целях повышения эффективности интерпретатор производит кэширование малых целых чисел и небольших строк. Это означает, что если ста пере- менным присвоено число 2, то в этих переменных, скорее всего, будет сохранена ссылка на один и тот же объект: >>> x = 2; y = 2; z = 2 >>> x is y, y is z (True, True) is not — проверяет, ссылаются ли две переменные на разные объекты. Если это так, возвращается значение True: >>> x = y = [1, 2] >>> x is not y False >>> x = [1, 2]; y = [1, 2] >>> x is not y True Значение логического выражения можно инвертировать с помощью оператора not: >>> x = 1; y = 1 >>> x == y True >>> not (x == y), not x == y (False, False) Если переменные x и y равны, возвращается значение True, но так как перед выражением стоит оператор not, выражение вернет False. Круглые скобки можно не указывать, по- скольку оператор not имеет более низкий приоритет выполнения, чем операторы сравнения. В логическом выражении можно указывать сразу несколько условий: >>> x = 10 >>> 1 < x < 20, 11 < x < 20 (True, False) Несколько логических выражений можно объединить в одно большое с помощью следую- щих операторов: and — логическое И. Если x в выражении x and y интерпретируется как False, то воз- вращается x, в противном случае — y. Примеры: >>> 1 < 5 and 2 < 5 # True and True == True True 62 Часть I. Основы языка Python >>> 1 < 5 and 2 > 5 # True and False == False False >>> 1 > 5 and 2 < 5 # False and True == False False >>> 10 and 20, 0 and 20, 10 and 0 (20, 0, 0) or — логическое ИЛИ. Если x в выражении x or y интерпретируется как False, то воз- вращается y, в противном случае — x. Примеры: >>> 1 < 5 or 2 < 5 # True or True == True True >>> 1 < 5 or 2 > 5 # True or False == True True >>> 1 > 5 or 2 < 5 # False or True == True True >>> 1 > 5 or 2 > 5 # False or False == False False >>> 10 or 20, 0 or 20, 10 or 0 (10, 20, 10) >>> 0 or "" or None or [] or "s" 's' Следующее выражение вернет True только в том случае, если оба выражения вернут True: x1 == x2 and x2 != x3 А это выражение вернет True, если хотя бы одно из выражений вернет True: x1 == x2 or x3 == x4 Перечислим операторы сравнения в порядке убывания приоритета: 1. <, >, <=, >=, ==, !=, <>, is, is not, in, not in2. not — логическое отрицание. 3. and — логическое И. 4. or — логическое ИЛИ. 4.2. Оператор ветвления if...else Оператор ветвления if...else позволяет в зависимости от значения логического выраже- ния выполнить отдельный участок программы или, наоборот, не выполнить его. Оператор имеет следующий формат: if <Логическое выражение>: <Блок, выполняемый, если условие истинно> [elif <Логическое выражение>: <Блок, выполняемый, если условие истинно> ] [else: <Блок, выполняемый, если все условия ложны> ] Глава 4. Условные операторы и циклы 63 Как вы уже знаете, блоки внутри составной инструкции выделяются одинаковым количест- вом пробелов (обычно четырьмя). Концом блока является инструкция, перед которой рас- положено меньшее количество пробелов. В некоторых языках программирования логиче- ское выражение заключается в круглые скобки. В языке Python это делать необязательно, но можно, т. к. любое выражение может быть расположено внутри круглых скобок. Тем не менее, круглые скобки следует использовать только при необходимости разместить условие на нескольких строках. 1   ...   4   5   6   7   8   9   10   11   ...   83

%(h1)s

>>> bytes("string\uFFFD", "cp1251", "replace") b'string?' >>> bytes("string\uFFFD", "cp1251", "ignore") b'string' с помощью строкового метода encode([encoding="utf-8"][, errors="strict"]). Если кодировка не указана, строка преобразуется в последовательность байтов в кодировке UTF-8. В параметре errors могут быть указаны значения "strict" (значение по умолча- нию), "replace", "ignore", "xmlcharrefreplace" или "backslashreplace": >>> "строка".encode() b'\xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0' >>> "строка".encode(encoding="cp1251") b'\xf1\xf2\xf0\xee\xea\xe0' >>> "строка\uFFFD".encode(encoding="cp1251", errors="xmlcharrefreplace") b'\xf1\xf2\xf0\xee\xea\xe0�' >>> "строка\uFFFD".encode(encoding="cp1251", errors="backslashreplace") b'\xf1\xf2\xf0\xee\xea\xe0\\ufffd' Глава 6. Строки и двоичные данные 113 указав букву b (регистр не имеет значения) перед строкой в апострофах, кавычках, трой- ных апострофах или тройных кавычках. Обратите внимание на то, что в строке могут быть только символы с кодами, входящими в кодировку ASCII. Все остальные символы должны быть представлены специальными последовательностями: >>> b"string", b'string', b"""string""", b'''string''' (b'string', b'string', b'string', b'string') >>> b"строка" SyntaxError: bytes can only contain ASCII literal characters. >>> b"\xf1\xf2\xf0\xee\xea\xe0" b'\xf1\xf2\xf0\xee\xea\xe0' с помощью функции bytes(<Последовательность>), которая преобразует последователь- ность целых чисел от 0 до 255 в объект типа bytes. Если число не попадает в диапазон, возбуждается исключение ValueError: >>> b = bytes([225, 226, 224, 174, 170, 160]) >>> b b'\xe1\xe2\xe0\xae\xaa\xa0' >>> str(b, "cp866") 'строка' с помощью функции bytes(<Число>), которая задает количество элементов в последова- тельности. Каждый элемент будет содержать нулевой символ: >>> bytes(10) b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' с помощью метода bytes.fromhex(<Строка>). Строка в этом случае должна содержать шестнадцатеричные значения символов: >>> b = bytes.fromhex(" e1 e2e0ae aaa0 ") >>> b b'\xe1\xe2\xe0\xae\xaa\xa0' >>> str(b, "cp866") 'строка' Объекты типа bytes относятся к последовательностям. Каждый элемент такой последова- тельности может хранить целое число от 0 до 255, которое обозначает код символа. Как и все последовательности, объекты поддерживают обращение к элементу по индексу, полу- чение среза, конкатенацию, повторение и проверку на вхождение: >>> b = bytes("string", "cp1251") >>> b b'string' >>> b[0] # Обращение по индексу 115 >>> b[1:3] # Получение среза b'tr' >>> b + b"123" # Конкатенация b'string123' >>> b * 3 # Повторение b'stringstringstring' >>> 115 in b, b"tr" in b, b"as" in b (True, True, False) 114 Часть I. Основы языка Python Как видно из примера, при выводе объекта целиком, а также при извлечении среза, произ- водится попытка отображения символов. Однако доступ по индексу возвращает целое чис- ло, а не символ. Если преобразовать объект в список, то мы получим последовательность целых чисел: >>> list(bytes("string", "cp1251")) [115, 116, 114, 105, 110, 103] Тип bytes относится к неизменяемым типам. Это означает, что можно получить значение по индексу, но изменить его нельзя: >>> b = bytes("string", "cp1251") >>> b[0] = 168 Traceback (most recent call last): File "", line 1, in b[0] = 168 TypeError: 'bytes' object does not support item assignment Объекты типа bytes поддерживают большинство строковых методов, которые мы рассмат- ривали в предыдущих разделах. Однако некоторые из этих методов могут некорректно ра- ботать с русскими буквами — в этих случаях следует использовать тип str, а не тип bytesНе поддерживаются объектами типа bytes строковые методы encode(), isidentifier(), isprintable(), isnumeric(), isdecimal(), format_map() и format(), а также операция фор- матирования. При использовании методов следует учитывать, что в параметрах нужно указывать объекты типа bytes, а не строки: >>> b = bytes("string", "cp1251") >>> b.replace(b"s", b"S") b'String' Необходимо также помнить, что смешивать строки и объекты типа bytes в выражениях нельзя. Предварительно необходимо явно преобразовать объекты к одному типу, а лишь затем производить операцию: >>> b"string" + "string" Traceback (most recent call last): File "", line 1, in b"string" + "string" TypeError: can't concat bytes to str >>> b"string" + "string".encode("ascii") b'stringstring' Объект типа bytes может содержать как однобайтовые, так и многобайтовые символы. При использовании многобайтовых символов некоторые функции могут работать не так, как предполагалось, — например, функция len() вернет количество байтов, а не символов: >>> len("строка") 6 >>> len(bytes("строка", "cp1251")) 6 >>> len(bytes("строка", "utf-8")) 12 Глава 6. Строки и двоичные данные 115 Преобразовать объект типа bytes в строку позволяет метод decode(). Метод имеет следую- щий формат: decode([encoding="utf-8"][, errors="strict"]) Параметр encoding задает кодировку символов (по умолчанию UTF-8) в объекте bytes, а параметр errors — способ обработки ошибок при преобразовании. В параметре errors можно указать значения "strict" (значение по умолчанию), "replace" или "ignore". При- мер преобразования: >>> b = bytes("строка", "cp1251") >>> b.decode(encoding="cp1251"), b.decode("cp1251") ('строка', 'строка') Для преобразования можно также воспользоваться функцией str(): >>> b = bytes("строка", "cp1251") >>> str(b, "cp1251") 'строка' Чтобы изменить кодировку данных, следует сначала преобразовать тип bytes в строку, а затем произвести обратное преобразование, указав нужную кодировку. Преобразуем дан- ные из кодировки Windows-1251 в кодировку KOI8-R, а затем обратно: >>> w = bytes("Строка", "cp1251") # Данные в кодировке windows-1251 >>> k = w.decode("cp1251").encode("koi8-r") >>> k, str(k, "koi8-r") # Данные в кодировке KOI8-R (b'\xf3\xd4\xd2\xcf\xcb\xc1', 'Строка') >>> w = k.decode("koi8-r").encode("cp1251") >>> w, str(w, "cp1251") # Данные в кодировке windows-1251 (b'\xd1\xf2\xf0\xee\xea\xe0', 'Строка') В Python 3.5 появились два полезных инструмента для работы с типом данных bytes. Во- первых, теперь можно форматировать такие данные с применением описанного в разд. 6.4 оператора %: >>> b"%i - %i - %f" % (10, 20, 30) b'10 - 20 - 30.000000' Однако здесь нужно помнить, что тип преобразования s (т. е. вывод в виде Unicode-строки) в этом случае не поддерживается, и его использование приведет к возбуждению исключе- ния TypeError: >>> b"%s - %s - %s" % (10, 20, 30) Traceback (most recent call last): File "", line 1, in b"%s - %s - %s" % (10, 20, 30) TypeError: %b requires a bytes-like object, or an object that implements __bytes__, not 'int' Во-вторых, тип bytes получил поддержку метода hex(), который возвращает строку с шест- надцатеричным представлением значения: >>> b"string".hex() '737472696e67' 116 Часть I. Основы языка Python 6.13. Тип данных bytearray Тип данных bytearray является разновидностью типа bytes и поддерживает те же самые методы и операции (включая оператор форматирования % и метод hex(), описанные ранее). В отличие от типа bytes, тип bytearray допускает возможность непосредственного измене- ния объекта и содержит дополнительные методы, позволяющие выполнять эти изменения. Создать объект типа bytearray можно следующими способами: с помощью функции bytearray([<Строка>, <Кодировка>[, <Обработка ошибок>]]). Если параметры не указаны, то возвращается пустой объект. Чтобы преобразовать строку в объект типа bytearray, необходимо передать минимум два первых параметра. Если строка указана только в первом параметре, то возбуждается исключение TypeError: >>> bytearray() bytearray(b'') >>> bytearray("строка", "cp1251") bytearray(b'\xf1\xf2\xf0\xee\xea\xe0') >>> bytearray("строка") Traceback (most recent call last): File "", line 1, in bytearray("строка") TypeError: string argument without an encoding В третьем параметре могут быть указаны значения "strict" (при ошибке возбуждается исключение UnicodeEncodeError — значение по умолчанию), "replace" (неизвестный символ заменяется символом вопроса) или "ignore" (неизвестные символы игнорируются): >>> bytearray("string\uFFFD", "cp1251", "strict") Traceback (most recent call last): File "", line 1, in bytearray("string\uFFFD", "cp1251", "strict") File "C:\Python36\lib\encodings\cp1251.py", line 12, in encode return codecs.charmap_encode(input,errors,encoding_table) UnicodeEncodeError: 'charmap' codec can't encode character '\ufffd' in position 6: character maps to >>> bytearray("string\uFFFD", "cp1251", "replace") bytearray(b'string?') >>> bytearray("string\uFFFD", "cp1251", "ignore") bytearray(b'string') с помощью функции bytearray(<Последовательность>), которая преобразует последова- тельность целых чисел от 0 до 255 в объект типа bytearray. Если число не попадает в диапазон, возбуждается исключение ValueError: >>> b = bytearray([225, 226, 224, 174, 170, 160]) >>> b bytearray(b'\xe1\xe2\xe0\xae\xaa\xa0') >>> bytearray(b'\xe1\xe2\xe0\xae\xaa\xa0') bytearray(b'\xe1\xe2\xe0\xae\xaa\xa0') >>> str(b, "cp866") 'строка' с помощью функции bytearray(<Число>), которая задает количество элементов в после- довательности. Каждый элемент будет содержать нулевой символ: Глава 6. Строки и двоичные данные 117 >>> bytearray(5) bytearray(b'\x00\x00\x00\x00\x00') с помощью метода bytearray.fromhex(<Строка>). Строка в этом случае должна содер- жать шестнадцатеричные значения символов: >>> b = bytearray.fromhex(" e1 e2e0ae aaa0 ") >>> b bytearray(b'\xe1\xe2\xe0\xae\xaa\xa0') >>> str(b, "cp866") 'строка' Тип bytearray относится к изменяемым типам. Поэтому можно не только получить значе- ние по индексу, но и изменить его (что не свойственно строкам): >>> b = bytearray("Python", "ascii") >>> b[0] # Можем получить значение 80 >>> b[0] = b"J"[0] # Можем изменить значение >>> b bytearray(b'Jython') При изменении значения важно помнить, что присваиваемое значение должно быть целым числом в диапазоне от 0 до 255. Чтобы получить число в предыдущем примере, мы создали объект типа bytes, а затем присвоили значение, расположенное по индексу 0 (b[0] = b"J"[0]). Можно, конечно, сразу указать код символа, но ведь держать все коды символов в памяти свойственно компьютеру, а не человеку. Для изменения объекта можно также использовать следующие методы: append(<Число>) — добавляет один элемент в конец объекта. Метод изменяет текущий объект и ничего не возвращает: >>> b = bytearray("string", "ascii") >>> b.append(b"1"[0]); b bytearray(b'string1') extend(<Последовательность>) — добавляет элементы последовательности в конец объекта. Метод изменяет текущий объект и ничего не возвращает: >>> b = bytearray("string", "ascii") >>> b.extend(b"123"); b bytearray(b'string123') Добавить несколько элементов можно с помощью операторов + и +=: >>> b = bytearray("string", "ascii") >>> b + b"123" # Возвращает новый объект bytearray(b'string123') >>> b += b"456"; b # Изменяет текущий объект bytearray(b'string456') Кроме того, можно воспользоваться операцией присваивания значения срезу: >>> b = bytearray("string", "ascii") >>> b[len(b):] = b"123" # Добавляем элементы в последовательность >>> b bytearray(b'string123') 118 Часть I. Основы языка Python insert(<Индекс>, <Число>) — добавляет один элемент в указанную позицию. Осталь- ные элементы смещаются. Метод изменяет текущий объект и ничего не возвращает. До- бавим элемент в начало объекта: >>> b = bytearray("string", "ascii") >>> b.insert(0, b"1"[0]); b bytearray(b'1string') Метод insert() позволяет добавить только один элемент. Чтобы добавить несколько элементов, можно воспользоваться операцией присваивания значения срезу. Добавим несколько элементов в начало объекта: >>> b = bytearray("string", "ascii") >>> b[:0] = b"123"; b bytearray(b'123string') pop([<Индекс>]) — удаляет элемент, расположенный по указанному индексу, и воз- вращает его. Если индекс не указан, удаляет и возвращает последний элемент: >>> b = bytearray("string", "ascii") >>> b.pop() # Удаляем последний элемент 103 >>> b bytearray(b'strin') >>> b.pop(0) # Удаляем первый элемент 115 >>> b bytearray(b'trin') Удалить элемент списка позволяет также оператор del: >>> b = bytearray("string", "ascii") >>> del b[5] # Удаляем последний элемент >>> b bytearray(b'strin') >>> del b[:2] # Удаляем первый и второй элементы >>> b bytearray(b'rin') remove(<Число>) — удаляет первый элемент, содержащий указанное значение. Если элемент не найден, возбуждается исключение ValueError. Метод изменяет текущий объ- ект и ничего не возвращает: >>> b = bytearray("strstr", "ascii") >>> b.remove(b"s"[0]) # Удаляет только первый элемент >>> b bytearray(b'trstr') reverse() — изменяет порядок следования элементов на противоположный. Метод изменяет текущий объект и ничего не возвращает: >>> b = bytearray("string", "ascii") >>> b.reverse(); b bytearray(b'gnirts') Преобразовать объект типа bytearray в строку позволяет метод decode(). Метод имеет сле- дующий формат: decode([encoding="utf-8"][, errors="strict"]) Глава 6. Строки и двоичные данные 119 Параметр encoding задает кодировку символов (по умолчанию UTF-8) в объекте bytearray, а параметр errors — способ обработки ошибок при преобразовании. В параметре errors можно указать значения "strict" (значение по умолчанию), "replace" или "ignore". При- мер преобразования: >>> b = bytearray("строка", "cp1251") >>> b.decode(encoding="cp1251"), b.decode("cp1251") ('строка', 'строка') Для преобразования можно также воспользоваться функцией str(): >>> b = bytearray("строка", "cp1251") >>> str(b, "cp1251") 'строка' 6.14. Преобразование объекта в последовательность байтов Преобразовать объект в последовательность байтов (выполнить его сериализацию), а затем восстановить (десериализовать) объект позволяет модуль pickle. Прежде чем использовать функции из этого модуля, необходимо подключить модуль с помощью инструкции: import pickle Для преобразования предназначены две функции: dumps(<Объект>[, protocol=None][, fix_imports=True]) — производит сериализацию объекта и возвращает последовательность байтов специального формата. Формат зави- сит от указанного во втором параметре протокола, который задается в виде числа от 0 до значения константы pickle.HIGHEST_PROTOCOL. Если второй параметр не указан, будет использован протокол 3 (константа pickle.DEFAULT_PROTOCOL). Пример преобразования списка и кортежа: >>> import pickle >>> obj1 = [1, 2, 3, 4, 5] # Список >>> obj2 = (6, 7, 8, 9, 10) # Кортеж >>> pickle.dumps(obj1) b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04K\x05e.' >>> pickle.dumps(obj2) b'\x80\x03(K\x06K\x07K\x08K\tK\ntq\x00.' loads(<Последовательность байтов>[, fix_imports=True][, encoding="ASCII"][, errors="strict"]) — преобразует последовательность байтов специального формата обратно в объект, выполняя его десериализацию. Пример восстановления списка и кор- тежа: >>> pickle.loads(b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04K\x05e.') [1, 2, 3, 4, 5] >>> pickle.loads(b'\x80\x03(K\x06K\x07K\x08K\tK\ntq\x00.') (6, 7, 8, 9, 10) 120 Часть I. Основы языка Python 6.15. Шифрование строк Для шифрования строк предназначен модуль hashlib. Прежде чем использовать функции из этого модуля, необходимо подключить модуль с помощью инструкции: import hashlib Модуль предоставляет следующие функции: md5(), sha1(), sha224(), sha256(), sha384(), sha512(), в Python 3.6 появилась поддержка функций sha3_224(), sha3_256(), sha3_384(), sha3_512(), shake_128() и shake_256(). В качестве необязательного параметра функциям можно передать шифруемую последовательность байтов: >>> import hashlib >>> h = hashlib.sha1(b"password") Передать последовательность байтов можно также с помощью метода update(). В этом случае объект присоединяется к предыдущему значению: >>> h = hashlib.sha1() >>> h.update(b"password") Получить зашифрованную последовательность байтов и строку позволяют два метода: digest() и hexdigest(). Первый метод возвращает значение, относящееся к типу bytes, а второй — строку, содержащую шестнадцатеричные цифры: >>> h = hashlib.sha1(b"password") >>> h.digest() b'[\xaaa\xe4\xc9\xb9??\x06\x82%\x0bl\xf83\x1b\xe6\x8f\xd8' >>> h.hexdigest() '5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8' Наиболее часто применяемой является функция md5(), которая шифрует строку с помощью алгоритма MD5. Эта функция используется для шифрования паролей, т. к. не существует алгоритма для дешифровки зашифрованных ей значений. Для сравнения введенного поль- зователем пароля с сохраненным в базе необходимо зашифровать введенный пароль, а за- тем произвести сравнение: >>> import hashlib >>> h = hashlib.md5(b"password") >>> p = h.hexdigest() >>> p # Пароль, сохраненный в базе '5f4dcc3b5aa765d61d8327deb882cf99' >>> h2 = hashlib.md5(b"password") # Пароль, введенный пользователем >>> if p == h2.hexdigest(): print("Пароль правильный") Пароль правильный Свойство digest_size хранит размер значения, генерируемого описанными ранее функция- ми шифрования, в байтах: >>> h = hashlib.sha512(b"password") >>> h.digest_size 64 Поддерживается еще несколько функций, выполняющих устойчивое к взлому шифрование паролей: Глава 6. Строки и двоичные данные 121 pbkdf2_hmac(<Основной алгоритм шифрования>, <Шифруемый пароль>, <"Соль">, <Коли- чество проходов шифрования>, dklen=None). В качестве основного алгоритма шифрова- ния следует указать строку с наименованием этого алгоритма: "md5", "sha1", "sha224", "sha256", "sha384" и "sha512". Шифруемый пароль указывается в виде значения типа bytes"Соль" — это особая величина типа bytes, выступающая в качестве ключа шиф- рования, — ее длина не должна быть менее 16 символов. Количество проходов шифро- вания следует указать достаточно большим (так, при использовании алгоритма SHA512 оно должно составлять 100 000). Последним параметром функции pbkdf2_hmac() можно указать длину результирующего закодированного значения в байтах — если она не за- дана или равна None, будет создано значение стандартной для выбранного алгоритма длины (64 байта для алгоритма SHA512). Закодированный пароль возвращается в виде величины типа bytes: >>> import hashlib >>> dk = hashlib.pbkdf2_hmac('sha512', b'1234567', b'saltsaltsaltsalt', 100000) >>> dk b"Sb\x85tc-\xcb@\xc5\x97\x19\x90\x94@\x9f\xde\x07\xa4p-\x83\x94\xf4\x94\x99\x07\ xec\xfa\xf3\xcd\xc3\x88jv\xd1\xe5\x9a\x119\x15/\xa4\xc2\xd3N\xaba\x02\xc0s\xc1\ xd1\x0b\x86xj(\x8c>Mr'@\xbb" ПРИМЕЧАНИЕКодирование данных с применением функции pbkdf2_hmac() отнимает очень много сис- темных ресурсов и может занять значительное время, особенно на маломощных компью- терах. Поддержка двух следующих функций появилась в Python 3.6: blake2s([<Шифруемый пароль>][, digest_size=32], [salt=b””]) — шифрует пароль по алгоритму BLAKE2s, оптимизированному для 32-разрядных систем. Второй параметр задает размер значения в виде числа от 1 до 32, третий — «соль» в виде величины типа bytes, которая может иметь в длину не более 8 байтов. Возвращает объект, хранящий закодированный пароль: >>> h = hashlib.blake2s(b"string", digest_size=16, salt=b"saltsalt") >>> h.digest() b'\x96l\xe0\xfa\xb4\xe7Bw\x11\xf7D\xc2\xa4\xcf\x06\xf7' blake2b([<Шифруемый пароль>][, digest_size=64], [salt=b””]) — шифрует пароль по алгоритму BLAKE2b, оптимизированному для 64-разрядных систем. Второй параметр задает размер значения в виде числа от 1 до 64, третий — «соль» в виде величины типа bytes, которая может иметь в длину не более 16 байтов. Возвращает объект, хранящий закодированный пароль: >>> h = hashlib.blake2b(b"string", digest_size=48, salt=b"saltsaltsalt") >>> h.digest() b'\x0e\xcf\xb9\xc8G;q\xbaV\xbdV\x16\xd4@/J\x97W\x0c\xc4\xc5{\xd4\xb6\x12\x01z\ x9f\xdd\xf6\xf1\x03o\x97&v\xfd\xa6\x90\x81\xc4T\xb8z\xaf\xc3\x9a\xd9' ПРИМЕЧАНИЕФункции blake2b() и blake2s() поддерживают большое количество параметров, которые применяются только в специфических случаях. Полное описание этих функций можно най- ти в документации по Python. ГЛ А В А 7 Регулярные выражения Регулярные выражения предназначены для выполнения в строке сложного поиска или за- мены. В языке Python использовать регулярные выражения позволяет модуль re. Прежде чем задействовать функции из этого модуля, необходимо подключить модуль с помощью инструкции: import re 7.1. Синтаксис регулярных выражений Создать откомпилированный шаблон регулярного выражения позволяет функция compile(). Функция имеет следующий формат: <Шаблон> = re.compile(<Регулярное выражение>[, <Модификатор>]) В параметре <Модификатор> могут быть указаны следующие флаги (или их комбинация через оператор |): I или IGNORECASE — поиск без учета регистра: >>> import re >>> p = re.compile(r"^[а-яе]+$", re.I | re.U) >>> print("Найдено" if p.search("АБВГДЕЕ") else "Нет") Найдено >>> p = re.compile(r"^[а-яе]+$", re.U) >>> print("Найдено" if p.search("АБВГДЕЕ") else "Нет") Нет M или MULTILINE — поиск в строке, состоящей из нескольких подстрок, разделенных символом новой строки ("\n"). Символ ^ соответствует привязке к началу каждой под- строки, а символ $ — позиции перед символом перевода строки; S или DOTALL — метасимвол «точка» по умолчанию соответствует любому символу, кро- ме символа перевода строки (\n). Символу перевода строки метасимвол «точка» будет соответствовать в присутствии дополнительного модификатора. Символ ^ соответствует привязке к началу всей строки, а символ $ — привязке к концу всей строки: >>> p = re.compile(r"^.$") >>> print("Найдено" if p.search("\n") else "Нет") Нет >>> p = re.compile(r"^.$", re.M) Глава 7. Регулярные выражения 123 >>> print("Найдено" if p.search("\n") else "Нет") Нет >>> p = re.compile(r"^.$", re.S) >>> print("Найдено" if p.search("\n") else "Нет") Найдено X или VERBOSE — если флаг указан, то пробелы и символы перевода строки будут проиг- норированы. Внутри регулярного выражения можно использовать и комментарии: >>> p = re.compile(r"""^ # Привязка к началу строки [0-9]+ # Строка должна содержать одну цифру (или более) $ # Привязка к концу строки """, re.X | re.S) >>> print("Найдено" if p.search("1234567890") else "Нет") Найдено >>> print("Найдено" if p.search("abcd123") else "Нет") Нет A или ASCII — классы \w, \W, \b, \B, \d, \D, \s и \S будут соответствовать символам в ко- дировке ASCII (по умолчанию указанные классы соответствуют Unicode-символам); ПРИМЕЧАНИЕФлаги U и UNICODE, включающие режим соответствия Unicode-символам классов \w, \W, \b, \B, \d, \D, \s и \S, сохранены в Python 3 лишь для совместимости с ранними версиями это- го языка и никакого влияния на обработку регулярных выражений не оказывают. L или LOCALE — учитываются настройки текущей локали. Начиная с Python 3.6, могут быть использованы только в том случае, когда регулярное выражение задается в виде значения типов bytes или bytearrayКак видно из примеров, перед всеми строками, содержащими регулярные выражения, указан модификатор r. Иными словами, мы используем неформатированные строки. Если модификатор не указать, то все слэши необходимо экранировать. Например, строку: p = re.compile(r"^\w+$") нужно было бы записать так: p = re.compile("^\\w+$") Внутри регулярного выражения символы , ^, $, *, +, ?, {, [, ], \, |, ( и ) имеют специальное значение. Если эти символы должны трактоваться как есть, их следует экранировать с по- мощью слэша. Некоторые специальные символы теряют свое особое значение, если их раз- местить внутри квадратных скобок, — в этом случае экранировать их не нужно. Например, как уже было отмечено ранее, метасимвол «точка» по умолчанию соответствует любому символу, кроме символа перевода строки. Если необходимо найти именно точку, то перед точкой нужно указать символ \ или разместить точку внутри квадратных скобок: [.]. Про- демонстрируем это на примере проверки правильности введенной даты (листинг 7.1). Листинг 7.1. Проверка правильности ввода даты # -*- coding: utf-8 -*- import re # Подключаем модуль d = "29,12.2009" # Вместо точки указана запятая p = re.compile(r"^[0-3][0-9].[01][0-9].[12][09][0-9][0-9]$") 124 Часть I. Основы языка Python # Символ "\" не указан перед точкой if p.search(d): print("Дата введена правильно") else: print("Дата введена неправильно") # Так как точка означает любой символ, # выведет: Дата введена правильно p = re.compile(r"^[0-3][0-9]\.[01][0-9]\.[12][09][0-9][0-9]$") # Символ "\" указан перед точкой if p.search(d): print("Дата введена правильно") else: print("Дата введена неправильно") # Так как перед точкой указан символ "\", # выведет: Дата введена неправильно p = re.compile(r"^[0-3][0-9][.][01][0-9][.][12][09][0-9][0-9]$") # Точка внутри квадратных скобок if p.search(d): print("Дата введена правильно") else: print("Дата введена неправильно") # Выведет: Дата введена неправильно input() В этом примере мы осуществляли привязку к началу и концу строки с помощью следующих метасимволов: ^ — привязка к началу строки или подстроки. Она зависит от флагов M (или MULTILINE) и S (или DOTALL); $ — привязка к концу строки или подстроки. Она зависит от флагов M (или MULTILINE) и S (или DOTALL); \A — привязка к началу строки (не зависит от модификатора); \Z — привязка к концу строки (не зависит от модификатора). Если в параметре <Модификатор> указан флаг M (или MULTILINE), то поиск производится в строке, состоящей из нескольких подстрок, разделенных символом новой строки (\n). В этом случае символ ^ соответствует привязке к началу каждой подстроки, а символ $ — позиции перед символом перевода строки: >>> p = re.compile(r"^.+$") # Точка не соответствует \n >>> p.findall("str1\nstr2\nstr3") # Ничего не найдено [] >>> p = re.compile(r"^.+$", re.S) # Теперь точка соответствует \n >>> p.findall("str1\nstr2\nstr3") # Строка полностью соответствует ['str1\nstr2\nstr3'] >>> p = re.compile(r"^.+$", re.M) # Многострочный режим >>> p.findall("str1\nstr2\nstr3") # Получили каждую подстроку ['str1', 'str2', 'str3'] Глава 7. Регулярные выражения 125 Привязку к началу и концу строки следует использовать, если строка должна полностью соответствовать регулярному выражению. Например, для проверки, содержит ли строка число (листинг 7.2). Листинг 7.2. Проверка наличия целого числа в строке # -*- coding: utf-8 -*- import re # Подключаем модуль p = re.compile(r"^[0-9]+$", re.S) if p.search("245"): print("Число") # Выведет: Число else: print("Не число") if p.search("Строка245"): print("Число") else: print("Не число") # Выведет: Не число input() Если убрать привязку к началу и концу строки, то любая строка, содержащая хотя бы одну цифру, будет распознана как Число (листинг 7.3). Листинг 7.3. Отсутствие привязки к началу или концу строки # -*- coding: utf-8 -*- import re # Подключаем модуль p = re.compile(r"[0-9]+", re.S) if p.search("Строка245"): print("Число") # Выведет: Число else: print("Не число") input() Кроме того, можно указать привязку только к началу или только к концу строки (листинг 7.4). Листинг 7.4. Привязка к началу и концу строки # -*- coding: utf-8 -*- import re # Подключаем модуль p = re.compile(r"[0-9]+$", re.S) if p.search("Строка245"): print("Есть число в конце строки") else: print("Нет числа в конце строки") # Выведет: Есть число в конце строки p = re.compile(r"^[0-9]+", re.S) if p.search("Строка245"): print("Есть число в начале строки") else: print("Нет числа в начале строки") # Выведет: Нет числа в начале строки input() 126 Часть I. Основы языка Python Также поддерживаются два метасимвола, позволяющие указать привязку к началу или кон- цу слова: \b — привязка к началу слова (началом слова считается пробел или любой символ, не являющийся буквой, цифрой или знаком подчеркивания); \B — привязка к позиции, не являющейся началом слова. Рассмотрим несколько примеров: >>> p = re.compile(r"\bpython\b") >>> print("Найдено" if p.search("python") else "Нет") Найдено >>> print("Найдено" if p.search("pythonware") else "Нет") Нет >>> p = re.compile(r"\Bth\B") >>> print("Найдено" if p.search("python") else "Нет") Найдено >>> print("Найдено" if p.search("this") else "Нет") Нет В квадратных скобках [] можно указать символы, которые могут встречаться на этом месте в строке. Разрешается записать символы подряд или указать диапазон через дефис: [09] — соответствует числу 0 или 9; [0-9] — соответствует любому числу от 0 до 9; [абв] — соответствует буквам «а», «б» и «в»; [а-г] — соответствует буквам «а», «б», «в» и «г»; [а-яё] — соответствует любой букве от «а» до «я»; [АБВ] — соответствует буквам «А», «Б» и «В»; [А-ЯЁ] — соответствует любой букве от «А» до «Я»; [а-яА-ЯёЁ] — соответствует любой русской букве в любом регистре; [0-9а-яА-ЯёЁa-zA-Z] — любая цифра и любая буква независимо от регистра и языка. ВНИМАНИЕ! Буква «ё» не входит в диапазон [а-я], а буква «Ё» — в диапазон [А-Я]. Значение в скобках инвертируется, если после первой скобки вставить символ ^. Таким образом можно указать символы, которых не должно быть на этом месте в строке: [^09] — не цифра 0 или 9; [^0-9] — не цифра от 0 до 9; [^а-яА-ЯёЁa-zA-Z] — не буква. Как вы уже знаете, точка теряет свое специальное значение, если ее заключить в квадрат- ные скобки. Кроме того, внутри квадратных скобок могут встретиться символы, которые имеют специальное значение (например, ^ и -). Символ ^ теряет свое специальное значение, если он не расположен сразу после открывающей квадратной скобки. Чтобы отменить спе- циальное значение символа -, его необходимо указать после всех символов, перед закры- вающей квадратной скобкой или сразу после открывающей квадратной скобки. Все специ- альные символы можно сделать обычными, если перед ними указать символ \ Глава 7. Регулярные выражения 127 Метасимвол | позволяет сделать выбор между альтернативными значениями. Выражение n|m соответствует одному из символов: n или m: >>> p = re.compile(r"красн((ая)|(ое))") >>> print("Найдено" if p.search("красная") else "Нет") Найдено >>> print("Найдено" if p.search("красное") else "Нет") Найдено >>> print("Найдено" if p.search("красный") else "Нет") Нет Вместо указания символов можно использовать стандартные классы: \d — соответствует любой цифре. При указании флага A (ASCII) эквивалентно [0-9]; \w — соответствует любой букве, цифре или символу подчеркивания. При указании фла- га A (ASCII) эквивалентно [a-zA-Z0-9_]; \s — любой пробельный символ. При указании флага A (ASCII) эквивалентно [\t\n\r\f\v]; \D — не цифра. При указании флага A (ASCII) эквивалентно [^0-9]; \W — не буква, не цифра и не символ подчеркивания. При указании флага A (ASCII) экви- валентно [^a-zA-Z0-9_]; \S — не пробельный символ. При указании флага A (ASCII) эквивалентно [^\t\n\r\f\v]ПРИМЕЧАНИЕВ Python 3 поддержка Unicode в регулярных выражениях установлена по умолчанию. При этом все классы трактуются гораздо шире. Так, класс \d соответствует не только десятич- ным цифрам, но и другим цифрам из кодировки Unicode, — например, дробям, класс \w включает не только латинские буквы, но и любые другие, а класс \s охватывает также не- разрывные пробелы. Поэтому на практике лучше явно указывать символы внутри квадрат- ных скобок, а не использовать классы. Количество вхождений символа в строку задается с помощью квантификаторов: {n} — n вхождений символа в строку. Например, шаблон r"^[0-9]{2}$" соответствует двум вхождениям любой цифры; {n,} — n или более вхождений символа в строку. Например, шаблон r"^[0-9]{2,}$"соответствует двум и более вхождениям любой цифры; {n,m} — не менее n и не более m вхождений символа в строку. Числа указываются через запятую без пробела. Например, шаблон r"^[0-9]{2,4}$" соответствует от двух до четырех вхождений любой цифры; * — ноль или большее число вхождений символа в строку. Эквивалентно комбинации {0,}; + — одно или большее число вхождений символа в строку. Эквивалентно комбинации {1,}; ? — ни одного или одно вхождение символа в строку. Эквивалентно комбинации {0,1}Все квантификаторы являются «жадными». При поиске соответствия ищется самая длинная подстрока, соответствующая шаблону, и не учитываются более короткие соответствия. Рас- смотрим это на примере и получим содержимое всех тегов вместе с тегами: >>> s = "Text1Text2Text3" >>> p = re.compile(r".*", re.S) 128 Часть I. Основы языка Python >>> p.findall(s) ['Text1Text2Text3'] Вместо желаемого результата мы получили полностью строку. Чтобы ограничить «жад- ность», необходимо после квантификатора указать символ ?: >>> s = "Text1Text2Text3" >>> p = re.compile(r".*?", re.S) >>> p.findall(s) ['Text1', 'Text3'] Этот код вывел то, что мы искали. Если необходимо получить содержимое без тегов, то нужный фрагмент внутри шаблона следует разместить внутри круглых скобок: >>> s = "Text1Text2Text3" >>> p = re.compile(r"(.*?)", re.S) >>> p.findall(s) ['Text1', 'Text3'] Круглые скобки часто используются для группировки фрагментов внутри шаблона. В этом случае не требуется, чтобы фрагмент запоминался и был доступен в результатах поиска. Чтобы избежать захвата фрагмента, следует после открывающей круглой скобки разместить символы ?: (вопросительный знак и двоеточие): >>> s = "test text" >>> p = re.compile(r"([a-z]+((st)|(xt)))", re.S) >>> p.findall(s) [('test', 'st', 'st', ''), ('text', 'xt', '', 'xt')] >>> p = re.compile(r"([a-z]+(?:(?:st)|(?:xt)))", re.S) >>> p.findall(s) ['test', 'text'] В первом примере мы получили список с двумя элементами. Каждый элемент списка явля- ется кортежем, содержащим четыре элемента. Все эти элементы соответствуют фрагмен- там, заключенным в шаблоне в круглые скобки. Первый элемент кортежа содержит фраг- мент, расположенный в первых круглых скобках, второй — во вторых круглых скобках и т. д. Три последних элемента кортежа являются лишними. Чтобы они не выводились в результатах, мы добавили символы ?: после каждой открывающей круглой скобки. В ре- зультате список состоит только из фрагментов, полностью соответствующих регулярному выражению. К найденному фрагменту в круглых скобках внутри шаблона можно обратиться с помощью механизма обратных ссылок. Для этого порядковый номер круглых скобок в шаблоне ука- зывается после слэша, например, так: \1. Нумерация скобок внутри шаблона начинается с 1Для примера получим текст между одинаковыми парными тегами: >>> s = "Text1Text2Text3Text4" >>> p = re.compile(r"<([a-z]+)>(.*?)\1>", re.S | re.I) >>> p.findall(s) [('b', 'Text1'), ('I', 'Text3'), ('b', 'Text4')] Фрагментам внутри круглых скобок можно дать имена, создав тем самым именованные фрагменты. Для этого после открывающей круглой скобки следует указать комбинацию символов ?P. В качестве примера разберем e-mail на составные части: Глава 7. Регулярные выражения 129 >>> email = "test@mail.ru" >>> p = re.compile(r"""(?P[a-z0-9_.-]+) # Название ящика @ # Символ "@" (?P1   ...   8   9   10   11   12   13   14   15   ...   83

254 Часть I. Основы языка Python __getattribute__(self, <Атрибут>) — вызывается при обращении к любому атрибуту класса. Необходимо учитывать, что использование точечной нотации (для обращения к атрибуту класса) внутри этого метода приведет к зацикливанию. Чтобы избежать за- цикливания, следует вызвать метод __getattribute__() объекта object и внутри этого метода вернуть значение атрибута или возбудить исключение AttributeError: class MyClass: def __init__(self): self.i = 20 def __getattribute__(self, attr): print("Вызван метод __getattribute__()") return object.__getattribute__(self, attr) # Только так!!! c = MyClass() print(c.i) # Выведет: Вызван метод __getattribute__() 20 __setattr__(self, <Атрибут>, <Значение>) — вызывается при попытке присваивания значения атрибуту экземпляра класса. Если внутри метода необходимо присвоить зна- чение атрибуту, следует использовать словарь __dict__, поскольку при применении то- чечной нотации метод __setattr__() будет вызван повторно, что приведет к зациклива- нию: class MyClass: def __setattr__(self, attr, value): print("Вызван метод __setattr__()") self.__dict__[attr] = value # Только так!!! c = MyClass() c.i = 10 # Выведет: Вызван метод __setattr__() print(c.i) # Выведет: 10 __delattr__(self, <Атрибут>) — вызывается при удалении атрибута с помощью инст- рукции del <Экземпляр класса>.<Атрибут>; __len__(self) — вызывается при использовании функции len(), а также для проверки объекта на логическое значение при отсутствии метода __bool__(). Метод должен воз- вращать положительное целое число: class MyClass: def __len__(self): return 50 c = MyClass() print(len(c)) # Выведет: 50 __bool__(self) — вызывается при использовании функции bool(); __int__(self) — вызывается при преобразовании объекта в целое число с помощью функции int(); __float__(self) — вызывается при преобразовании объекта в вещественное число с по- мощью функции float(); __complex__(self) — вызывается при преобразовании объекта в комплексное число с помощью функции complex(); __round__(self, n) — вызывается при использовании функции round(); __index__(self) — вызывается при использовании функций bin(), hex() и oct(); Глава 13. Объектно-ориентированное программирование 255 __repr__(self) и __str__(self) — служат для преобразования объекта в строку. Метод __repr__() вызывается при выводе в интерактивной оболочке, а также при использова- нии функции repr(). Метод __str__() вызывается при выводе с помощью функции print(), а также при использовании функции str(). Если метод __str__() отсутствует, будет вызван метод __repr__(). В качестве значения методы __repr__() и __str__()должны возвращать строку: class MyClass: def __init__(self, m): self.msg = m def __repr__(self): return "Вызван метод __repr__() {0}".format(self.msg) def __str__(self): return "Вызван метод __str__() {0}".format(self.msg) c = MyClass("Значение") print(repr(c)) # Выведет: Вызван метод __repr__() Значение print(str(c)) # Выведет: Вызван метод __str__() Значение print(c) # Выведет: Вызван метод __str__() Значение __hash__(self) — этот метод следует переопределить, если экземпляр класса планиру- ется использовать в качестве ключа словаря или внутри множества: class MyClass: def __init__(self, y): self.x = y def __hash__(self): return hash(self.x) c = MyClass(10) d = {} d[c] = "Значение" print(d[c]) # Выведет: Значение Классы поддерживают еще несколько специальных методов, которые применяются лишь в особых случаях и будут рассмотрены в главе 15. 13.6. Перегрузка операторов Перегрузка операторов позволяет экземплярам классов участвовать в обычных операциях. Чтобы перегрузить оператор, необходимо в классе определить метод со специальным на- званием. Для перегрузки математических операторов используются следующие методы: x + y — сложение: x.__add__(y); y + x — сложение (экземпляр класса справа): x.__radd__(y); x += y — сложение и присваивание: x.__iadd__(y); x — y — вычитание: x.__sub__(y); y — x — вычитание (экземпляр класса справа): x.__rsub__(y); x -= y — вычитание и присваивание: x.__isub__(y); x * y — умножение: x.__mul__(y); y * x — умножение (экземпляр класса справа): x.__rmul__(y); 256 Часть I. Основы языка Python x *= y — умножение и присваивание: x.__imul__(y); x / y — деление: x.__truediv__(y); y / x — деление (экземпляр класса справа): x.__rtruediv__(y); x /= y — деление и присваивание: x.__itruediv__(y); x // y — деление с округлением вниз: x.__floordiv__(y); y // x — деление с округлением вниз (экземпляр класса справа): x.__rfloordiv__(y); x //= y — деление с округлением вниз и присваивание: x.__ifloordiv__(y); x % y — остаток от деления: x.__mod__(y); y % x — остаток от деления (экземпляр класса справа): x.__rmod__(y); x %= y — остаток от деления и присваивание: x.__imod__(y); x ** y — возведение в степень: x.__pow__(y); y ** x — возведение в степень (экземпляр класса справа): x.__rpow__(y); x **= y — возведение в степень и присваивание: x.__ipow__(y); -x — унарный минус: x.__neg__(); +x — унарный плюс: x.__pos__(); abs(x) — абсолютное значение: x.__abs__()Пример перегрузки математических операторов приведен в листинге 13.13. Листинг 13.13. Пример перегрузки математических операторов class MyClass: def __init__(self, y): self.x = y def __add__(self, y): # Перегрузка оператора + print("Экземпляр слева") return self.x + y def __radd__(self, y): # Перегрузка оператора + print("Экземпляр справа") return self.x + y def __iadd__(self, y): # Перегрузка оператора += print("Сложение с присваиванием") self.x += y return self c = MyClass(50) print(c + 10) # Выведет: Экземпляр слева 60 print(20 + c) # Выведет: Экземпляр справа 70 c += 30 # Выведет: Сложение с присваиванием print(c.x) # Выведет: 80 Методы перегрузки двоичных операторов: x — двоичная инверсия: x.__invert__(); x & y — двоичное И: x.__and__(y); Глава 13. Объектно-ориентированное программирование 257 y & x — двоичное И (экземпляр класса справа): x.__rand__(y); x &= y — двоичное И и присваивание: x.__iand__(y); x | y — двоичное ИЛИ: x.__or__(y); y | x — двоичное ИЛИ (экземпляр класса справа): x.__ror__(y); x |= y — двоичное ИЛИ и присваивание: x.__ior__(y); x ^ y — двоичное исключающее ИЛИ: x.__xor__(y); y ^ x — двоичное исключающее ИЛИ (экземпляр класса справа): x.__rxor__(y); x ^= y — двоичное исключающее ИЛИ и присваивание: x.__ixor__(y); x << y — сдвиг влево: x.__lshift__(y); y << x — сдвиг влево (экземпляр класса справа): x.__rlshift__(y); x <<= y — сдвиг влево и присваивание: x.__ilshift__(y); x >> y — сдвиг вправо: x.__rshift__(y); y >> x — сдвиг вправо (экземпляр класса справа): x.__rrshift__(y); x >>= y — сдвиг вправо и присваивание: x.__irshift__(y)Перегрузка операторов сравнения производится с помощью следующих методов: x == y — равно: x.__eq__(y); x != y — не равно: x.__ne__(y); x < y — меньше: x.__lt__(y); x > y — больше: x.__gt__(y); x <= y — меньше или равно: x.__le__(y); x >= y — больше или равно: x.__ge__(y); y in x — проверка на вхождение: x.__contains__(y)Пример перегрузки операторов сравнения приведен в листинге 13.14. Листинг 13.14. Пример перегрузки операторов сравнения class MyClass: def __init__(self): self.x = 50 self.arr = [1, 2, 3, 4, 5] def __eq__(self, y): # Перегрузка оператора == return self.x == y def __contains__(self, y): # Перегрузка оператора in return y in self.arr c = MyClass() print("Равно" if c == 50 else "Не равно") # Выведет: Равно print("Равно" if c == 51 else "Не равно") # Выведет: Не равно print("Есть" if 5 in c else "Нет") # Выведет: Есть 258 Часть I. Основы языка Python 13.7. Статические методы и методы класса Внутри класса можно создать метод, который будет доступен без создания экземпляра класса (статический метод). Для этого перед определением метода внутри класса следует указать декоратор @staticmethod. Вызов статического метода без создания экземпляра клас- са осуществляется следующим образом: <Название класса>.<Название метода>(<Параметры>) Кроме того, можно вызвать статический метод через экземпляр класса: <Экземпляр класса>.<Название метода>(<Параметры>) Пример использования статических методов приведен в листинге 13.15. Листинг 13.15. Статические методы class MyClass: @staticmethod def func1(x, y): # Статический метод return x + y def func2(self, x, y): # Обычный метод в классе return x + y def func3(self, x, y): return MyClass.func1(x, y) # Вызов из метода класса print(MyClass.func1(10, 20)) # Вызываем статический метод c = MyClass() print(c.func2(15, 6)) # Вызываем метод класса print(c.func1(50, 12)) # Вызываем статический метод # через экземпляр класса print(c.func3(23, 5)) # Вызываем статический метод # внутри класса Обратите внимание на то, что в определении статического метода нет параметра self. Это означает, что внутри статического метода нет доступа к атрибутам и методам экземпляра класса. Методы класса создаются с помощью декоратора @classmethod. В качестве первого пара- метра в метод класса передается ссылка на класс. Вызов метода класса осуществляется сле- дующим образом: <Название класса>.<Название метода>(<Параметры>) Кроме того, можно вызвать метод класса через экземпляр класса: <Экземпляр класса>.<Название метода>(<Параметры>) Пример использования методов класса приведен в листинге 13.16. Листинг 13.16. Методы класса class MyClass: @classmethod def func(cls, x): # Метод класса print(cls, x) Глава 13. Объектно-ориентированное программирование 259 MyClass.func(10) # Вызываем метод через название класса c = MyClass() c.func(50) # Вызываем метод класса через экземпляр 13.8. Абстрактные методы Абстрактные методы содержат только определение метода без реализации. Предполагает- ся, что производный класс должен переопределить метод и реализовать его функциональ- ность. Чтобы такое предположение сделать более очевидным, часто внутри абстрактного метода возбуждают исключение (листинг 13.17). Листинг 13.17. Абстрактные методы class Class1: def func(self, x): # Абстрактный метод # Возбуждаем исключение с помощью raise raise NotImplementedError("Необходимо переопределить метод") class Class2(Class1): # Наследуем абстрактный метод def func(self, x): # Переопределяем метод print(x) class Class3(Class1): # Класс не переопределяет метод pass c2 = Class2() c2.func(50) # Выведет: 50 c3 = Class3() try: # Перехватываем исключения c3.func(50) # Ошибка. Метод func() не переопределен except NotImplementedError as msg: print(msg) # Выведет: Необходимо переопределить метод В состав стандартной библиотеки входит модуль abc. В этом модуле определен декоратор @abstractmethod, который позволяет указать, что метод, перед которым расположен декора- тор, является абстрактным. При попытке создать экземпляр производного класса, в котором не переопределен абстрактный метод, возбуждается исключение TypeError. Рассмотрим использование декоратора @abstractmethod на примере (листинг 13.18). Листинг 13.18. Использование декоратора @abstractmethod from abc import ABCMeta, abstractmethod class Class1(metaclass=ABCMeta): @abstractmethod def func(self, x): # Абстрактный метод pass class Class2(Class1): # Наследуем абстрактный метод def func(self, x): # Переопределяем метод print(x) 260 Часть I. Основы языка Python class Class3(Class1): # Класс не переопределяет метод pass c2 = Class2() c2.func(50) # Выведет: 50 try: c3 = Class3() # Ошибка. Метод func() не переопределен c3.func(50) except TypeError as msg: print(msg) # Can't instantiate abstract class Class3 # with abstract methods func Имеется возможность создания абстрактных статических методов и абстрактных методов класса, для чего необходимые декораторы указываются одновременно, друг за другом. Для примера объявим класс с абстрактными статическим методом и методом класса (лис- тинг 13.19). Листинг 13.19. Абстрактный статический метод и абстрактный метод класса from abc import ABCMeta, abstractmethod class MyClass(metaclass=ABCMeta): @staticmethod @abstractmethod def static_func(self, x): # Абстрактный статический метод pass @classmethod @abstractmethod def class_func(self, x): # Абстрактный метод класса pass 13.9. Ограничение доступа к идентификаторам внутри класса Все идентификаторы внутри класса в языке Python являются открытыми, т. е. доступны для непосредственного изменения. Для имитации частных идентификаторов можно воспользо- ваться методами __getattr__(), __getattribute__() и __setattr__(), которые перехваты- вают обращения к атрибутам класса. Кроме того, можно воспользоваться идентификатора- ми, названия которых начинаются с двух символов подчеркивания. Такие идентификаторы называются псевдочастными. Псевдочастные идентификаторы доступны лишь внутри класса, но никак не вне его. Тем не менее изменить идентификатор через экземпляр класса все равно можно, зная, каким образом искажается название идентификатора. Напри- мер, идентификатор __privateVar внутри класса Class1 будет доступен по имени _Class1__ privateVar. Как можно видеть, здесь перед идентификатором добавляется название класса с предваряющим символом подчеркивания. Приведем пример использования псевдочаст- ных идентификаторов (листинг 13.20). Глава 13. Объектно-ориентированное программирование 261 Листинг 13.20. Псевдочастные идентификаторы class MyClass: def __init__(self, x): self.__privateVar = x def set_var(self, x): # Изменение значения self.__privateVar = x def get_var(self): # Получение значения return self.__privateVar c = MyClass(10) # Создаем экземпляр класса print(c.get_var()) # Выведет: 10 c.set_var(20) # Изменяем значение print(c.get_var()) # Выведет: 20 try: # Перехватываем ошибки print(c.__privateVar) # Ошибка!!! except AttributeError as msg: print(msg) # Выведет: 'MyClass' object has # no attribute '__privateVar' c._MyClass__privateVar = 50 # Значение псевдочастных атрибутов # все равно можно изменить print(c.get_var()) # Выведет: 50 Можно также ограничить перечень атрибутов, разрешенных для экземпляров класса. Для этого разрешенные атрибуты указываются внутри класса в атрибуте __slots__. В качестве значения атрибуту можно присвоить строку или список строк с названиями идентификато- ров. Если производится попытка обращения к атрибуту, не указанному в __slots__, возбу- ждается исключение AttributeError (листинг 13.21). Листинг 13.21. Использование атрибута __slots__ class MyClass: __slots__ = ["x", "y"] def __init__(self, a, b): self.x, self.y = a, b c = MyClass(1, 2) print(c.x, c.y) # Выведет: 1 2 c.x, c.y = 10, 20 # Изменяем значения атрибутов print(c.x, c.y) # Выведет: 10 20 try: # Перехватываем исключения c.z = 50 # Атрибут z не указан в __slots__, # поэтому возбуждается исключение except AttributeError as msg: print(msg) # 'MyClass' object has no attribute 'z' 13.10. Свойства класса Внутри класса можно создать идентификатор, через который в дальнейшем будут произво- диться операции получения и изменения значения какого-либо атрибута, а также его удале- ния. Создается такой идентификатор с помощью функции property(). Формат функции: 262 Часть I. Основы языка Python <Свойство> = property(<Чтение>[, <Запись>[, <Удаление> [, <Строка документирования>]]]) В первых трех параметрах указывается ссылка на соответствующий метод класса. При по- пытке получить значение будет вызван метод, указанный в первом параметре. При опера- ции присваивания значения будет вызван метод, указанный во втором параметре, — этот метод должен принимать один параметр. В случае удаления атрибута вызывается метод, указанный в третьем параметре. Если в качестве какого-либо параметра задано значение None, то это означает, что соответствующий метод не поддерживается. Рассмотрим свойства класса на примере (листинг 13.22). Листинг 13.22. Свойства класса class MyClass: def __init__(self, value): self.__var = value def get_var(self): # Чтение return self.__var def set_var(self, value): # Запись self.__var = value def del_var(self): # Удаление del self.__var v = property(get_var, set_var, del_var, "Строка документирования") c = MyClass(5) c.v = 35 # Вызывается метод set_var() print(c.v) # Вызывается метод get_var() del c.v # Вызывается метод del_var() Python поддерживает альтернативный метод определения свойств — с помощью методов getter(), setter() и deleter(), которые используются в декораторах. Соответствующий пример приведен в листинге 13.23. Листинг 13.23. Методы getter(), setter() и deleter() class MyClass: def __init__(self, value): self.__var = value @property def v(self): # Чтение return self.__var @v.setter def v(self, value): # Запись self.__var = value @v.deleter def v(self): # Удаление del self.__var c = MyClass(5) c.v = 35 # Запись print(c.v) # Чтение del c.v # Удаление Глава 13. Объектно-ориентированное программирование 263 Имеется возможность определить абстрактное свойство — в этом случае все реализующие его методы должны быть переопределены в подклассе. Выполняется это с помощью знако- мого нам декоратора 1   ...   21   22   23   24   25   26   27   28   ...   83

QMargins из модуля QtCore, конструктор которого имеет следующий формат: QMargins(<Граница слева>, <Граница сверху>, <Граница справа>, <Граница снизу>) Текущая область при этом не изменяется: >>> r1 = QtCore.QRect(10, 15, 400, 300) >>> m = QtCore.QMargins(5, 2, 5, 2) 376 Часть II. Библиотека PyQt 5 >>> r2 = r1.marginsAdded(m) >>> r2 PyQt5.QtCore.QRect(5, 13, 410, 304) >>> r1 PyQt5.QtCore.QRect(10, 15, 400, 300) marginsRemoved() — то же самое, что marginsAdded(), но уменьшает новую область на заданные величины границ: >>> r1 = QtCore.QRect(10, 15, 400, 300) >>> m = QtCore.QMargins(2, 10, 2, 10) >>> r2 = r1.marginsRemoved(m) >>> r2 PyQt5.QtCore.QRect(12, 25, 396, 280) >>> r1 PyQt5.QtCore.QRect(10, 15, 400, 300) Переместить область при изменении координат позволяют следующие методы: moveTo(, ), moveTo(), moveLeft() и moveTop() — задают новые координаты левого верхнего угла: >>> r = QtCore.QRect(10, 15, 400, 300) >>> r.moveTo(0, 0); r PyQt5.QtCore.QRect(0, 0, 400, 300) >>> r.moveTo(QtCore.QPoint(10, 10)); r PyQt5.QtCore.QRect(10, 10, 400, 300) >>> r.moveLeft(5); r.moveTop(0); r PyQt5.QtCore.QRect(5, 0, 400, 300) moveRight() и moveBottom() — задают новые координаты правого нижнего угла; moveTopLeft() — задает новые координаты левого верхнего угла; moveTopRight() — задает новые координаты правого верхнего угла; moveBottomLeft() — задает новые координаты левого нижнего угла; moveBottomRight() — задает новые координаты правого нижнего угла. Примеры: >>> r = QtCore.QRect(10, 15, 400, 300) >>> r.moveTopLeft(QtCore.QPoint(0, 0)); r PyQt5.QtCore.QRect(0, 0, 400, 300) >>> r.moveBottomRight(QtCore.QPoint(599, 499)); r PyQt5.QtCore.QRect(200, 200, 400, 300) moveCenter() — задает новые координаты центра; translate(<Сдвиг по оси X>, <Сдвиг по оси Y>) и translate() — задают но- вые координаты левого верхнего угла относительно текущего значения координат: >>> r = QtCore.QRect(0, 0, 400, 300) >>> r.translate(20, 15); r PyQt5.QtCore.QRect(20, 15, 400, 300) >>> r.translate(QtCore.QPoint(10, 5)); r PyQt5.QtCore.QRect(30, 20, 400, 300) Глава 18. Управление окном приложения 377 translated(<Сдвиг по оси X>, <Сдвиг по оси Y>) и translated() — анало- гичен методу translate(), но возвращает новый экземпляр класса QRect, а не изменяет текущий; adjust(, , , ) — задает новые координаты левого верхнего и правого нижнего углов относительно текущих значений координат: >>> r = QtCore.QRect(0, 0, 400, 300) >>> r.adjust(10, 5, 10, 5); r PyQt5.QtCore.QRect(10, 5, 400, 300) adjusted(, , , ) — аналогичен методу adjust(), но возвращает но- вый экземпляр класса QRect, а не изменяет текущий. Для получения параметров области предназначены следующие методы: left() и x() — возвращают координату левого верхнего угла по оси X; top() и y() — возвращают координату левого верхнего угла по оси Y; right() и bottom() — возвращают координаты правого нижнего угла по осям X и Y соот- ветственно; width() и height() — возвращают ширину и высоту соответственно; size() — возвращает размеры в виде экземпляра класса QSizeПримеры: >>> r = QtCore.QRect(10, 15, 400, 300) >>> r.left(), r.top(), r.x(), r.y(), r.right(), r.bottom() (10, 15, 10, 15, 409, 314) >>> r.width(), r.height(), r.size() (400, 300, PyQt5.QtCore.QSize(400, 300)) topLeft() — возвращает координаты левого верхнего угла; topRight() — возвращает координаты правого верхнего угла; bottomLeft() — возвращает координаты левого нижнего угла; bottomRight() — возвращает координаты правого нижнего угла. Примеры: >>> r = QtCore.QRect(10, 15, 400, 300) >>> r.topLeft(), r.topRight() (PyQt5.QtCore.QPoint(10, 15), PyQt5.QtCore.QPoint(409, 15)) >>> r.bottomLeft(), r.bottomRight() (PyQt5.QtCore.QPoint(10, 314), PyQt5.QtCore.QPoint(409, 314)) center() — возвращает координаты центра области. Например, вывести окно по центру доступной области экрана можно так: desktop = QtWidgets.QApplication.desktop() window.move(desktop.availableGeometry().center() - window.rect().center()) getRect() — возвращает кортеж с координатами левого верхнего угла и размерами об- ласти; getCoords() — возвращает кортеж с координатами левого верхнего и правого нижнего углов: 378 Часть II. Библиотека PyQt 5 >>> r = QtCore.QRect(10, 15, 400, 300) >>> r.getRect(), r.getCoords() ((10, 15, 400, 300), (10, 15, 409, 314)) Прочие методы: isNull() — возвращает True, если ширина и высота равны нулю, и False — в противном случае; isValid() — возвращает True, если left() < right() и top() < bottom(), и False — в противном случае; isEmpty() — возвращает True, если left() > right() или top() > bottom(), и False — в противном случае; normalized() — исправляет ситуацию, при которой left() > right() или top() > bottom(), и возвращает новый экземпляр класса QRect: >>> r = QtCore.QRect(QtCore.QPoint(409, 314), QtCore.QPoint(10, 15)) >>> r PyQt5.QtCore.QRect(409, 314, -398, -298) >>> r.normalized() PyQt5.QtCore.QRect(10, 15, 400, 300) contains([, <Флаг>]) и contains(, [, <Флаг>]) — возвращает True, если точка с указанными координатами расположена внутри области или на ее границе, и False — в противном случае. Если во втором параметре указано значение True, то точка должна быть расположена только внутри области, а не на ее границе. Значение парамет- ра по умолчанию — False: >>> r = QtCore.QRect(0, 0, 400, 300) >>> r.contains(0, 10), r.contains(0, 10, True) (True, False) contains([, <Флаг>]) — возвращает True, если указанная область расположена внутри текущей области или на ее краю, и False — в противном случае. Если во втором параметре указано значение True, то указанная область должна быть расположена толь- ко внутри текущей области, а не на ее краю. Значение параметра по умолчанию — False: >>> r = QtCore.QRect(0, 0, 400, 300) >>> r.contains(QtCore.QRect(0, 0, 20, 5)) True >>> r.contains(QtCore.QRect(0, 0, 20, 5), True) False intersects() — возвращает True, если указанная область пересекается с текущей областью, и False — в противном случае; intersected() — возвращает область, которая расположена на пересечении те- кущей и указанной областей: >>> r = QtCore.QRect(0, 0, 20, 20) >>> r.intersects(QtCore.QRect(10, 10, 20, 20)) True >>> r.intersected(QtCore.QRect(10, 10, 20, 20)) PyQt5.QtCore.QRect(10, 10, 10, 10) Глава 18. Управление окном приложения 379 united() — возвращает область, которая охватывает текущую и указанную об- ласти: >>> r = QtCore.QRect(0, 0, 20, 20) >>> r.united(QtCore.QRect(30, 30, 20, 20)) PyQt5.QtCore.QRect(0, 0, 50, 50) Над двумя экземплярами класса QRect можно выполнять операции & и &= (пересечение), | и |= (объединение), in (проверка на вхождение), == и !=Пример: >>> r1, r2 = QtCore.QRect(0, 0, 20, 20), QtCore.QRect(10, 10, 20, 20) >>> r1 & r2, r1 | r2 (PyQt5.QtCore.QRect(10, 10, 10, 10), PyQt5.QtCore.QRect(0, 0, 30, 30)) >>> r1 in r2, r1 in QtCore.QRect(0, 0, 30, 30) (False, True) >>> r1 == r2, r1 != r2 (False, True) Помимо этого, поддерживаются операторы + и -, выполняющие увеличение и уменьшение области на заданные величины границ, которые должны быть заданы в виде объекта класса QMargins: >>> r = QtCore.QRect(10, 15, 400, 300) >>> m = QtCore.QMargins(5, 15, 5, 15) >>> r + m PyQt5.QtCore.QRect(5, 0, 410, 330) >>> r - m PyQt5.QtCore.QRect(15, 30, 390, 270) 18.6. Разворачивание и сворачивание окна В заголовке окна расположены кнопки Свернуть и Развернуть, с помощью которых мож- но свернуть окно в значок на панели задач или развернуть его на весь экран. Выполнить подобные действия из программы позволяют следующие методы класса QWidget: showMinimized() — сворачивает окно на панель задач. Эквивалентно нажатию кнопки Свернуть в заголовке окна; showMaximized() — разворачивает окно до максимального размера. Эквивалентно нажа- тию кнопки Развернуть в заголовке окна; showFullScreen() — включает полноэкранный режим отображения окна. Окно отобра- жается без заголовка и границ; showNormal() — отменяет сворачивание, максимальный размер и полноэкранный режим, возвращая окно к изначальным размерам; activateWindow() — делает окно активным (т. е. имеющим фокус ввода). В Windows, если окно было ранее свернуто в значок на панель задач, оно не будет развернуто в из- начальный вид; setWindowState(<Флаги>) — изменяет состояние окна в зависимости от переданных фла- гов. В качестве параметра указывается комбинация следующих атрибутов из класса QtCore.Qt через побитовые операторы: 380 Часть II. Библиотека PyQt 5 • WindowNoState — нормальное состояние окна; • WindowMinimized — окно свернуто; • WindowMaximized — окно максимально развернуто; • WindowFullScreen — полноэкранный режим; • WindowActive — окно имеет фокус ввода, т. е. является активным. Например, включить полноэкранный режим можно так: window.setWindowState((window.windowState() & (QtCore.Qt.WindowMinimized | QtCore.Qt.WindowMaximized)) | QtCore.Qt.WindowFullScreen) Проверить текущий статус окна позволяют следующие методы: isMinimized() — возвращает True, если окно свернуто, и False — в противном случае; isMaximized() — возвращает True, если окно раскрыто до максимальных размеров, и False — в противном случае; isFullScreen() — возвращает True, если включен полноэкранный режим, и False — в противном случае; isActiveWindow() — возвращает True, если окно имеет фокус ввода, и False — в про- тивном случае; windowState() — возвращает комбинацию флагов, обозначающих текущий статус окна. Пример проверки использования полноэкранного режима: if window.windowState() & QtCore.Qt.WindowFullScreen: print("Полноэкранный режим") Пример разворачивания и сворачивания окна приведен в листинге 18.4. Листинг 18.4. Разворачивание и сворачивание окна # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets class MyWindow(QtWidgets.QWidget): def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) self.btnMin = QtWidgets.QPushButton("Свернуть") self.btnMax = QtWidgets.QPushButton("Развернуть") self.btnFull = QtWidgets.QPushButton("Полный экран") self.btnNormal = QtWidgets.QPushButton("Нормальный размер") vbox = QtWidgets.QVBoxLayout() vbox.addWidget(self.btnMin) vbox.addWidget(self.btnMax) vbox.addWidget(self.btnFull) vbox.addWidget(self.btnNormal) self.setLayout(vbox) self.btnMin.clicked.connect(self.on_min) self.btnMax.clicked.connect(self.on_max) self.btnFull.clicked.connect(self.on_full) self.btnNormal.clicked.connect(self.on_normal) Глава 18. Управление окном приложения 381 def on_min(self): self.showMinimized() def on_max(self): self.showMaximized() def on_full(self): self.showFullScreen() def on_normal(self): self.showNormal() if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) window = MyWindow() window.setWindowTitle("Разворачивание и сворачивание окна") window.resize(300, 100) window.show() sys.exit(app.exec_()) 18.7. Управление прозрачностью окна Сделать окно полупрозрачным позволяет метод setWindowOpacity() класса QWidget. Формат метода: setWindowOpacity(<Вещественное число от 0.0 до 1.0>) Число 0.0 соответствует полностью прозрачному окну, а число 1.0 — отсутствию прозрач- ности. Для получения степени прозрачности окна из программы предназначен метод windowOpacity(). Выведем окно со степенью прозрачности 0.5 (листинг 18.5). Листинг 18.5. Полупрозрачное окно # -*- coding: utf-8 -*- from PyQt5 import QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowTitle("Полупрозрачное окно") window.resize(300, 100) window.setWindowOpacity(0.5) window.show() print(window.windowOpacity()) # Выведет: 0.4980392156862745 sys.exit(app.exec_()) 18.8. Модальные окна Модальным называется окно, которое не позволяет взаимодействовать с другими окнами в том же приложении, — пока модальное окно не будет закрыто, сделать активным другое окно нельзя. Например, если в программе Microsoft Word выбрать пункт меню Файл | Со- хранить как, откроется модальное диалоговое окно, позволяющее выбрать путь и название 382 Часть II. Библиотека PyQt 5 файла, и, пока это окно не будет закрыто, вы не сможете взаимодействовать с главным ок- ном приложения. Указать, что окно является модальным, позволяет метод setWindowModality(<Флаг>) класса QWidget. В качестве параметра могут быть указаны следующие атрибуты из класса QtCore.Qt: NonModal — 0 — окно не является модальным (поведение по умолчанию); WindowModal — 1 — окно блокирует только родительские окна в пределах иерархии; ApplicationModal — 2 — окно блокирует все окна в приложении. Окна, открытые из модального окна, не блокируются. Следует также учитывать, что метод setWindowModality() должен быть вызван до отображения окна. Получить текущее значение модальности позволяет метод windowModality(). Проверить, является ли окно модальным, можно с помощью метода isModal() — он возвращает True, если окно является модальным, и False — в противном случае. Создадим два независимых окна. В первом окне разместим кнопку, по нажатию которой откроется модальное окно, — оно будет блокировать только первое окно, но не второе. При открытии модального окна отобразим его примерно по центру родительского окна (лис- тинг 18.6). Листинг 18.6. Модальные окна # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets import sys def show_modal_window(): global modalWindow modalWindow = QtWidgets.QWidget(window1, QtCore.Qt.Window) modalWindow.setWindowTitle("Модальное окно") modalWindow.resize(200, 50) modalWindow.setWindowModality(QtCore.Qt.WindowModal) modalWindow.setAttribute(QtCore.Qt.WA_DeleteOnClose, True) modalWindow.move(window1.geometry().center() - modalWindow.rect().center() – QtCore.QPoint(4, 30)) modalWindow.show() app = QtWidgets.QApplication(sys.argv) window1 = QtWidgets.QWidget() window1.setWindowTitle("Обычное окно") window1.resize(300, 100) button = QtWidgets.QPushButton("Открыть модальное окно") button.clicked.connect(show_modal_window) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(button) window1.setLayout(vbox) window1.show() window2 = QtWidgets.QWidget() window2.setWindowTitle("Это окно не будет блокировано при WindowModal") Глава 18. Управление окном приложения 383 window2.resize(500, 100) window2.show() sys.exit(app.exec_()) Если запустить приложение и нажать кнопку Открыть модальное окно, откроется окно, выровненное примерно по центру родительского окна (произвести точное выравнивание вы сможете самостоятельно). При этом получить доступ к родительскому окну можно только после закрытия модального окна, второе же окно блокировано не будет. Если заменить атрибут WindowModal атрибутом ApplicationModal, оба окна будут блокированы. Обратите внимание, что в конструктор модального окна мы передали ссылку на первое ок- но и атрибут Window. Если не указать ссылку, то окно блокировано не будет, а если не ука- зать атрибут, окно вообще не откроется. Кроме того, мы объявили переменную modalWindow глобальной, иначе при достижении конца функции переменная выйдет из области видимо- сти, и окно будет автоматически удалено. Чтобы объект окна автоматически удалялся при закрытии окна, атрибуту WA_DeleteOnClose в методе setAttribute() было присвоено значе- ние TrueМодальные окна в большинстве случаев являются диалоговыми. Для работы с такими окнами в PyQt предназначен класс QDialog, который автоматически выравнивает окно по центру экрана или родительского окна. Кроме того, этот класс предоставляет множество специальных методов, позволяющих дождаться закрытия окна, определить статус заверше- ния и выполнить другие действия. Подробно класс QDialog мы рассмотрим в главе 26. 18.9. Смена значка в заголовке окна По умолчанию в левом верхнем углу окна отображается стандартный значок. Отобразить другой значок позволяет метод setWindowIcon() класса QWidget. В качестве параметра метод принимает экземпляр класса QIcon из модуля QtGui (см. разд. 24.3.4). Чтобы загрузить значок из файла, следует передать путь к файлу конструктору класса QIcon. Если указан относительный путь, поиск файла будет производиться относительно текущего рабочего каталога. Получить список поддерживаемых форматов файлов можно с помощью статического метода supportedImageFormats() класса QImageReader, объявлен- ного в модуле QtGui. Метод возвращает список с экземплярами класса QByteArray. Получим список поддерживаемых форматов: >>> from PyQt5 import QtGui >>> for i in QtGui.QImageReader.supportedImageFormats(): print(str(i, "ascii").upper(), end=" ") Вот результат выполнения этого примера на компьютере одного из авторов: BMP CUR GIF ICNS ICO JPEG JPG PBM PGM PNG PPM SVG SVGZ TGA TIF TIFF WBMP WEBP XBM XPM Если для окна не указать значок, будет использоваться значок приложения, установленный с помощью метода setWindowIcon() класса QApplication. В качестве параметра метод также принимает экземпляр класса QIconВместо загрузки значка из файла можно воспользоваться одним из встроенных значков. Загрузить стандартный значок позволяет следующий код: ico = window.style().standardIcon(QtWidgets.QStyle.SP_MessageBoxCritical) window.setWindowIcon(ico) 384 Часть II. Библиотека PyQt 5 Посмотреть список всех встроенных значков можно в документации к классу QStyle(см. https://doc.qt.io/qt-5/qstyle.html#StandardPixmap-enum). В качестве примера создадим значок размером 16 на 16 пикселов в формате PNG и сохра- ним его в одном каталоге с программой, после чего установим этот значок для окна и всего приложения (листинг 18.7). Листинг 18.7. Смена значка в заголовке окна # -*- coding: utf-8 -*- from PyQt5 import QtGui, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowTitle("Смена значка в заголовке окна") window.resize(300, 100) ico = QtGui.QIcon("icon.png") window.setWindowIcon(ico) # Значок для окна app.setWindowIcon(ico) # Значок приложения window.show() sys.exit(app.exec_()) 18.10. Изменение цвета фона окна Чтобы изменить цвет фона окна (или компонента), следует установить палитру с настроен- ной ролью Window (или Background). Цветовая палитра содержит цвета для каждой роли и состояния компонента. Указать состояние компонента позволяют следующие атрибуты из класса QPalette (модуль QtGui): Active и Normal — 0 — компонент активен (окно находится в фокусе ввода); Disabled — 1 — компонент недоступен; Inactive — 2 — компонент неактивен (окно находится вне фокуса ввода). Получить текущую палитру компонента позволяет его метод palette(). Чтобы изменить цвет для какой-либо роли и состояния, следует воспользоваться методом setColor() класса QPalette. Формат метода: setColor([<Состояние>, ]<Роль>, <Цвет>) В параметре <Роль> указывается, для какого элемента изменяется цвет. Например, атрибут Window (или Background) изменяет цвет фона, а WindowText (или Foreground) — цвет текста. Полный список атрибутов имеется в документации по классу QPalette (см. https://doc.qt.io/ qt-5/qpalette.html). В параметре <Цвет> указывается цвет элемента. В качестве значения можно указать атрибут из класса QtCore.Qt (например, black, white и т. д.) или экземпляр класса QColor (например, QColor("red"), QColor("#ff0000"), QColor(255, 0, 0) и др.). После настройки палитры необходимо вызвать метод setPalette() компонента и передать этому методу измененный объект палитры. Следует помнить, что компоненты-потомки по умолчанию имеют прозрачный фон и не перерисовываются автоматически. Чтобы вклю- Глава 18. Управление окном приложения 385 чить перерисовку, необходимо передать значение True методу setAutoFillBackground()окна. Изменить цвет фона также можно с помощью CSS-атрибута background-color. Для этого следует передать таблицу стилей в метод setStyleSheet() компонента. Таблицы стилей могут быть внешними (подключение через командную строку), установленными на уровне приложения (с помощью метода setStyleSheet() класса QApplication) или установленными на уровне компонента (с помощью метода setStyleSheet() класса QWidget). Атрибуты, установленные последними, обычно перекрывают значения аналогичных атрибутов, ука- занных ранее. Если вы занимались веб-программированием, то язык CSS (каскадные табли- цы стилей) вам уже знаком, а если нет, придется дополнительно его изучить. Создадим окно с надписью. Для активного окна установим зеленый цвет, а для неактивно- го — красный. Цвет фона надписи сделаем белым. Для изменения фона окна используем палитру, а для изменения цвета фона надписи — CSS-атрибут background-color (лис- тинг 18.8). Листинг 18.8. Изменение цвета фона окна # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtGui, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowTitle("Изменение цвета фона окна") window.resize(300, 100) pal = window.palette() pal.setColor(QtGui.QPalette.Normal, QtGui.QPalette.Window, QtGui.QColor("#008800")) pal.setColor(QtGui.QPalette.Inactive, QtGui.QPalette.Window, QtGui.QColor("#ff0000")) window.setPalette(pal) label = QtWidgets.QLabel("Текст надписи") label.setAlignment(QtCore.Qt.AlignHCenter) label.setStyleSheet("background-color: #ffffff;") label.setAutoFillBackground(True) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(label) window.setLayout(vbox) window.show() sys.exit(app.exec_()) 18.11. Вывод изображения в качестве фона В качестве фона окна (или компонента) можно использовать изображение. Для этого необ- ходимо получить текущую палитру компонента с помощью метода palette(), а затем вы- звать метод setBrush() класса QPalette. Формат метода: setBrush([<Состояние>, ]<Роль>, ) 386 Часть II. Библиотека PyQt 5 Первые два параметра аналогичны соответствующим параметрам в методе setColor(), ко- торый мы рассматривали в предыдущем разделе. В третьем параметре указывается кисть — экземпляр класса QBrush из модуля QtGui. Форматы конструктора класса: <Объект> = QBrush(<Стиль кисти>) <Объект> = QBrush(<Цвет>[, <Стиль кисти>=SolidPattern]) <Объект> = QBrush(<Цвет>, ) <Объект> = QBrush() <Объект> = QBrush() <Объект> = QBrush() <Объект> = QBrush() В параметре <Стиль кисти> указываются атрибуты из класса QtCore.Qt, задающие стиль кисти, — например: NoBrush, SolidPattern, Dense1Pattern, Dense2Pattern, Dense3Pattern, Dense4Pattern, Dense5Pattern, Dense6Pattern, Dense7Pattern, CrossPattern и др. С по- мощью этого параметра можно сделать цвет сплошным (SolidPattern) или имеющим тек- стуру (например, атрибут CrossPattern задает текстуру в виде сетки). В параметре <Цвет> указывается цвет кисти. В качестве значения можно указать атрибут из класса QtCore.Qt (например, black, white и т. д.) или экземпляр класса QColor (например, QColor("red"), QColor("#ff0000"), QColor(255, 0, 0) и др.). При этом установка сплошного цвета фона окна может выглядеть так: pal = window.palette() pal.setBrush(QtGui.QPalette.Normal, QtGui.QPalette.Window, QtGui.QBrush(QtGui.QColor("#008800"), QtCore.Qt.SolidPattern)) window.setPalette(pal) Параметры и позволяют передать объекты изображений. Конструкторы этих классов принимают путь к файлу — абсолютный или относительный. Параметр позволяет создать кисть на основе другой кисти, а параметр — на основе градиента, представленного объектом класса QGradient (см. главу 24). После настройки палитры необходимо вызвать метод setPalette() и передать ему изме- ненный объект палитры. Следует помнить, что компоненты-потомки по умолчанию имеют прозрачный фон и не перерисовываются автоматически. Чтобы включить перерисовку, не- обходимо передать значение True в метод setAutoFillBackground()Указать, какое изображение используется в качестве фона, также можно с помощью CSS- атрибутов background и background-image. С помощью CSS-атрибута background-repeat можно дополнительно указать режим повтора фонового рисунка. Он может принимать зна- чения repeat (повтор по горизонтали и вертикали), repeat-x (повтор только по горизонта- ли), repeat-y (повтор только по вертикали) и no-repeat (не повторяется). Создадим окно с надписью. Для активного окна установим одно изображение (с помощью изменения палитры), а для надписи — другое (с помощью CSS-атрибута background-image) (листинг 18.9). Листинг 18.9. Использование изображения в качестве фона # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtGui, QtWidgets import sys Глава 18. Управление окном приложения 387 app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowTitle("Изображение в качестве фона") window.resize(300, 100) pal = window.palette() pal.setBrush(QtGui.QPalette.Normal, QtGui.QPalette.Window, QtGui.QBrush(QtGui.QPixmap("background1.jpg"))) window.setPalette(pal) label = QtWidgets.QLabel("Текст надписи") label.setAlignment(QtCore.Qt.AlignCenter) label.setStyleSheet("background-image: url(background2.jpg);") label.setAutoFillBackground(True) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(label) window.setLayout(vbox) window.show() sys.exit(app.exec_()) 18.12. Создание окна произвольной формы Чтобы создать окно произвольной формы, нужно выполнить следующие шаги: 1. Создать изображение нужной формы с прозрачным фоном и сохранить его, например, в формате PNG. 2. Создать экземпляр класса QPixmap, передав конструктору класса абсолютный или отно- сительный путь к изображению. 3. Установить изображение в качестве фона окна с помощью палитры. 4. Отделить альфа-канал с помощью метода mask() класса QPixmap5. Передать получившуюся маску в метод setMask() окна. 6. Убрать рамку окна, например, передав комбинацию следующих флагов: QtCore.Qt.Window | QtCore.Qt.FramelessWindowHint Если для создания окна используется класс QLabel, то вместо установки палитры можно передать экземпляр класса QPixmap в метод setPixmap(), а маску — в метод setMask()Для примера создадим круглое окно с кнопкой, с помощью которой можно закрыть окно. Для использования в качестве маски создадим изображение в формате PNG, установим для него прозрачный фон и нарисуем белый круг, занимающий все это изображение. Окно выведем без заголовка и границ (листинг 18.10). Листинг 18.10. Создание окна произвольной формы # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtGui, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.FramelessWindowHint) 388 Часть II. Библиотека PyQt 5 window.setWindowTitle("Создание окна произвольной формы") window.resize(300, 300) pixmap = QtGui.QPixmap("mask.png") pal = window.palette() pal.setBrush(QtGui.QPalette.Normal, QtGui.QPalette.Window, QtGui.QBrush(pixmap)) pal.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, QtGui.QBrush(pixmap)) window.setPalette(pal) window.setMask(pixmap.mask()) button = QtWidgets.QPushButton("Закрыть окно", window) button.setFixedSize(150, 30) button.move(75, 135) button.clicked.connect(QtWidgets.qApp.quit) window.show() sys.exit(app.exec_()) Получившееся окно можно увидеть на рис. 18.1. Рис. 18.1. Окно круглой формы 18.13. Всплывающие подсказки При работе с программой у пользователя могут возникать вопросы о предназначении того или иного компонента. Обычно для информирования пользователя служат надписи, распо- ложенные над компонентом или левее его. Но часто либо место в окне ограничено, либо вывод этих надписей портит весь дизайн окна. В таких случаях принято выводить текст подсказки в отдельном окне без рамки при наведении указателя мыши на компонент. Под- сказка автоматически скроется после увода курсора мыши или спустя определенное время. В PyQt нет необходимости создавать окно с подсказкой самому и следить за перемещения- ми указателя мыши — весь этот процесс автоматизирован и максимально упрощен. Чтобы создать всплывающие подсказки для окна или любого другого компонента и управлять ими, нужно воспользоваться следующими методами класса QWidget: Глава 18. Управление окном приложения 389 setToolTip(<Текст>) — задает текст всплывающей подсказки. В качестве параметра можно указать простой текст или HTML-код. Чтобы отключить вывод подсказки, доста- точно передать в этот метод пустую строку; toolTip() — возвращает текст всплывающей подсказки; setToolTipDuration(<Время>) — задает время, в течение которого всплывающая под- сказка будет присутствовать на экране. Значение должно быть указано в миллисекундах. Если задать значение -1, PyQt будет сама вычислять необходимое время, основываясь на длине текста подсказки (это поведение по умолчанию); toolTipDuration() — возвращает время, в течение которого всплывающая подсказка будет присутствовать на экране; setWhatsThis(<Текст>) — задает текст справки. Обычно этот метод используется для вывода информации большего объема, чем во всплывающей подсказке. У диалоговых окон в заголовке окна есть кнопка Справка, по нажатию которой курсор принимает вид стрелки со знаком вопроса, — чтобы в таком случае отобразить текст справки, следует нажать эту кнопку и щелкнуть на компоненте. Можно также сделать компонент актив- ным и нажать комбинацию клавиш +. В качестве параметра можно указать простой текст или HTML-код. Чтобы отключить вывод подсказки, достаточно передать в этот метод пустую строку; whatsThis() — возвращает текст справки. Создадим окно с кнопкой и зададим для них текст всплывающих подсказок и текст справки (листинг 18.11). Листинг 18.11. Всплывающие подсказки # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget(flags=QtCore.Qt.Dialog) window.setWindowTitle("Всплывающие подсказки") window.resize(300, 70) button = QtWidgets.QPushButton("Закрыть окно", window) button.setFixedSize(150, 30) button.move(75, 20) button.setToolTip("Это всплывающая подсказка для кнопки") button.setToolTipDuration(3000) window.setToolTip("Это всплывающая подсказка для окна") button.setToolTipDuration(5000) button.setWhatsThis("Это справка для кнопки") window.setWhatsThis("Это справка для окна") button.clicked.connect(QtWidgets.qApp.quit) window.show() sys.exit(app.exec_()) 390 Часть II. Библиотека PyQt 5 18.14. Программное закрытие окна В предыдущих разделах для закрытия окна мы использовали слот quit() и метод exit([returnCode=0]) объекта приложения. Однако эти методы не только закрывают теку- щее окно, но и завершают выполнение всего приложения. Чтобы закрыть только текущее окно, следует воспользоваться методом close() класса QWidget. Метод возвращает значение True, если окно успешно закрыто, и False — в противном случае. Закрыть сразу все окна приложения позволяет слот closeAllWindows() класса QApplicationЕсли для окна атрибут WA_DeleteOnClose из класса QtCore.Qt установлен в значение True, после закрытия окна объект окна будет автоматически удален, в противном случае окно просто скрывается. Значение атрибута можно изменить с помощью метода setAttribute(): window.setAttribute(QtCore.Qt.WA_DeleteOnClose, True) После вызова метода close() или нажатия кнопки Закрыть в заголовке окна генерируется событие QEvent.Close. Если внутри класса определить метод с предопределенным названи- ем closeEvent(), это событие можно перехватить и обработать. В качестве параметра метод принимает объект класса QCloseEvent, который поддерживает методы accept() (позволяет закрыть окно) и ignore() (запрещает закрытие окна). Вызывая эти методы, можно контро- лировать процесс закрытия окна. В качестве примера закроем окно по нажатию кнопки (листинг 18.12). Листинг 18.12. Программное закрытие окна # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget(flags=QtCore.Qt.Dialog) window.setWindowTitle("Закрытие окна из программы") window.resize(300, 70) button = QtWidgets.QPushButton("Закрыть окно", window) button.setFixedSize(150, 30) button.move(75, 20) button.clicked.connect(window.close) window.show() sys.exit(app.exec_()) ПРИМЕЧАНИЕЗакрыв последнее окно приложения, мы тем самым автоматически завершим и само при- ложение. Не забываем об этом. 18.15. Использование таблиц стилей CSS для оформления окон Вернемся к методу setStyleSheet(), упомянутому в разд. 18.10 и предназначенному для задания таблиц стилей у приложений и отдельных элементов управления. С помощью таб- лиц стилей можно задавать не только цвет фона и фоновое изображение, но и другие пара- метры оформления. Глава 18. Управление окном приложения 391 Метод setStyleSheet() поддерживается классами QWidget (и всеми его подклассами) и QApplication. Следовательно, его можно вызвать у: самого приложения — тогда заданные в таблице стилей параметры оформления будут применены ко всем элементам управления всех окон приложения; отдельного окна — тогда эти параметры будут действовать в пределах данного окна; отдельного элемента управления — тогда они будут действовать только на этот элемент управления. При указании таблицы стилей у приложения и окна можно использовать привычный нам по CSS формат объявления стилей: <Селектор> {<Определение стилей>} <Селектор> записывается в следующем формате: <Основной селектор>[<Дополнительный селектор>][<Псевдокласс>][<Псевдоселектор>] Параметр <Основной селектор> указывает на класс элемента управления. Его можно указать в одном из следующих форматов: * (звездочка) — указывает на все элементы управления (универсальный селектор). На- пример, так можно задать для всех элементов управления зеленый цвет текста: * {color: green;} <Класс> — указывает на элементы управления, относящиеся к заданному <Классу> и его подклассам. Задание красного цвета текста для всех элементов управления, относящихся к классу QAbstractButton и его подклассам, т. е. для командных кнопок, флажков и пе- реключателей, осуществляется так: QAbstractButton {color: red;} .<Класс> — указывает только на элементы управления, относящиеся к заданному <Классу>, но не к его подклассам. Указание полужирного шрифта для всех элементов управления, относящихся к классу QPushButton (командных кнопок), но не для его под- классов, осуществляется так: .QPushButton {font-weight: bold;} Параметр <Дополнительный селектор> задает дополнительные параметры элемента управле- ния. Его форматы: [<Свойство>="<Значение>"] — указанное <Свойство> элемента управления должно иметь заданное <Значение>. Так мы задаем полужирный шрифт для кнопки, чье свойство default имеет значение true, т. е. для кнопки по умолчанию: QPushButton[default="true"] {font-weight: bold;} #<Имя> — указывает на элемент управления, для которого было задано <Имя><Имя>можно задать вызовом у элемента управления метода setObjectName(<Имя>), а полу- чить — вызовом метода objectName(). Так выполняется указание красного цвета текста для кнопки с именем btnRed: QPushButton#btnRed {color: red;} Параметр <Псевдокласс> указывает на отдельную составную часть сложного элемента управления. Он записывается в формате ::<Обозначение составной части>. Вот пример ука- зания графического изображения для кнопки разворачивания раскрывающегося списка (обозначение этой составной части — down-arrow): QComboBox::down-arrow {image: url(arrow.png);} 392 Часть II. Библиотека PyQt 5 Параметр <Псевдоселектор> указывает на состояние элемента управления (должна ли быть кнопка нажата, должен ли флажок быть установленным и т. п.). Он может быть записан в двух форматах: :<Обозначение состояния> — элемент управления должен находиться в указанном со- стоянии. Вот пример указания белого цвета фона для кнопки, когда она нажата (это состояние имеет обозначение pressed): QPushButton:pressed {background-color: white;} :!<Обозначение состояния> — элемент управления должен находиться в любом состоя- нии, кроме указанного. Вот пример указания желтого цвета фона для кнопки, когда она не нажата: QPushButton:!pressed {background-color: yellow;} Можно указать сразу несколько псевдоселекторов, расположив их непосредственно друг за другом — тогда селектор будет указывать на элемент управления, находящийся одно- временно во всех состояниях, которые обозначены этими селекторами. Вот пример ука- зания черного цвета фона и белого цвета текста для кнопки, которая нажата и над кото- рой находится курсор мыши (обозначение — hover): QPushButton:pressed:hover {color: white; background-color: black;} Если нужно указать стиль для элемента управления, вложенного в другой элемент управле- ния, применяется следующий формат указания селектора: <Селектор "внешнего" элемента><Разделитель><Селектор вложенного элемента> Поддерживаются два варианта параметра <Разделитель>: пробел — <Вложенный элемент> не обязательно должен быть вложен непосредственно во <"Внешний">. Так мы указываем зеленый цвет фона для всех надписей (QLabel), вложен- ных в группу (QGroupBox) и вложенные в нее элементы: QGroupBox QLabel {background-color: green;} > — <Вложенный элемент> обязательно должен быть вложен непосредственно во <"Внеш- ний">. Так мы укажем синий цвет текста для всех надписей, непосредственно вложенных в группу: QGroupBox>QLabel {color: blue;} В стиле можно указать сразу несколько селекторов, записав их через запятую — тогда стиль будет применен к элементам управления, на которые указывают эти селекторы. Вот пример задания зеленого цвета фона для кнопок и надписей: QLabel, QPushButton {background-color: green;} В CSS элементы страницы наследуют параметры оформления от их родителей. Но в PyQt это не так. Скажем, если мы укажем для группы красный цвет текста: app.setStyleSheet("QGroupBox {color: red;}") вложенные в эту группу элементы не унаследуют его и будут иметь цвет текста, заданный по умолчанию. Нам придется задать для них нужный цвет явно: app.setStyleSheet("QGroupBox, QGroupBox * {color: red;}") Начиная с версии PyQt 5.7, поддерживается возможность указать библиотеке, что все элементы-потомки должны наследовать параметры оформления у родителя. Для этого дос- таточно вызвать у класса QCoreApplication статический метод setAttribute, передав ему Глава 18. Управление окном приложения 393 в качестве первого параметра значение атрибута AA_UseStyleSheetPropagationInWidgetStyles класса QtCore.Qt, а в качестве второго параметра — значение True: QtCore.QCoreApplication.setAttribute( QtCore.Qt.AA_UseStyleSheetPropagationInWidgetStyles, True) Чтобы отключить такую возможность, достаточно вызвать этот метод еще раз, указав в нем вторым параметром FalseИ, наконец, при вызове метода setStyleSheet() у элемента управления, для которого следу- ет задать таблицу стилей, в последней не указываются ни селектор, ни фигурные скобки — они просто не нужны. Отметим, что в случае PyQt, как и в CSS, также действуют правила каскадности. Так, таб- лица стилей, заданная для окна, имеет больший приоритет, нежели таковая, указанная для приложения, а стиль, что был задан для элемента управления, имеет наивысший приоритет. Помимо этого, более специфические стили имеют больший приоритет, чем менее специфи- ческие; так, стиль с селектором, в чей состав входит имя элемента управления, перекроет стиль с селектором любого другого типа. За более подробным описанием поддерживаемых PyQt псевдоклассов, псевдоселекторов и особенностей указания стилей для отдельных классов элементов управления обращайтесь по интернет-адресу https://doc.qt.io/qt-5/stylesheet-reference.html. Листинг 18.13 показывает пример задания таблиц стилей для элементов управления разны- ми способами. Результат выполнения приведенного в нем кода можно увидеть на рис. 18.2. Листинг 18.13. Использование таблиц стилей для указания оформления # -*- coding: utf-8 -*- from PyQt5 import QtWidgets import sys app = QtWidgets.QApplication(sys.argv) # На уровне приложения задаем синий цвет текста для надписей, вложенных в группы, # и курсивное начертание текста кнопок app.setStyleSheet("QGroupBox QLabel {color: blue;} QPushButton {font-style: italic}") window = QtWidgets.QWidget() window.setWindowTitle("Таблицы стилей") # На уровне окна задаем зеленый цвет текста для надписи с именем first и # красный цвет текста для надписи, на которую наведен курсор мыши window.setStyleSheet("QLabel#first {color: green;} QLabel:hover {color: red;}") window.resize(200, 150) # Создаем три надписи lbl1 = QtWidgets.QLabel("Зеленый текст") # Указываем для первой надписи имя first lbl1.setObjectName("first") lbl2 = QtWidgets.QLabel("Полужирный текст") # Для второй надписи указываем полужирный шрифт lbl2.setStyleSheet("font-weight: bold") lbl3 = QtWidgets.QLabel("Синий текст") # Создаем кнопку btn = QtWidgets.QPushButton("Курсивный текст") 394 Часть II. Библиотека PyQt 5 # Создаем группу box = QtWidgets.QGroupBox("Группа") # Создаем контейнер, помещаем в него третью надпись и вставляем в группу bbox = QtWidgets.QVBoxLayout() bbox.addWidget(lbl3) box.setLayout(bbox) # Создаем еще один контейнер, помещаем в него две первые надписи, группу и кнопку и # вставляем в окно mainbox = QtWidgets.QVBoxLayout() mainbox.addWidget(lbl1) mainbox.addWidget(lbl2) mainbox.addWidget(box) mainbox.addWidget(btn) window.setLayout(mainbox) # Выводим окно и запускаем приложение window.show() sys.exit(app.exec_()) Рис. 18.2. Пример использования таблиц стилей ГЛ А В А 19 Обработка сигналов и событий При взаимодействии пользователя с окном возникают события — своего рода извещения о том, что пользователь выполнил какое-либо действие или в самой системе возникло неко- торое условие. В ответ на события система генерирует определенные сигналы, которые можно рассматривать как представления системных событий внутри библиотеки PyQt. Сигналы являются важнейшей составляющей приложения с графическим интерфейсом, поэтому необходимо знать, как назначить обработчик сигнала, как удалить его, а также уметь правильно обработать событие. Сигналы, которые генерирует тот или иной компо- нент, мы будем рассматривать при изучении конкретного компонента. 19.1. Назначение обработчиков сигналов Чтобы обработать какой-либо сигнал, необходимо сопоставить ему функцию или метод класса, который будет вызван при возникновении события и станет его обработчиком. Каждый сигнал, поддерживаемый классом, соответствует одноименному атрибуту этого класса (отметим, что это именно атрибуты класса, а не атрибуты экземпляра). Так, сигнал clicked, генерируемый при щелчке мышью, соответствует атрибуту clicked. Каждый такой атрибут хранит экземпляр особого класса, представляющего соответствующий сигнал. Чтобы назначить сигналу обработчик, следует использовать метод connect(), унаследован- ный от класса QObject. Форматы вызова этого метода таковы: <Компонент>.<Сигнал>.connect(<Обработчик>[, <Тип соединения>]) <Компонент>.<Сигнал>[<Тип>].connect(<Обработчик>[, <Тип соединения>]) Здесь мы назначаем <Обработчик> для параметра <Сигнал>, генерируемого параметром <Компонент>. В качестве обработчика можно указать: ссылку на пользовательскую функцию; ссылку на метод класса; ссылку на экземпляр класса, в котором определен метод __call__(); анонимную функцию; ссылку на слот класса. Вот пример назначения функции on_clicked_button() в качестве обработчика сигнала clicked кнопки button: button.clicked.connect(on_clicked_button) 396 Часть II. Библиотека PyQt 5 Сигналы могут принимать произвольное число параметров, каждый из которых может от- носиться к любому типу данных. При этом бывает и так, что в классе существуют два сиг- нала с одинаковыми наименованиями, но разными наборами параметров. Тогда следует дополнительно в квадратных скобках указать <Тип> данных, принимаемых сигналом, — либо просто написав его наименование, либо задав его в виде строки. Например, оба сле- дующих выражения назначают обработчик сигнала, принимающего один параметр логиче- ского типа: button.clicked[bool].connect(on_clicked_button) button.clicked["bool"].connect(on_clicked_button) Одному и тому же сигналу можно назначить произвольное количество обработчиков. Это иллюстрирует код из листинга 19.1, где сигналу clicked кнопки назначены сразу четыре обработчика. Листинг 19.1. Назначение сигналу нескольких обработчиков # -*- coding: utf-8 -*- from PyQt5 import QtWidgets import sys def on_clicked(): print("Кнопка нажата. Функция on_clicked()") class MyClass(): def __init__(self, x=0): self.x = x def __call__(self): print("Кнопка нажата. Метод MyClass.__call__()") print("x =", self.x) def on_clicked(self): print("Кнопка нажата. Метод MyClass.on_clicked()") obj = MyClass() app = QtWidgets.QApplication(sys.argv) button = QtWidgets.QPushButton("Нажми меня") # Назначаем обработчиком функцию button.clicked.connect(on_clicked) # Назначаем обработчиком метод класса button.clicked.connect(obj.on_clicked) # Назначаем обработчиком ссылку на экземпляр класса button.clicked.connect(MyClass(10)) # Назначаем обработчиком анонимную функцию button.clicked.connect(lambda: MyClass(5)()) button.show() sys.exit(app.exec_()) В четвертом обработчике мы использовали анонимную функцию. В ней мы сначала создаем объект класса MyClass, передав ему в качестве параметра число 5, после чего сразу же вы- зываем его как функцию, указав после конструктора пустые скобки: button.clicked.connect(lambda: MyClass(5)()) Глава 19. Обработка сигналов и событий 397 Результат выполнения в окне консоли при щелчке на кнопке: Кнопка нажата. Функция on_clicked() Кнопка нажата. Метод MyClass.on_clicked() Кнопка нажата. Метод MyClass.__call__() x = 10 Кнопка нажата. Метод MyClass.__call__() x = 5 Классы PyQt 5 поддерживают ряд методов, специально предназначенных для использова- ния в качестве обработчиков сигналов. Такие методы называются слотами. Например, класс QApplication поддерживает слот quit(), завершающий текущее приложение. В лис- тинге 19.2 показан код, использующий этот слот. Листинг 19.2. Использование слота # -*- coding: utf-8 -*- from PyQt5 import QtWidgets import sys app = QtWidgets.QApplication(sys.argv) button = QtWidgets.QPushButton("Завершить работу") button.clicked.connect(app.quit) button.show() sys.exit(app.exec_()) Любой пользовательский метод можно сделать слотом, для чего необходимо перед его оп- ределением вставить декоратор @pyqtSlot(). Формат декоратора: @QtCore.pyqtSlot(*<Типы данных>, name=None, result=None) В параметре <Типы данных> через запятую указываются типы данных параметров, прини- маемых слотом, — например: bool или int. При задании типа данных C++ его название не- обходимо указать в виде строки. Если метод не принимает параметров, параметр <Типы дан- ных> не указывается. В именованном параметре name можно передать название слота в виде строки — это название станет использоваться вместо названия метода, а если параметр name не задан, название слота будет совпадать с названием метода. Именованный параметр result предназначен для указания типа данных, возвращаемых методом, — если параметр не задан, то метод ничего не возвращает. Чтобы создать перегруженную версию слота, декоратор указывается последовательно несколько раз с разными типами данных. Пример использования декоратора @pyqtSlot() приведен в листинге 19.3. Листинг 19.3. Использование декоратора @pyqtSlot() # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets import sys class MyClass(QtCore.QObject): def __init__(self): QtCore.QObject.__init__(self) 398 Часть II. Библиотека PyQt 5 @QtCore.pyqtSlot() def on_clicked(self): print("Кнопка нажата. Слот on_clicked()") @QtCore.pyqtSlot(bool, name="myslot") def on_clicked2(self, status): print("Кнопка нажата. Слот myslot(bool)", status) obj = MyClass() app = QtWidgets.QApplication(sys.argv) button = QtWidgets.QPushButton("Нажми меня") button.clicked.connect(obj.on_clicked) button.clicked.connect(obj.myslot) button.show() sys.exit(app.exec_()) PyQt не требует обязательного превращения в слот метода, который будет использоваться как обработчик сигнала. Однако это рекомендуется сделать, т. к. вызов слота в этом случае выполняется быстрее, чем вызов обычного метода. Необязательный параметр <Тип соединения> метода connect() определяет тип соединения между сигналом и обработчиком. На этот параметр следует обратить особое внимание при использовании в приложении нескольких потоков, т. к. изменять GUI-поток из другого потока нельзя. В параметре можно указать один из следующих атрибутов класса QtCore.Qt: AutoConnection — 0 — значение по умолчанию. Если источник сигнала и обработчик находятся в одном потоке, то оно эквивалентно значению DirectConnection, а если в разных потоках, то — QueuedConnection; DirectConnection — 1 — обработчик вызывается сразу после генерации сигнала и вы- полняется в потоке его источника; QueuedConnection — 2 — сигнал помещается в очередь обработки событий, а его обра- ботчик выполняется в потоке приемника сигнала; BlockingQueuedConnection — 4 — аналогично значению QueuedConnection за тем исклю- чением, что поток блокируется на время обработки сигнала. Обратите внимание, что ис- точник и обработчик сигнала обязательно должны быть расположены в разных потоках; UniqueConnection — 0x80 — указывает, что обработчик можно назначить только один раз. Этот атрибут с помощью оператора | может быть объединен с любым из представ- ленных ранее флагов: # Эти два обработчика будут успешно назначены и выполнены button.clicked.connect(on_clicked) button.clicked.connect(on_clicked) # А эти два обработчика назначены не будут button.clicked.connect(on_clicked, Qt.Core.Qt.AutoConnection | QtCore.Qt.UniqueConnection) button.clicked.connect(on_clicked, Qt.Core.Qt.AutoConnection | QtCore.Qt.UniqueConnection) # Тем не менее, эти два обработчика будут назначены, поскольку они разные button.clicked.connect(on_clicked, Qt.Core.Qt.AutoConnection | QtCore.Qt.UniqueConnection) button.clicked.connect(obj.on_clicked, Qt.Core.Qt.AutoConnection | QtCore.Qt.UniqueConnection) Глава 19. Обработка сигналов и событий 399 19.2. Блокировка и удаление обработчика Для блокировки и удаления обработчиков предназначены следующие методы класса QObject: blockSignals(<Флаг>) — временно блокирует прием сигналов, если параметр имеет зна- чение True, и снимает блокировку, если параметр имеет значение False. Метод возвра- щает логическое представление предыдущего состояния соединения; signalsBlocked() — возвращает значение True, если блокировка сигналов установлена, и False — в противном случае; disconnect() — удаляет обработчик. Форматы метода: <Компонент>.<Сигнал>.disconnect([<Обработчик>]) <Компонент>.<Сигнал>[<Тип>].disconnect([<Обработчик>]) Если параметр <Обработчик> не указан, удаляются все обработчики, назначенные ранее, в противном случае удаляется только указанный обработчик. Параметр <Тип> указывает- ся лишь в том случае, если существуют сигналы с одинаковыми именами, но прини- мающие разные параметры: button.clicked.disconnect() button.clicked[bool].disconnect(on_clicked_button) button.clicked["bool"].disconnect(on_clicked_button) Создадим окно с четырьмя кнопками (листинг 19.4). Для кнопки Нажми меня назначим обработчик сигнала clicked. Чтобы информировать о нажатии кнопки, выведем сообщение в окно консоли. Для кнопок Блокировать, Разблокировать и Удалить обработчик созда- дим обработчики, которые будут изменять статус обработчика для кнопки Нажми меня. Листинг 19.4. Блокировка и удаление обработчика # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets class MyWindow(QtWidgets.QWidget): def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) self.setWindowTitle("Блокировка и удаление обработчика") self.resize(300, 150) self.button1 = QtWidgets.QPushButton("Нажми меня") self.button2 = QtWidgets.QPushButton("Блокировать") self.button3 = QtWidgets.QPushButton("Разблокировать") self.button4 = QtWidgets.QPushButton("Удалить обработчик") self.button3.setEnabled(False) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(self.button1) vbox.addWidget(self.button2) vbox.addWidget(self.button3) vbox.addWidget(self.button4) self.setLayout(vbox) self.button1.clicked.connect(self.on_clicked_button1) 400 Часть II. Библиотека PyQt 5 self.button2.clicked.connect(self.on_clicked_button2) self.button3.clicked.connect(self.on_clicked_button3) self.button4.clicked.connect(self.on_clicked_button4) @QtCore.pyqtSlot() def on_clicked_button1(self): print("Нажата кнопка button1") @QtCore.pyqtSlot() def on_clicked_button2(self): self.button1.blockSignals(True) self.button2.setEnabled(False) self.button3.setEnabled(True) @QtCore.pyqtSlot() def on_clicked_button3(self): self.button1.blockSignals(False) self.button2.setEnabled(True) self.button3.setEnabled(False) @QtCore.pyqtSlot() def on_clicked_button4(self): self.button1.clicked.disconnect(self.on_clicked_button1) self.button2.setEnabled(False) self.button3.setEnabled(False) self.button4.setEnabled(False) if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) window = MyWindow() window.show() sys.exit(app.exec_()) Если нажать кнопку Нажми меня, в окно консоли будет выведена строка Нажата кнопка button1. Нажатие кнопки Блокировать производит блокировку обработчика — теперь при нажатии кнопки Нажми меня никаких сообщений в окно консоли не выводится. Отменить блокировку можно с помощью кнопки Разблокировать. Нажатие кнопки Удалить обра- ботчик производит полное удаление обработчика — в этом случае, чтобы обрабатывать нажатие кнопки Нажми меня, необходимо заново назначить обработчик. Также можно отключить генерацию сигнала, сделав компонент недоступным с помощью следующих методов из класса QWidget: setEnabled(<Флаг>) — если в параметре указано значение False, компонент станет не- доступным. Чтобы сделать компонент опять доступным, следует передать значение True; setDisabled(<Флаг>) — если в параметре указано значение True, компонент станет не- доступным. Чтобы сделать компонент опять доступным, следует передать значение FalseПроверить, доступен компонент или нет, позволяет метод isEnabled(). Он возвращает зна- чение True, если компонент доступен, и False — в противном случае. Глава 19. Обработка сигналов и событий 401 19.3. Генерация сигналов В некоторых случаях необходимо сгенерировать сигнал программно. Например, при запол- нении последнего текстового поля и нажатии клавиши можно имитировать нажатие кнопки ОK и тем самым выполнить подтверждение ввода пользователя. Осуществить гене- рацию сигнала из программы позволяет метод emit() класса QObject. Форматы этого ме- тода: <Компонент>.<Сигнал>.emit([<Данные>]) <Компонент>.<Сигнал>[<Тип>].emit([<Данные>]) Метод emit() всегда вызывается у объекта, которому посылается сигнал: button.clicked.emit() Сигналу и, соответственно, его обработчику можно передать данные, указав их в вызове метода emit(): button.clicked[bool].emit(False) button.clicked["bool"].emit(False) Также мы можем создавать свои собственные сигналы. Для этого следует определить в классе атрибут, чье имя совпадет с наименованием сигнала. Отметим, что это должен быть атрибут класса, а не экземпляра. Далее мы присвоим вновь созданному атрибуту результат, возвращенный функцией pyqtSignal() из модуля QtCore. Формат функции: <Объект сигнала> = pyqtSignal(*<Типы данных>[, name=<Имя сигнала>]) В параметре <Типы данных> через запятую указываются названия типов данных, передавае- мых сигналу, — например: bool или int: mysignal1 = QtCore.pyqtSignal(int) mysignal2 = QtCore.pyqtSignal(int, str) При использовании типа данных C++ его название необходимо указать в виде строки: mysignal3 = QtCore.pyqtSignal("QDate") Если сигнал не принимает параметров, параметр <Типы данных> не указывается. Сигнал может иметь несколько перегруженных версий, различающихся количеством и типом принимаемых параметров. В этом случае типы параметров указываются внутри квадратных скобок. Вот пример сигнала, передающего данные типа int или str: mysignal4 = QtCore.pyqtSignal([int], [str]) По умолчанию название создаваемого сигнала будет совпадать с названием атрибута клас- са. Однако мы можем указать для сигнала другое название, после чего он будет доступен под двумя названиями: совпадающим с именем атрибута класса и заданным нами. Для ука- зания названия сигнала применяется параметр name: mysignal = QtCore.pyqtSignal(int, name="mySignal") В качестве примера создадим окно с двумя кнопками (листинг 19.5), которым назначим обработчики сигнала clicked (нажатие кнопки). Внутри обработчика щелчка на первой кнопке сгенерируем два сигнала: первый будет имитировать нажатие второй кнопки, а вто- рой станет пользовательским, привязанным к окну. Внутри обработчиков выведем сообще- ния в окно консоли. 402 Часть II. Библиотека PyQt 5 Листинг 19.5. Генерация сигнала из программы # -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets class MyWindow(QtWidgets.QWidget): mysignal = QtCore.pyqtSignal(int, int) def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) self.setWindowTitle("Генерация сигнала из программы") self.resize(300, 100) self.button1 = QtWidgets.QPushButton("Нажми меня") self.button2 = QtWidgets.QPushButton("Кнопка 2") vbox = QtWidgets.QVBoxLayout() vbox.addWidget(self.button1) vbox.addWidget(self.button2) self.setLayout(vbox) self.button1.clicked.connect(self.on_clicked_button1) self.button2.clicked.connect(self.on_clicked_button2) self.mysignal.connect(self.on_mysignal) def on_clicked_button1(self): print("Нажата кнопка button1") # Генерируем сигналы self.button2.clicked[bool].emit(False) self.mysignal.emit(10, 20) def on_clicked_button2(self): print("Нажата кнопка button2") def on_mysignal(self, x, y): print("Обработан пользовательский сигнал mysignal()") print("x =", x, "y =", y) if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) window = MyWindow() window.show() sys.exit(app.exec_()) Результат выполнения после нажатия первой кнопки: Нажата кнопка button1 Нажата кнопка button2 Обработан пользовательский сигнал mysignal() x = 10 y = 20 Вместо конкретного типа принимаемого сигналом параметра можно указать тип QVariant из модуля QtCore. В этом случае при генерации сигнала допускается передавать ему данные любого типа. Вот пример создания и генерирования сигнала, принимающего параметр любого типа: mysignal = QtCore.pyqtSignal(QtCore.QVariant) self.mysignal.emit(20) Глава 19. Обработка сигналов и событий 403 self.mysignal.emit("Привет!") self.mysignal.emit([1, "2"]) Сгенерировать сигнал можно не только с помощью метода emit(). Некоторые компоненты предоставляют методы, которые посылают сигнал. Например, у кнопок существует метод click(). Используя этот метод, инструкцию: button.clicked.emit() можно записать следующим образом: button.click() Более подробно такие методы мы будем рассматривать при изучении конкретных компо- нентов. 19.4. Передача данных в обработчик При назначении обработчика в метод connect() передается ссылка на функцию или метод. Если после названия функции (метода) указать внутри круглых скобок какой-либо пара- метр, то это приведет к вызову функции (метода) и вместо ссылки будет передан результат ее выполнения, что вызовет ошибку. Передать данные в обработчик можно следующими способами: создать анонимную функцию и внутри ее выполнить вызов обработчика с параметрами. Вот пример передачи обработчику числа 10: self.button1.clicked.connect(lambda : self.on_clicked_button1(10)) Если передаваемое обработчику значение вычисляется в процессе выполнения кода, переменную, хранящую это значение, следует указывать в анонимной функции как зна- чение по умолчанию, иначе функции будет передана ссылка на это значение, а не оно само: y = 10 self.button1.clicked.connect(lambda x=y: self.on_clicked_button1(x)) передать ссылку на экземпляр класса, внутри которого определен метод __call__()Передаваемое значение указывается в качестве параметра конструктора этого класса: class MyClass(): def __init__(self, x=0): self.x = x def __call__(self): print("x =", self.x) self.button1.clicked.connect(MyClass(10)) передать ссылку на обработчик и данные в функцию partial() из модуля functoolsФормат функции: partial(<Функция>[, *<Неименованные параметры>][, **<Именованные параметры>]) Пример передачи параметра в обработчик: from functools import partial self.button1.clicked.connect(partial(self.on_clicked_button1, 10)) 404 Часть II. Библиотека PyQt 5 Если при генерации сигнала передается предопределенное значение, то оно будет дос- тупно в обработчике после остальных параметров. Назначим обработчик сигнала clicked, принимающего логический параметр, и дополнительно передадим число: self.button1.clicked.connect(partial(self.on_clicked_button1, 10)) Обработчик будет иметь следующий вид: def on_clicked_button1(self, x, status): print("Нажата кнопка button1", x, status) Результат выполнения: Нажата кнопка button1 10 False 19.5. Использование таймеров Таймеры позволяют через заданный интервал времени выполнять метод с предопределен- ным названием timerEvent(). Для назначения таймера используется метод startTimer()класса QObject. Формат метода: 1   ...   33   34   35   36   37   38   39   40   ...   83

Заголовок


Глава 6. Строки и двоичные данные
93
• e
— вещественное число в экспоненциальной форме (буква e
в нижнем регистре):
>>> print("%e %e" % (3000, 18657.81452))
3.000000e+03 1.865781e+04
•
E
— вещественное число в экспоненциальной форме (буква
E
в верхнем регистре):
>>> print("%E %E" % (3000, 18657.81452))
3.000000E+03 1.865781E+04
• g
— эквивалентно f
или e
(выбирается более короткая запись числа):
>>> print("%g %g %g" % (0.086578, 0.000086578, 1.865E-005))
0.086578 8.6578e-05 1.865e-05
•
G
— эквивалентно f
или
E
(выбирается более короткая запись числа):
>>> print("%G %G %G" % (0.086578, 0.000086578, 1.865E-005))
0.086578 8.6578E-05 1.865E-05
Если внутри строки необходимо использовать символ процента, этот символ следует удво- ить, иначе будет выведено сообщение об ошибке:
>>> print("% %s" % ("- это символ процента")) # Ошибка
Traceback (most recent call last):
File "
", line 1, in print("% %s" % ("- это символ процента")) # Ошибка
TypeError: not all arguments converted during string formatting
>>> print("%% %s" % ("- это символ процента")) # Нормально
% — это символ процента
Форматирование строк очень удобно использовать при передаче данных в шаблон веб- страницы. Для этого заполняем словарь данными и указываем его справа от символа
%
, а сам шаблон — слева. Продемонстрируем это на примере (листинг 6.1).
Листинг 6.1. Пример использования форматирования строк
# -*- coding: utf-8 -*- html = """

1   ...   6   7   8   9   10   11   12   13   ...   83

%(h1)s


%(content)s


94
Часть I. Основы языка Python

Это заголовок первого уровня


Это основное содержание страницы


Глава 6. Строки и двоичные данные
95
>>> s = "str"
>>> "'%15s' '%-15s' '%s'" % (s, s, s.center(15))
"' str' 'str ' ' str '"
Если количество символов в строке превышает ширину поля, то значение ширины игно- рируется, и строка возвращается полностью:
>>> s = "string"
>>> s.center(6), s.center(5)
('string', 'string')
ljust(<Ширина>[, <Символ>])
— производит выравнивание строки по левому краю внутри поля указанной ширины. Если второй параметр не указан, справа от исходной строки будут добавлены пробелы. Если количество символов в строке превышает шири- ну поля, значение ширины игнорируется, и строка возвращается полностью:
>>> s = "string"
>>> s.ljust(15), s.ljust(15, "-")
('string ', 'string---------')
>>> s.ljust(6), s.ljust(5)
('string', 'string')
rjust(<Ширина>[, <Символ>])
— производит выравнивание строки по правому краю внутри поля указанной ширины. Если второй параметр не указан, слева от исходной строки будут добавлены пробелы. Если количество символов в строке превышает шири- ну поля, значение ширины игнорируется, и строка возвращается полностью:
>>> s = "string"
>>> s.rjust(15), s.rjust(15, "-")
(' string', '---------string')
>>> s.rjust(6), s.rjust(5)
('string', 'string')
zfill(<Ширина>)
— производит выравнивание фрагмента по правому краю внутри поля указанной ширины. Слева от фрагмента будут добавлены нули. Если количество симво- лов в строке превышает ширину поля, значение ширины игнорируется, и строка возвра- щается полностью:
>>> "5".zfill(20), "123456".zfill(5)
('00000000000000000005', '123456')
6.5. Метод format()
Помимо операции форматирования, мы можем использовать для этой же цели метод format()
. Он имеет следующий синтаксис:
<Строка> = <Строка специального формата>.format(*args, **kwargs)
В параметре
<Строка специального формата>
внутри символов фигурных скобок
{
и
}
ука- зываются спецификаторы, имеющие следующий синтаксис:
{[<Поле>][!<Функция>][:<Формат>]}
Все символы, расположенные вне фигурных скобок, выводятся без преобразований. Если внутри строки необходимо использовать символы
{
и
}
, то эти символы следует удвоить, иначе возбуждается исключение
ValueError
:

96
Часть I. Основы языка Python
>>> print("Символы {{ и }} — {0}".format("специальные"))
Символы { и } — специальные

В качестве параметра
<Поле>
можно указать порядковый номер (нумерация начинается с нуля) или ключ параметра, указанного в методе format()
. Допустимо комбинировать по- зиционные и именованные параметры, при этом именованные параметры следует ука- зать последними:
>>> "{0} - {1} - {2}".format(10, 12.3, "string") # Индексы '10 - 12.3 - string'
>>> arr = [10, 12.3, "string"]
>>> "{0} - {1} - {2}".format(*arr) # Индексы '10 - 12.3 - string'
>>> "{model} - {color}".format(color="red", model="BMW") # Ключи 'BMW - red'
>>> d = {"color": "red", "model": "BMW"}
>>> "{model} - {color}".format(**d) # Ключи 'BMW - red'
>>> "{color} - {0}".format(2015, color="red") # Комбинация 'red - 2015'
В вызове метода format()
можно указать список, словарь или объект. Для доступа к элементам списка по индексу внутри строки формата применяются квадратные скобки, а для доступа к элементам словаря или атрибутам объекта используется точечная нотация:
>>> arr = [10, [12.3, "string"] ]
>>> "{0[0]} - {0[1][0]} - {0[1][1]}".format(arr) # Индексы '10 - 12.3 - string'
>>> "{arr[0]} - {arr[1][1]}".format(arr=arr) # Индексы '10 - string'
>>> class Car: color, model = "red", "BMW"
>>> car = Car()
>>> "{0.model} - {0.color}".format(car) # Атрибуты 'BMW - red'
Существует также краткая форма записи, при которой
<Поле>
не указывается. В этом случае скобки без указанного индекса нумеруются слева направо, начиная с нуля:
>>> "{} - {} - {} - {n}".format(1, 2, 3, n=4) # "{0} - {1} - {2} - {n}"
'1 - 2 - 3 - 4'
>>> "{} - {} - {n} - {}".format(1, 2, 3, n=4) # "{0} - {1} - {n} - {2}"
'1 - 2 - 4 - 3'

Параметр
<Функция>
задает функцию, с помощью которой обрабатываются данные перед вставкой в строку. Если указано значение s
, то данные обрабатываются функцией str()
, если значение r
, то функцией repr()
, а если значение a
, то функцией ascii()
. Если параметр не указан, для преобразования данных в строку используется функция str()
:
>>> print("{0!s}".format("строка")) # str() строка
>>> print("{0!r}".format("строка")) # repr()
'строка'
>>> print("{0!a}".format("строка")) # ascii()
'\u0441\u0442\u0440\u043e\u043a\u0430'

Глава 6. Строки и двоичные данные
97

В параметре
<Формат>
указывается значение, имеющее следующий синтаксис:
[[<Заполнитель>]<Выравнивание>][<Знак>][#][0][<Ширина>][,]
[.<Точность>][<Преобразование>]
•
Параметр
<Ширина>
задает минимальную ширину поля. Если строка не помещается в указанную ширину, то значение игнорируется, и строка выводится полностью:
>>> "'{0:10}' '{1:3}'".format(3, "string")
"' 3' 'string'"
Ширину поля можно передать в качестве параметра в методе format()
. В этом случае вместо числа указывается индекс параметра внутри фигурных скобок:
>>> "'{0:{1}}'".format(3, 10) # 10 — это ширина поля "' 3'"
•
Параметр
<Выравнивание>
управляет выравниванием значения внутри поля. Поддер- живаются следующие значения:

<
— по левому краю;

>
— по правому краю (поведение по умолчанию);

^
— по центру поля. Пример:
>>> "'{0:<10}' '{1:>10}' '{2:^10}'".format(3, 3, 3)
"'3 ' ' 3' ' 3 '"
=
— знак числа выравнивается по левому краю, а число по правому краю:
>>> "'{0:=10}' '{1:=10}'".format(-3, 3)
"'- 3' ' 3'"
Как видно из приведенного примера, пространство между знаком и числом по умолчанию заполняется пробелами, а знак положительного числа не указывается.
Чтобы вместо пробелов пространство заполнялось нулями, необходимо указать нуль перед шириной поля:
>>> "'{0:=010}' '{1:=010}'".format(-3, 3)
"'-000000003' '0000000003'"
•
Параметр
<Заполнитель>
задает символ, которым будет заполняться свободное про- странство в поле (по умолчанию — пробел). Такого же эффекта можно достичь, ука- зав нуль в параметре
<Заполнитель>
:
>>> "'{0:0=10}' '{1:0=10}'".format(-3, 3)
"'-000000003' '0000000003'"
>>> "'{0:*<10}' '{1:+>10}' '{2:.^10}'".format(3, 3, 3)
"'3*********' '+++++++++3' '....3.....'"
•
Параметр
<Знак>
управляет выводом знака числа. Допустимые значения:
+ — задает обязательный вывод знака как для отрицательных, так и для положи- тельных чисел;

-
— вывод знака только для отрицательных чисел (значение по умолчанию);
пробел
— вставляет пробел перед положительным числом. Перед отрицательным числом будет стоять минус. Пример:

98
Часть I. Основы языка Python
>>> "'{0:+}' '{1:+}' '{0:-}' '{1:-}'".format(3, -3)
"'+3' '-3' '3' '-3'"
>>> "'{0: }' '{1: }'".format(3, -3) # Пробел "' 3' '-3'"
•
Для целых чисел в параметре
<Преобразование>
могут быть указаны следующие опции:
b
— преобразование в двоичную систему счисления:
>>> "'{0:b}' '{0:#b}'".format(3)
"'11' '0b11'"
c
— преобразование числа в соответствующий символ:
>>> "'{0:c}'".format(100)
"'d'"
d
— преобразование в десятичную систему счисления;
n
— аналогично опции d
, но учитывает настройки локали. Например, выведем большое число с разделением тысячных разрядов пробелом:
>>> import locale
>>> locale.setlocale(locale.LC_NUMERIC, 'Russian_Russia.1251')
'Russian_Russia.1251'
>>> print("{0:n}".format(100000000).replace("\uffa0", " "))
100 000 000
В Python 3 между разрядами вставляется символ с кодом
\uffa0
, который отобра- жается квадратиком. Чтобы вывести символ пробела, мы производим замену в строке с помощью метода replace()
. В Python версии 2 поведение было другим.
Там вставлялся символ с кодом
\xa0
и не нужно было производить замену. Чтобы в Python 3 вставлялся символ с кодом
\xa0
, следует воспользоваться функцией format()
из модуля locale
:
>>> import locale
>>> locale.setlocale(locale.LC_NUMERIC, "Russian_Russia.1251")
'Russian_Russia.1251'
>>> print(locale.format("%d", 100000000, grouping = True))
100 000 000
>>> locale.localeconv()["thousands_sep"]
'\xa0'
Можно также разделить тысячные разряды запятой, указав ее в строке формата:
>>> print("{0:,d}".format(100000000))
100,000,000
o
— преобразование в восьмеричную систему счисления:
>>> "'{0:d}' '{0:o}' '{0:#o}'".format(511)
"'511' '777' '0o777'"
x
— преобразование в шестнадцатеричную систему счисления в нижнем регистре:
>>> "'{0:x}' '{0:#x}'".format(255)
"'ff' '0xff'"

Глава 6. Строки и двоичные данные
99

X
— преобразование в шестнадцатеричную систему счисления в верхнем регистре:
>>> "'{0:X}' '{0:#X}'".format(255)
"'FF' '0XFF'"
•
Для вещественных чисел в параметре
<Преобразование>
могут быть указаны следую- щие опции:
f
и
F
— преобразование в десятичную систему счисления:
>>> "'{0:f}' '{1:f}' '{2:f}'".format(30, 18.6578145, -2.5)
"'30.000000' '18.657815' '-2.500000'"
По умолчанию выводимое число имеет шесть знаков после запятой. Задать другое количество знаков после запятой мы можем в параметре
<Точность>
:
>>> "'{0:.7f}' '{1:.2f}'".format(18.6578145, -2.5)
"'18.6578145' '-2.50'"
e
— вывод в экспоненциальной форме (буква e
в нижнем регистре):
>>> "'{0:e}' '{1:e}'".format(3000, 18657.81452)
"'3.000000e+03' '1.865781e+04'"

E
— вывод в экспоненциальной форме (буква
E
в верхнем регистре):
>>> "'{0:E}' '{1:E}'".format(3000, 18657.81452)
"'3.000000E+03' '1.865781E+04'"
Здесь по умолчанию количество знаков после запятой также равно шести, но мы можем указать другую величину этого параметра:
>>> "'{0:.2e}' '{1:.2E}'".format(3000, 18657.81452)
"'3.00e+03' '1.87E+04'"
g
— эквивалентно f
или e
(выбирается более короткая запись числа):
>>> "'{0:g}' '{1:g}'".format(0.086578, 0.000086578)
"'0.086578' '8.6578e-05'"
n
— аналогично опции g
, но учитывает настройки локали;

G
— эквивалентно f
или
E
(выбирается более короткая запись числа):
>>> "'{0:G}' '{1:G}'".format(0.086578, 0.000086578)
"'0.086578' '8.6578E-05'"

%
— умножает число на 100 и добавляет символ процента в конец. Значение ото- бражается в соответствии с опцией f
:
>>> "'{0:%}' '{1:.4%}'".format(0.086578, 0.000086578)
"'8.657800%' '0.0087%'"
6.5.1. Форматируемые строки
В Python 3.6 появилась весьма удобная альтернатива методу format()
— форматируемые строки.
Форматируемая строка обязательно должна предваряться буквой f
или
F
. В нужных местах такой строки записываются команды на вставку в эти места значений, хранящихся в пере-

100
Часть I. Основы языка Python менных, — точно так же, как и в строках специального формата, описанных ранее. Такие команды имеют следующий синтаксис:
{[<Переменная>][!<Функция>][:<Формат>]}
Параметр
<Переменная>
задает имя переменной, из которой будет извлечено вставляемое в строку значение. Вместо имени переменной можно записать выражение, вычисляющее значение, которое нужно вывести. Параметры
<Функция>
и
<Формат>
имеют то же назначе- ние и записываются так же, как и в случае метода format()
:
>>> a = 10; b = 12.3; s = "string"
>>> f"{a} - {b} - {s}" # Простой вывод чисел и строк '10 - 12.3 - string'
>>> f"{a} - {b:5.2f} - {s}" # Вывод с форматированием '10 - 12.30 - string'
>>> d = 3
>>> f"{a} - {b:5.{d}f} - {s}" # В командах можно использовать
# значения из переменных '10 - 12.300 - string'
>>> arr = [3, 4]
>>> f"{arr[0]} - {arr[1]}" # Вывод элементов массива '3 - 4'
>>> f"{arr[0]} - {arr[1] * 2}" # Использование выражений '3 - 8'
6.6. Функции и методы для работы со строками
Рассмотрим основные функции для работы со строками:
str([<Объект>])
— преобразует любой объект в строку. Если параметр не указан, воз- вращается пустая строка. Используется функцией print()
для вывода объектов:
>>> str(), str([1, 2]), str((3, 4)), str({"x": 1})
('', '[1, 2]', '(3, 4)', "{'x': 1}")
>>> print("строка1\nстрока2") строка1 строка2
repr(<Объект>)
— возвращает строковое представление объекта. Используется при вы- воде объектов в окне Python Shell редактора IDLE:
>>> repr("Строка"), repr([1, 2, 3]), repr({"x": 5})
("'Строка'", '[1, 2, 3]', "{'x': 5}")
>>> repr("строка1\nстрока2")
"'строка1\\nстрока2'"
ascii(<Объект>)
— возвращает строковое представление объекта. В строке могут быть символы только из кодировки ASCII:
>>> ascii([1, 2, 3]), ascii({"x": 5})
('[1, 2, 3]', "{'x': 5}")
>>> ascii("строка")
"'\\u0441\\u0442\\u0440\\u043e\\u043a\\u0430'"

Глава 6. Строки и двоичные данные
101
len(<Строка>)
— возвращает длину строки — количество символов в ней:
>>> len("Python"), len("\r\n\t"), len(r"\r\n\t")
(6, 3, 6)
>>> len("строка")
6
Приведем перечень основных методов для работы со строками:
strip([<Символы>])
— удаляет указанные в параметре символы в начале и в конце стро- ки. Если параметр не задан, удаляются пробельные символы: пробел, символ перевода строки (
\n
), символ возврата каретки (
\r
), символы горизонтальной (
\t
) и вертикальной
(
\v
) табуляции:
>>> s1, s2 = " str\n\r\v\t", "strstrstrokstrstrstr"
>>> "'%s' — '%s'" % (s1.strip(), s2.strip("tsr"))
"'str' — 'ok'"
lstrip([<Символы>])
— удаляет пробельные или указанные символы в начале строки:
>>> s1, s2 = " str ", "strstrstrokstrstrstr"
>>> "'%s' — '%s'" % (s1.lstrip(), s2.lstrip("tsr"))
"'str ' — 'okstrstrstr'"
rstrip([<Символы>])
— удаляет пробельные или указанные символы в конце строки:
>>> s1, s2 = " str ", "strstrstrokstrstrstr"
>>> "'%s' — '%s'" % (s1.rstrip(), s2.rstrip("tsr"))
"' str' — 'strstrstrok'"
split([<Разделитель>[, <Лимит>]])
— разделяет строку на подстроки по указанному разделителю и добавляет эти подстроки в список, который возвращается в качестве ре- зультата. Если первый параметр не указан или имеет значение
None
, то в качестве разде- лителя используется символ пробела. Во втором параметре можно задать количество подстрок в результирующем списке — если он не указан или равен
-1
, в список попадут все подстроки. Если подстрок больше указанного количества, то список будет содержать еще один элемент — с остатком строки:
>>> s = "word1 word2 word3"
>>> s.split(), s.split(None, 1)
(['word1', 'word2', 'word3'], ['word1', 'word2 word3'])
>>> s = "word1\nword2\nword3"
>>> s.split("\n")
['word1', 'word2', 'word3']
Если в строке содержатся несколько пробелов подряд и разделитель не указан, то пустые элементы не будут добавлены в список:
>>> s = "word1 word2 word3 "
>>> s.split()
['word1', 'word2', 'word3']
При использовании другого разделителя могут возникнуть пустые элементы:
>>> s = ",,word1,,word2,,word3,,"
>>> s.split(",")
['', '', 'word1', '', 'word2', '', 'word3', '', '']
>>> "1,,2,,3".split(",")
['1', '', '2', '', '3']

102
Часть I. Основы языка Python
Если разделитель не найден в строке, то список будет состоять из одного элемента, представляющего исходную строку:
>>> "word1 word2 word3".split("\n")
['word1 word2 word3']
rsplit([<Разделитель>[, <Лимит>]])
— аналогичен методу split()
, но поиск символа- разделителя производится не слева направо, а наоборот — справа налево:
>>> s = "word1 word2 word3"
>>> s.rsplit(), s.rsplit(None, 1)
(['word1', 'word2', 'word3'], ['word1 word2', 'word3'])
>>> "word1\nword2\nword3".rsplit("\n")
['word1', 'word2', 'word3']
splitlines([False])
— разделяет строку на подстроки по символу перевода строки (
\n
) и добавляет их в список. Символы новой строки включаются в результат, только если необязательный параметр имеет значение
True
. Если разделитель не найден в строке, список будет содержать только один элемент:
>>> "word1\nword2\nword3".splitlines()
['word1', 'word2', 'word3']
>>> "word1\nword2\nword3".splitlines(True)
['word1\n', 'word2\n', 'word3']
>>> "word1\nword2\nword3".splitlines(False)
['word1', 'word2', 'word3']
>>> "word1 word2 word3".splitlines()
['word1 word2 word3']
partition(<Разделитель>)
— находит первое вхождение символа-разделителя в строку и возвращает кортеж из трех элементов: первый элемент будет содержать фрагмент, рас- положенный перед разделителем, второй элемент — сам разделитель, а третий эле- мент — фрагмент, расположенный после разделителя. Поиск производится слева напра- во. Если символ-разделитель не найден, то первый элемент кортежа будет содержать всю строку, а остальные элементы останутся пустыми:
>>> "word1 word2 word3".partition(" ")
('word1', ' ', 'word2 word3')
>>> "word1 word2 word3".partition("\n")
('word1 word2 word3', '', '')
rpartition(<Разделитель>)
— метод аналогичен методу partition()
, но поиск символа- разделителя производится не слева направо, а наоборот — справа налево. Если символ- разделитель не найден, то первые два элемента кортежа окажутся пустыми, а третий элемент будет содержать всю строку:
>>> "word1 word2 word3".rpartition(" ")
('word1 word2', ' ', 'word3')
>>> "word1 word2 word3".rpartition("\n")
('', '', 'word1 word2 word3')
join()
— преобразует последовательность в строку. Элементы добавляются через ука- занный разделитель. Формат метода:
<Строка> = <Разделитель>.join(<Последовательность>)

Глава 6. Строки и двоичные данные
103
В качестве примера преобразуем список и кортеж в строку:
>>> " => ".join(["word1", "word2", "word3"])
'word1 => word2 => word3'
>>> " ".join(("word1", "word2", "word3"))
'word1 word2 word3'
Обратите внимание на то, что элементы последовательностей должны быть строками, иначе возбуждается исключение
TypeError
:
>>> " ".join(("word1", "word2", 5))
Traceback (most recent call last):
File "
", line 1, in
" ".join(("word1", "word2", 5))
TypeError: sequence item 2: expected str instance, int found
Как вы уже знаете, строки относятся к неизменяемым типам данных. Если попытаться из- менить символ по индексу, возникнет ошибка. Чтобы изменить символ по индексу, можно преобразовать строку в список с помощью функции list()
, произвести изменения, а затем с помощью метода join()
преобразовать список обратно в строку:
>>> s = "Python"
>>> arr = list(s); arr # Преобразуем строку в список
['P', 'y', 't', 'h', 'o', 'n']
>>> arr[0] = "J"; arr # Изменяем элемент по индексу
['J', 'y', 't', 'h', 'o', 'n']
>>> s = "".join(arr); s # Преобразуем список в строку 'Jython'
В Python 3 также можно преобразовать строку в тип bytearray
, а затем изменить символ по индексу:
>>> s = "Python"
>>> b = bytearray(s, "cp1251"); b bytearray(b'Python')
>>> b[0] = ord("J"); b bytearray(b'Jython')
>>> s = b.decode("cp1251"); s
'Jython'
6.7. Настройка локали
Для установки локали (совокупности локальных настроек системы) служит функция setlocale()
из модуля locale
. Прежде чем использовать функцию, необходимо подклю- чить модуль с помощью выражения: import locale
Функция setlocale()
имеет следующий формат: setlocale(<Категория>[, <Локаль>]);
Параметр
<Категория>
может принимать следующие значения:
locale.LC_ALL
— устанавливает локаль для всех режимов;
locale.LC_COLLATE
— для сравнения строк;

104
Часть I. Основы языка Python
locale.LC_CTYPE
— для перевода символов в нижний или верхний регистр;
locale.LC_MONETARY
— для отображения денежных единиц;
locale.LC_NUMERIC
— для форматирования чисел;
locale.LC_TIME
— для форматирования вывода даты и времени.
Получить текущее значение локали позволяет функция getlocale([<Категория>])
. В ка- честве примера настроим локаль под Windows вначале на кодировку Windows-1251, потом на кодировку UTF-8, а затем на кодировку по умолчанию. Далее выведем текущее значение локали для всех категорий и только для locale.LC_COLLATE
:
>>> import locale
>>> # Для кодировки windows-1251
>>> locale.setlocale(locale.LC_ALL, "Russian_Russia.1251")
'Russian_Russia.1251'
>>> # Устанавливаем локаль по умолчанию
>>> locale.setlocale(locale.LC_ALL, "")
'Russian_Russia.1251'
>>> # Получаем текущее значение локали для всех категорий
>>> locale.getlocale()
('Russian_Russia', '1251')
>>> # Получаем текущее значение категории locale.LC_COLLATE
>>> locale.getlocale(locale.LC_COLLATE)
('Russian_Russia', '1251')
Получить настройки локали позволяет функция localeconv()
. Функция возвращает словарь с настройками. Результат выполнения функции для локали
Russian_Russia.1251
выглядит следующим образом:
>>> locale.localeconv()
{'decimal_point': ',', 'thousands_sep': '\xa0', 'grouping': [3, 0],
'int_curr_symbol': 'RUB', 'currency_symbol': '?', 'mon_decimal_point': ',',
'mon_thousands_sep': '\xa0', 'mon_grouping': [3, 0], 'positive_sign': '',
'negative_sign': '-', 'int_frac_digits': 2, 'frac_digits': 2, 'p_cs_precedes': 0,
'p_sep_by_space': 1, 'n_cs_precedes': 0, 'n_sep_by_space': 1, 'p_sign_posn': 1,
'n_sign_posn': 1}
6.8. Изменение регистра символов
Для изменения регистра символов предназначены следующие методы:
upper()
— заменяет все символы строки соответствующими прописными буквами:
>>> print("строка".upper())
СТРОКА
lower()
— заменяет все символы строки соответствующими строчными буквами:
>>> print("СТРОКА".lower()) строка
swapcase()
— заменяет все строчные символы соответствующими прописными буквами, а все прописные символы — строчными:

Глава 6. Строки и двоичные данные
105
>>> print("СТРОКА строка".swapcase()) строка СТРОКА
capitalize()
— делает первую букву строки прописной:
>>> print("строка строка".capitalize())
Строка строка
title()
— делает первую букву каждого слова прописной:
>>> s = "первая буква каждого слова станет прописной"
>>> print(s.title())
Первая Буква Каждого Слова Станет Прописной
casefold()
— то же самое, что и lower()
, но дополнительно преобразует все символы с диакритическими знаками и лигатуры в буквы стандартной латиницы. Обычно приме- няется для сравнения строк:
>>> "Python".casefold() == "python".casefold()
True
>>> "grosse".casefold() == "große".casefold()
True
6.9. Функции для работы с символами
Для работы с отдельными символами предназначены следующие функции:
chr(<Код символа>)
— возвращает символ по указанному коду:
>>> print(chr(1055))
П
ord(<Символ>)
— возвращает код указанного символа:
>>> print(ord("П"))
1055 6.10. Поиск и замена в строке
Для поиска и замены в строке используются следующие методы:
find()
— ищет подстроку в строке. Возвращает номер позиции, с которой начинается вхождение подстроки в строку. Если подстрока в строку не входит, то возвращается зна- чение
-1
. Метод зависит от регистра символов. Формат метода:
<Строка>.find(<Подстрока>[, <Начало>[, <Конец>]])
Если начальная позиция не указана, то поиск будет осуществляться с начала строки.
Если параметры
<Начало>
и
<Конец>
указаны, то производится операция извлечения среза:
<Строка>[<Начало>:<Конец>] и поиск подстроки будет выполняться в этом фрагменте:
>>> s = "пример пример Пример"
>>> s.find("при"), s.find("При"), s.find("тест")
(0, 14, -1)
>>> s.find("при", 9), s.find("при", 0, 6), s.find("при", 7, 12)
(-1, 0, 7)

106
Часть I. Основы языка Python
index()
— метод аналогичен методу find()
, но если подстрока в строку не входит, воз- буждается исключение
ValueError
. Формат метода:
<Строка>.index(<Подстрока>[, <Начало>[, <Конец>]])
Пример:
>>> s = "пример пример Пример"
>>> s.index("при"), s.index("при", 7, 12), s.index("При", 1)
(0, 7, 14)
>>> s.index("тест")
Traceback (most recent call last):
File "
", line 1, in s.index("тест")
ValueError: substring not found
rfind()
— ищет подстроку в строке. Возвращает позицию последнего вхождения под- строки в строку. Если подстрока в строку не входит, возвращается значение
-1
. Метод зависит от регистра символов. Формат метода:
<Строка>.rfind(<Подстрока>[, <Начало>[, <Конец>]])
Если начальная позиция не указана, то поиск будет производиться с начала строки. Если параметры
<Начало>
и
<Конец>
указаны, то выполняется операция извлечения среза, и поиск подстроки будет производиться в этом фрагменте:
>>> s = "пример пример Пример Пример"
>>> s.rfind("при"), s.rfind("При"), s.rfind("тест")
(7, 21, -1)
>>> s.find("при", 0, 6), s.find("При", 10, 20)
(0, 14)
rindex()
— метод аналогичен методу rfind()
, но если подстрока в строку не входит, возбуждается исключение
ValueError
. Формат метода:
<Строка>.rindex(<Подстрока>[, <Начало>[, <Конец>]])
Пример:
>>> s = "пример пример Пример Пример"
>>> s.rindex("при"), s.rindex("При"), s.rindex("при", 0, 6)
(7, 21, 0)
>>> s.rindex("тест")
Traceback (most recent call last):
File "
", line 1, in s.rindex("тест")
ValueError: substring not found
count()
— возвращает число вхождений подстроки в строку. Если подстрока в строку не входит, возвращается значение
0
. Метод зависит от регистра символов. Формат метода:
<Строка>.count(<Подстрока>[, <Начало>[, <Конец>]])
Пример:
>>> s = "пример пример Пример Пример"
>>> s.count("при"), s.count("при", 6), s.count("При")
(2, 1, 2)

Глава 6. Строки и двоичные данные
107
>>> s.count("тест")
0
startswith()
— проверяет, начинается ли строка с указанной подстроки. Если начинает- ся, возвращается значение
True
, в противном случае —
False
. Метод зависит от регистра символов. Формат метода:
<Строка>.startswith(<Подстрока>[, <Начало>[, <Конец>]])
Если начальная позиция не указана, сравнение будет производиться с началом строки.
Если параметры
<Начало>
и
<Конец>
указаны, выполняется операция извлечения среза, и сравнение будет производиться с началом фрагмента:
>>> s = "пример пример Пример Пример"
>>> s.startswith("при"), s.startswith("При")
(True, False)
>>> s.startswith("при", 6), s.startswith("При", 14)
(False, True)
Начиная с Python версии 2.5, параметр
<Подстрока>
может быть кортежем:
>>> s = "пример пример Пример Пример"
>>> s.startswith(("при", "При"))
True
endswith()
— проверяет, заканчивается ли строка указанной подстрокой. Если заканчи- вается, то возвращается значение
True
, в противном случае —
False
. Метод зависит от регистра символов. Формат метода:
<Строка>.endswith(<Подстрока>[, <Начало>[, <Конец>]])
Если начальная позиция не указана, то сравнение будет производиться с концом строки.
Если параметры
<Начало>
и
<Конец>
указаны, то выполняется операция извлечения среза, и сравнение будет производиться с концом фрагмента:
>>> s = "подстрока ПОДСТРОКА"
>>> s.endswith("ока"), s.endswith("ОКА")
(False, True)
>>> s.endswith("ока", 0, 9)
True
Начиная с Python версии 2.5, параметр
<Подстрока>
может быть кортежем:
>>> s = "подстрока ПОДСТРОКА"
>>> s.endswith(("ока", "ОКА"))
True
replace()
— производит замену всех вхождений заданной подстроки в строке на другую подстроку и возвращает результат в виде новой строки. Метод зависит от регистра сим- волов. Формат метода:
<Строка>.replace(<Подстрока для замены>, <Новая подстрока>[,
<Максимальное количество замен>])
Если количество замен не указано, будет выполнена замена всех найденных подстрок:
>>> s = "Привет, Петя"
>>> print(s.replace("Петя", "Вася"))
Привет, Вася

108
Часть I. Основы языка Python
>>> print(s.replace("петя", "вася")) # Зависит от регистра
Привет, Петя
>>> s = "strstrstrstrstr"
>>> s.replace("str", ""), s.replace("str", "", 3)
('', 'strstr')
translate(<Таблица символов>)
— заменяет символы в соответствии с параметром
<Таблица символов>
. Параметр
<Таблица символов>
должен быть словарем, ключами которого являются Unicode-коды заменяемых символов, а значениями — Unicode-коды заменяющих символов. Если в качестве значения указать
None
, то символ будет удален.
Для примера удалим букву
П
, а также изменим регистр всех букв р
:
>>> s = "Пример"
>>> d = {ord("П"): None, ord("р"): ord("Р")}
>>> d
{1088: 1056, 1055: None}
>>> s.translate(d)
'РимеР'
Упростить создание параметра
<Таблица символов>
позволяет статический метод maketrans()
. Формат метода: str.maketrans([, [, ]])
Если указан только первый параметр, то он должен быть словарем:
>>> t = str.maketrans({"а": "А", "о": "О", "с": None})
>>> t
{1072: 'А', 1089: None, 1086: 'О'}
>>> "строка".translate(t)
'трОкА'
Если указаны два первых параметра, то они должны быть строками одинаковой длины.
В результате будет создан словарь с ключами из строки

и значениями из строки

, расположенными в той же позиции. Изменим регистр некоторых символов:
>>> t = str.maketrans("абвгдежзи", "АБВГДЕЖЗИ")
>>> t
{1072: 1040, 1073: 1041, 1074: 1042, 1075: 1043, 1076: 1044,
1077: 1045, 1078: 1046, 1079: 1047, 1080: 1048}
>>> "абвгдежзи".translate(t)
'АБВГДЕЖЗИ'
В третьем параметре можно дополнительно указать строку из символов, которым будет сопоставлено значение
None
. После выполнения метода translate()
эти символы будут удалены из строки. Заменим все цифры на
0
, а некоторые буквы удалим из строки:
>>> t = str.maketrans("123456789", "0" * 9, "str")
>>> t
{116: None, 115: None, 114: None, 49: 48, 50: 48, 51: 48,
52: 48, 53: 48, 54: 48, 55: 48, 56: 48, 57: 48}
>>> "str123456789str".translate(t)
'000000000'

Глава 6. Строки и двоичные данные
109 6.11. Проверка типа содержимого строки
Для проверки типа содержимого предназначены следующие методы:
isalnum()
— возвращает
True
, если строка содержит только буквы и (или) цифры, в про- тивном случае —
False
. Если строка пустая, возвращается значение
False
:
>>> "0123".isalnum(), "123abc".isalnum(), "abc123".isalnum()
(True, True, True)
>>> "строка".isalnum()
True
>>> "".isalnum(), "123 abc".isalnum(), "abc, 123.".isalnum()
(False, False, False)
isalpha()
— возвращает
True
, если строка содержит только буквы, в противном слу- чае —
False
. Если строка пустая, возвращается значение
False
:
>>> "string".isalpha(), "строка".isalpha(), "".isalpha()
(True, True, False)
>>> "123abc".isalpha(), "str str".isalpha(), "st,st".isalpha()
(False, False, False)
isdigit()
— возвращает
True
, если строка содержит только цифры, в противном слу- чае —
False
:
>>> "0123".isdigit(), "123abc".isdigit(), "abc123".isdigit()
(True, False, False)
isdecimal()
— возвращает
True
, если строка содержит только десятичные символы, в противном случае —
False
. К десятичным символам относятся десятичные цифры в кодировке ASCII, а также надстрочные и подстрочные десятичные цифры в других языках:
>>> "123".isdecimal(), "123стр".isdecimal()
(True, False)
isnumeric()
— возвращает
True
, если строка содержит только числовые символы, в про- тивном случае —
False
. К числовым символам относятся десятичные цифры в кодиров- ке ASCII, символы римских чисел, дробные числа и др.:
>>> "\u2155".isnumeric(), "\u2155".isdigit()
(True, False)
>>> print("\u2155") # Выведет символ "1/5"
isupper()
— возвращает
True
, если строка содержит буквы только верхнего регистра, в противном случае —
False
:
>>> "STRING".isupper(), "СТРОКА".isupper(), "".isupper()
(True, True, False)
>>> "STRING1".isupper(), "СТРОКА, 123".isupper(), "123".isupper()
(True, True, False)
>>> "string".isupper(), "STRing".isupper()
(False, False)
islower()
— возвращает
True
, если строка содержит буквы только нижнего регистра, в противном случае —
False
:

110
Часть I. Основы языка Python
>>> "srting".islower(), "строка".islower(), "".islower()
(True, True, False)
>>> "string1".islower(), "str, 123".islower(), "123".islower()
(True, True, False)
>>> "STRING".islower(), "Строка".islower()
(False, False)
istitle()
— возвращает
True
, если все слова в строке начинаются с заглавной буквы, в противном случае —
False
. Если строка пустая, также возвращается
False
:
>>> "Str Str".istitle(), "Стр Стр".istitle()
(True, True)
>>> "Str Str 123".istitle(), "Стр Стр 123".istitle()
(True, True)
>>> "Str str".istitle(), "Стр стр".istitle()
(False, False)
>>> "".istitle(), "123".istitle()
(False, False)
isprintable()
— возвращает
True
, если строка содержит только печатаемые символы, в противном случае —
False
. Отметим, что пробел относится к печатаемым символам:
>>> "123".isprintable()
True
>>> "PHP Python".isprintable()
True
>>> "\n".isprintable()
False
isspace()
— возвращает
True
, если строка содержит только пробельные символы, в про- тивном случае —
False
:
>>> "".isspace(), " \n\r\t".isspace(), "str str".isspace()
(False, True, False)
isidentifier()
— возвращает
True
, если строка представляет собой допустимое с точки зрения Python имя переменной, функции или класса, в противном случае —
False
:
>>> "s".isidentifier()
True
>>> "func".isidentifier()
True
>>> "123func".isidentifier()
False
Следует иметь в виду, что метод isidentifier()
лишь проверяет, удовлетворяет ли за- данное имя правилам языка. Он не проверяет, совпадает ли это имя с ключевым словом
Python. Для этого надлежит применять функцию iskeyword()
, объявленную в модуле keyword
, которая возвращает
True
, если переданная ей строка совпадает с одним из клю- чевых слов:
>>> keyword.iskeyword("else")
True
>>> keyword.iskeyword("elsewhere")
False

Глава 6. Строки и двоичные данные
111
Переделаем нашу программу суммирования произвольного количества целых чисел, вве- денных пользователем (см. листинг 4.12), таким образом, чтобы при вводе строки вместо числа программа не завершалась с фатальной ошибкой. Кроме того, предусмотрим возмож- ность ввода отрицательных целых чисел (листинг 6.2).
Листинг 6.2. Суммирование неопределенного количества чисел
# -*- coding: utf-8 -*- print("Введите слово 'stop' для получения результата") summa = 0 while True: x = input("Введите число: ") if x == "stop": break # Выход из цикла if x == "": print("Вы не ввели значение!") continue if x[0] == "-": # Если первым символом является минус if not x[1:].isdigit(): # Если фрагмент не состоит из цифр print("Необходимо ввести число, а не строку!") continue else: # Если минуса нет, то проверяем всю строку if not x.isdigit(): # Если строка не состоит из цифр print("Необходимо ввести число, а не строку!") continue x = int(x) # Преобразуем строку в число summa += x print("Сумма чисел равна:", summa) input()
Процесс ввода значений и получения результата выглядит так (значения, введенные поль- зователем, выделены здесь полужирным шрифтом):
Введите слово 'stop' для получения результата
Введите число:
10
Введите число:
Вы не ввели значение!
Введите число: str
Необходимо ввести число, а не строку!
Введите число:
-5
Введите число:
-str
Необходимо ввести число, а не строку!
Введите число: stop
Сумма чисел равна: 5 6.12. Тип данных bytes
Тип данных str отлично подходит для хранения текста, но что делать, если необходимо обрабатывать изображения? Ведь изображение не имеет кодировки, а значит, оно не может быть преобразовано в Unicode-строку. Для решения этой проблемы в Python 3 были введе-

112
Часть I. Основы языка Python ны типы bytes и bytearray
, которые позволяют хранить последовательность целых чисел в диапазоне от
0
до
255
, т. е. байтов. Тип данных bytes относится к неизменяемым типам, как и строки, а тип данных bytearray
— к изменяемым, как и списки.
Создать объект типа bytes можно следующими способами:
с помощью функции bytes([<Строка>, <Кодировка>[, <Обработка ошибок>]])
. Если параметры не указаны, то возвращается пустой объект. Чтобы преобразовать строку в объект типа bytes
, необходимо передать минимум два первых параметра. Если строка указана только в первом параметре, то возбуждается исключение
TypeError
:
>>> bytes() b''
>>> bytes("строка", "cp1251") b'\xf1\xf2\xf0\xee\xea\xe0'
>>> bytes("строка")
Traceback (most recent call last):
File "
", line 1, in bytes("строка")
TypeError: string argument without an encoding
В третьем параметре могут быть указаны значения "strict"
(при ошибке возбуждается исключение
UnicodeEncodeError
— значение по умолчанию),
"replace"
(неизвестный символ заменяется символом вопроса) или "ignore"
(неизвестные символы игнориру- ются):
>>> bytes("string\uFFFD", "cp1251", "strict")
Traceback (most recent call last):
File "
", line 1, in bytes("string\uFFFD", "cp1251", "strict")
File "C:\Python36\lib\encodings\cp1251.py", line 12, in encode return codecs.charmap_encode(input,errors,encoding_table)
UnicodeEncodeError: 'charmap' codec can't encode character
'\ufffd' in position 6: character maps to


>>> bytes("string\uFFFD", "cp1251", "replace") b'string?'
>>> bytes("string\uFFFD", "cp1251", "ignore") b'string'
с помощью строкового метода encode([encoding="utf-8"][, errors="strict"])
. Если кодировка не указана, строка преобразуется в последовательность байтов в кодировке
UTF-8. В параметре errors могут быть указаны значения "strict"
(значение по умолча- нию),
"replace"
,
"ignore"
,
"xmlcharrefreplace" или "backslashreplace"
:
>>> "строка".encode() b'\xd1\x81\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0'
>>> "строка".encode(encoding="cp1251") b'\xf1\xf2\xf0\xee\xea\xe0'
>>> "строка\uFFFD".encode(encoding="cp1251", errors="xmlcharrefreplace") b'\xf1\xf2\xf0\xee\xea\xe0�'
>>> "строка\uFFFD".encode(encoding="cp1251", errors="backslashreplace") b'\xf1\xf2\xf0\xee\xea\xe0\\ufffd'

Глава 6. Строки и двоичные данные
113
указав букву b
(регистр не имеет значения) перед строкой в апострофах, кавычках, трой- ных апострофах или тройных кавычках. Обратите внимание на то, что в строке могут быть только символы с кодами, входящими в кодировку ASCII. Все остальные символы должны быть представлены специальными последовательностями:
>>> b"string", b'string', b"""string""", b'''string'''
(b'string', b'string', b'string', b'string')
>>> b"строка"
SyntaxError: bytes can only contain ASCII literal characters.
>>> b"\xf1\xf2\xf0\xee\xea\xe0" b'\xf1\xf2\xf0\xee\xea\xe0'
с помощью функции bytes(<Последовательность>)
, которая преобразует последователь- ность целых чисел от
0
до
255
в объект типа bytes
. Если число не попадает в диапазон, возбуждается исключение
ValueError
:
>>> b = bytes([225, 226, 224, 174, 170, 160])
>>> b b'\xe1\xe2\xe0\xae\xaa\xa0'
>>> str(b, "cp866")
'строка'
с помощью функции bytes(<Число>)
, которая задает количество элементов в последова- тельности. Каждый элемент будет содержать нулевой символ:
>>> bytes(10) b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
с помощью метода bytes.fromhex(<Строка>)
. Строка в этом случае должна содержать шестнадцатеричные значения символов:
>>> b = bytes.fromhex(" e1 e2e0ae aaa0 ")
>>> b b'\xe1\xe2\xe0\xae\xaa\xa0'
>>> str(b, "cp866")
'строка'
Объекты типа bytes относятся к последовательностям. Каждый элемент такой последова- тельности может хранить целое число от
0
до
255
, которое обозначает код символа. Как и все последовательности, объекты поддерживают обращение к элементу по индексу, полу- чение среза, конкатенацию, повторение и проверку на вхождение:
>>> b = bytes("string", "cp1251")
>>> b b'string'
>>> b[0] # Обращение по индексу
115
>>> b[1:3] # Получение среза b'tr'
>>> b + b"123" # Конкатенация b'string123'
>>> b * 3 # Повторение b'stringstringstring'
>>> 115 in b, b"tr" in b, b"as" in b
(True, True, False)

114
Часть I. Основы языка Python
Как видно из примера, при выводе объекта целиком, а также при извлечении среза, произ- водится попытка отображения символов. Однако доступ по индексу возвращает целое чис- ло, а не символ. Если преобразовать объект в список, то мы получим последовательность целых чисел:
>>> list(bytes("string", "cp1251"))
[115, 116, 114, 105, 110, 103]
Тип bytes относится к неизменяемым типам. Это означает, что можно получить значение по индексу, но изменить его нельзя:
>>> b = bytes("string", "cp1251")
>>> b[0] = 168
Traceback (most recent call last):
File "
", line 1, in b[0] = 168
TypeError: 'bytes' object does not support item assignment
Объекты типа bytes поддерживают большинство строковых методов, которые мы рассмат- ривали в предыдущих разделах. Однако некоторые из этих методов могут некорректно ра- ботать с русскими буквами — в этих случаях следует использовать тип str
, а не тип bytes
Не поддерживаются объектами типа bytes строковые методы encode()
, isidentifier()
, isprintable()
, isnumeric()
, isdecimal()
, format_map()
и format()
, а также операция фор- матирования.
При использовании методов следует учитывать, что в параметрах нужно указывать объекты типа bytes
, а не строки:
>>> b = bytes("string", "cp1251")
>>> b.replace(b"s", b"S") b'String'
Необходимо также помнить, что смешивать строки и объекты типа bytes в выражениях нельзя. Предварительно необходимо явно преобразовать объекты к одному типу, а лишь затем производить операцию:
>>> b"string" + "string"
Traceback (most recent call last):
File "
", line 1, in b"string" + "string"
TypeError: can't concat bytes to str
>>> b"string" + "string".encode("ascii") b'stringstring'
Объект типа bytes может содержать как однобайтовые, так и многобайтовые символы. При использовании многобайтовых символов некоторые функции могут работать не так, как предполагалось, — например, функция len()
вернет количество байтов, а не символов:
>>> len("строка")
6
>>> len(bytes("строка", "cp1251"))
6
>>> len(bytes("строка", "utf-8"))
12

Глава 6. Строки и двоичные данные
115
Преобразовать объект типа bytes в строку позволяет метод decode()
. Метод имеет следую- щий формат: decode([encoding="utf-8"][, errors="strict"])
Параметр encoding задает кодировку символов (по умолчанию UTF-8) в объекте bytes
, а параметр errors
— способ обработки ошибок при преобразовании. В параметре errors можно указать значения "strict"
(значение по умолчанию),
"replace"
или "ignore"
. При- мер преобразования:
>>> b = bytes("строка", "cp1251")
>>> b.decode(encoding="cp1251"), b.decode("cp1251")
('строка', 'строка')
Для преобразования можно также воспользоваться функцией str()
:
>>> b = bytes("строка", "cp1251")
>>> str(b, "cp1251")
'строка'
Чтобы изменить кодировку данных, следует сначала преобразовать тип bytes в строку, а затем произвести обратное преобразование, указав нужную кодировку. Преобразуем дан- ные из кодировки Windows-1251 в кодировку KOI8-R, а затем обратно:
>>> w = bytes("Строка", "cp1251") # Данные в кодировке windows-1251
>>> k = w.decode("cp1251").encode("koi8-r")
>>> k, str(k, "koi8-r") # Данные в кодировке KOI8-R
(b'\xf3\xd4\xd2\xcf\xcb\xc1', 'Строка')
>>> w = k.decode("koi8-r").encode("cp1251")
>>> w, str(w, "cp1251") # Данные в кодировке windows-1251
(b'\xd1\xf2\xf0\xee\xea\xe0', 'Строка')
В Python 3.5 появились два полезных инструмента для работы с типом данных bytes
. Во- первых, теперь можно форматировать такие данные с применением описанного в разд. 6.4 оператора
%
:
>>> b"%i - %i - %f" % (10, 20, 30) b'10 - 20 - 30.000000'
Однако здесь нужно помнить, что тип преобразования s
(т. е. вывод в виде Unicode-строки) в этом случае не поддерживается, и его использование приведет к возбуждению исключе- ния
TypeError
:
>>> b"%s - %s - %s" % (10, 20, 30)
Traceback (most recent call last):
File "
", line 1, in b"%s - %s - %s" % (10, 20, 30)
TypeError: %b requires a bytes-like object, or an object that implements __bytes__, not 'int'
Во-вторых, тип bytes получил поддержку метода hex()
, который возвращает строку с шест- надцатеричным представлением значения:
>>> b"string".hex()
'737472696e67'

116
Часть I. Основы языка Python
6.13. Тип данных bytearray
Тип данных bytearray является разновидностью типа bytes и поддерживает те же самые методы и операции (включая оператор форматирования
%
и метод hex()
, описанные ранее).
В отличие от типа bytes
, тип bytearray допускает возможность непосредственного измене- ния объекта и содержит дополнительные методы, позволяющие выполнять эти изменения.
Создать объект типа bytearray можно следующими способами:
с помощью функции bytearray([<Строка>, <Кодировка>[, <Обработка ошибок>]])
. Если параметры не указаны, то возвращается пустой объект. Чтобы преобразовать строку в объект типа bytearray
, необходимо передать минимум два первых параметра. Если строка указана только в первом параметре, то возбуждается исключение
TypeError
:
>>> bytearray() bytearray(b'')
>>> bytearray("строка", "cp1251") bytearray(b'\xf1\xf2\xf0\xee\xea\xe0')
>>> bytearray("строка")
Traceback (most recent call last):
File "
", line 1, in bytearray("строка")
TypeError: string argument without an encoding
В третьем параметре могут быть указаны значения "strict"
(при ошибке возбуждается исключение
UnicodeEncodeError
— значение по умолчанию),
"replace"
(неизвестный символ заменяется символом вопроса) или "ignore"
(неизвестные символы игнорируются):
>>> bytearray("string\uFFFD", "cp1251", "strict")
Traceback (most recent call last):
File "
", line 1, in bytearray("string\uFFFD", "cp1251", "strict")
File "C:\Python36\lib\encodings\cp1251.py", line 12, in encode return codecs.charmap_encode(input,errors,encoding_table)
UnicodeEncodeError: 'charmap' codec can't encode character
'\ufffd' in position 6: character maps to
>>> bytearray("string\uFFFD", "cp1251", "replace") bytearray(b'string?')
>>> bytearray("string\uFFFD", "cp1251", "ignore") bytearray(b'string')
с помощью функции bytearray(<Последовательность>)
, которая преобразует последова- тельность целых чисел от
0
до
255
в объект типа bytearray
. Если число не попадает в диапазон, возбуждается исключение
ValueError
:
>>> b = bytearray([225, 226, 224, 174, 170, 160])
>>> b bytearray(b'\xe1\xe2\xe0\xae\xaa\xa0')
>>> bytearray(b'\xe1\xe2\xe0\xae\xaa\xa0') bytearray(b'\xe1\xe2\xe0\xae\xaa\xa0')
>>> str(b, "cp866")
'строка'
с помощью функции bytearray(<Число>)
, которая задает количество элементов в после- довательности. Каждый элемент будет содержать нулевой символ:

Глава 6. Строки и двоичные данные
117
>>> bytearray(5) bytearray(b'\x00\x00\x00\x00\x00')
с помощью метода bytearray.fromhex(<Строка>)
. Строка в этом случае должна содер- жать шестнадцатеричные значения символов:
>>> b = bytearray.fromhex(" e1 e2e0ae aaa0 ")
>>> b bytearray(b'\xe1\xe2\xe0\xae\xaa\xa0')
>>> str(b, "cp866")
'строка'
Тип bytearray относится к изменяемым типам. Поэтому можно не только получить значе- ние по индексу, но и изменить его (что не свойственно строкам):
>>> b = bytearray("Python", "ascii")
>>> b[0] # Можем получить значение
80
>>> b[0] = b"J"[0] # Можем изменить значение
>>> b bytearray(b'Jython')
При изменении значения важно помнить, что присваиваемое значение должно быть целым числом в диапазоне от
0
до
255
. Чтобы получить число в предыдущем примере, мы создали объект типа bytes
, а затем присвоили значение, расположенное по индексу
0
(
b[0] = b"J"[0]
). Можно, конечно, сразу указать код символа, но ведь держать все коды символов в памяти свойственно компьютеру, а не человеку.
Для изменения объекта можно также использовать следующие методы:
append(<Число>)
— добавляет один элемент в конец объекта. Метод изменяет текущий объект и ничего не возвращает:
>>> b = bytearray("string", "ascii")
>>> b.append(b"1"[0]); b bytearray(b'string1')
extend(<Последовательность>)
— добавляет элементы последовательности в конец объекта. Метод изменяет текущий объект и ничего не возвращает:
>>> b = bytearray("string", "ascii")
>>> b.extend(b"123"); b bytearray(b'string123')
Добавить несколько элементов можно с помощью операторов
+
и
+=
:
>>> b = bytearray("string", "ascii")
>>> b + b"123" # Возвращает новый объект bytearray(b'string123')
>>> b += b"456"; b # Изменяет текущий объект bytearray(b'string456')
Кроме того, можно воспользоваться операцией присваивания значения срезу:
>>> b = bytearray("string", "ascii")
>>> b[len(b):] = b"123" # Добавляем элементы в последовательность
>>> b bytearray(b'string123')

118
Часть I. Основы языка Python
insert(<Индекс>, <Число>)
— добавляет один элемент в указанную позицию. Осталь- ные элементы смещаются. Метод изменяет текущий объект и ничего не возвращает. До- бавим элемент в начало объекта:
>>> b = bytearray("string", "ascii")
>>> b.insert(0, b"1"[0]); b bytearray(b'1string')
Метод insert()
позволяет добавить только один элемент. Чтобы добавить несколько элементов, можно воспользоваться операцией присваивания значения срезу. Добавим несколько элементов в начало объекта:
>>> b = bytearray("string", "ascii")
>>> b[:0] = b"123"; b bytearray(b'123string')
pop([<Индекс>])
— удаляет элемент, расположенный по указанному индексу, и воз- вращает его. Если индекс не указан, удаляет и возвращает последний элемент:
>>> b = bytearray("string", "ascii")
>>> b.pop() # Удаляем последний элемент
103
>>> b bytearray(b'strin')
>>> b.pop(0) # Удаляем первый элемент
115
>>> b bytearray(b'trin')
Удалить элемент списка позволяет также оператор del
:
>>> b = bytearray("string", "ascii")
>>> del b[5] # Удаляем последний элемент
>>> b bytearray(b'strin')
>>> del b[:2] # Удаляем первый и второй элементы
>>> b bytearray(b'rin')
remove(<Число>)
— удаляет первый элемент, содержащий указанное значение. Если элемент не найден, возбуждается исключение
ValueError
. Метод изменяет текущий объ- ект и ничего не возвращает:
>>> b = bytearray("strstr", "ascii")
>>> b.remove(b"s"[0]) # Удаляет только первый элемент
>>> b bytearray(b'trstr')
reverse()
— изменяет порядок следования элементов на противоположный. Метод изменяет текущий объект и ничего не возвращает:
>>> b = bytearray("string", "ascii")
>>> b.reverse(); b bytearray(b'gnirts')
Преобразовать объект типа bytearray в строку позволяет метод decode()
. Метод имеет сле- дующий формат: decode([encoding="utf-8"][, errors="strict"])

Глава 6. Строки и двоичные данные
119
Параметр encoding задает кодировку символов (по умолчанию UTF-8) в объекте bytearray
, а параметр errors
— способ обработки ошибок при преобразовании. В параметре errors можно указать значения "strict"
(значение по умолчанию), "
replace"
или "ignore"
. При- мер преобразования:
>>> b = bytearray("строка", "cp1251")
>>> b.decode(encoding="cp1251"), b.decode("cp1251")
('строка', 'строка')
Для преобразования можно также воспользоваться функцией str()
:
>>> b = bytearray("строка", "cp1251")
>>> str(b, "cp1251")
'строка'
6.14. Преобразование объекта в последовательность байтов
Преобразовать объект в последовательность байтов (выполнить его сериализацию), а затем восстановить (десериализовать) объект позволяет модуль pickle
. Прежде чем использовать функции из этого модуля, необходимо подключить модуль с помощью инструкции: import pickle
Для преобразования предназначены две функции:
dumps(<Объект>[, protocol=None][, fix_imports=True])
— производит сериализацию объекта и возвращает последовательность байтов специального формата. Формат зави- сит от указанного во втором параметре протокола, который задается в виде числа от
0
до значения константы pickle.HIGHEST_PROTOCOL
. Если второй параметр не указан, будет использован протокол
3
(константа pickle.DEFAULT_PROTOCOL
). Пример преобразования списка и кортежа:
>>> import pickle
>>> obj1 = [1, 2, 3, 4, 5] # Список
>>> obj2 = (6, 7, 8, 9, 10) # Кортеж
>>> pickle.dumps(obj1) b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04K\x05e.'
>>> pickle.dumps(obj2) b'\x80\x03(K\x06K\x07K\x08K\tK\ntq\x00.'
loads(<Последовательность байтов>[, fix_imports=True][, encoding="ASCII"][, errors="strict"])
— преобразует последовательность байтов специального формата обратно в объект, выполняя его десериализацию. Пример восстановления списка и кор- тежа:
>>> pickle.loads(b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04K\x05e.')
[1, 2, 3, 4, 5]
>>> pickle.loads(b'\x80\x03(K\x06K\x07K\x08K\tK\ntq\x00.')
(6, 7, 8, 9, 10)

120
Часть I. Основы языка Python
6.15. Шифрование строк
Для шифрования строк предназначен модуль hashlib
. Прежде чем использовать функции из этого модуля, необходимо подключить модуль с помощью инструкции: import hashlib
Модуль предоставляет следующие функции: md5()
, sha1()
, sha224()
, sha256()
, sha384()
, sha512()
, в Python 3.6 появилась поддержка функций sha3_224()
, sha3_256()
, sha3_384()
, sha3_512()
, shake_128()
и shake_256().
В качестве необязательного параметра функциям можно передать шифруемую последовательность байтов:
>>> import hashlib
>>> h = hashlib.sha1(b"password")
Передать последовательность байтов можно также с помощью метода update()
. В этом случае объект присоединяется к предыдущему значению:
>>> h = hashlib.sha1()
>>> h.update(b"password")
Получить зашифрованную последовательность байтов и строку позволяют два метода: digest()
и hexdigest()
. Первый метод возвращает значение, относящееся к типу bytes
, а второй — строку, содержащую шестнадцатеричные цифры:
>>> h = hashlib.sha1(b"password")
>>> h.digest() b'[\xaaa\xe4\xc9\xb9??\x06\x82%\x0bl\xf83\x1b\xe6\x8f\xd8'
>>> h.hexdigest()
'5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8'
Наиболее часто применяемой является функция md5()
, которая шифрует строку с помощью алгоритма MD5. Эта функция используется для шифрования паролей, т. к. не существует алгоритма для дешифровки зашифрованных ей значений. Для сравнения введенного поль- зователем пароля с сохраненным в базе необходимо зашифровать введенный пароль, а за- тем произвести сравнение:
>>> import hashlib
>>> h = hashlib.md5(b"password")
>>> p = h.hexdigest()
>>> p # Пароль, сохраненный в базе '5f4dcc3b5aa765d61d8327deb882cf99'
>>> h2 = hashlib.md5(b"password") # Пароль, введенный пользователем
>>> if p == h2.hexdigest(): print("Пароль правильный")
Пароль правильный
Свойство digest_size хранит размер значения, генерируемого описанными ранее функция- ми шифрования, в байтах:
>>> h = hashlib.sha512(b"password")
>>> h.digest_size
64
Поддерживается еще несколько функций, выполняющих устойчивое к взлому шифрование паролей:

Глава 6. Строки и двоичные данные
121
pbkdf2_hmac(<Основной алгоритм шифрования>, <Шифруемый пароль>, <"Соль">, <Коли- чество проходов шифрования>, dklen=None)
. В качестве основного алгоритма шифрова- ния следует указать строку с наименованием этого алгоритма:
"md5"
,
"sha1"
,
"sha224"
,
"sha256"
,
"sha384"
и "sha512"
. Шифруемый пароль указывается в виде значения типа bytes
"Соль"
— это особая величина типа bytes
, выступающая в качестве ключа шиф- рования, — ее длина не должна быть менее 16 символов. Количество проходов шифро- вания следует указать достаточно большим (так, при использовании алгоритма SHA512 оно должно составлять 100 000). Последним параметром функции pbkdf2_hmac()
можно указать длину результирующего закодированного значения в байтах — если она не за- дана или равна
None
, будет создано значение стандартной для выбранного алгоритма длины (64 байта для алгоритма SHA512). Закодированный пароль возвращается в виде величины типа bytes
:
>>> import hashlib
>>> dk = hashlib.pbkdf2_hmac('sha512', b'1234567', b'saltsaltsaltsalt', 100000)
>>> dk b"Sb\x85tc-\xcb@\xc5\x97\x19\x90\x94@\x9f\xde\x07\xa4p-\x83\x94\xf4\x94\x99\x07\ xec\xfa\xf3\xcd\xc3\x88jv\xd1\xe5\x9a\x119\x15/\xa4\xc2\xd3N\xaba\x02\xc0s\xc1\ xd1\x0b\x86xj(\x8c>Mr'@\xbb"
П
РИМЕЧАНИЕ
Кодирование данных с применением функции pbkdf2_hmac() отнимает очень много сис- темных ресурсов и может занять значительное время, особенно на маломощных компью- терах.
Поддержка двух следующих функций появилась в Python 3.6:
blake2s([<Шифруемый пароль>][, digest_size=32], [salt=b””])
— шифрует пароль по алгоритму BLAKE2s, оптимизированному для 32-разрядных систем. Второй параметр задает размер значения в виде числа от 1 до 32, третий — «соль» в виде величины типа bytes
, которая может иметь в длину не более 8 байтов. Возвращает объект, хранящий закодированный пароль:
>>> h = hashlib.blake2s(b"string", digest_size=16, salt=b"saltsalt")
>>> h.digest() b'\x96l\xe0\xfa\xb4\xe7Bw\x11\xf7D\xc2\xa4\xcf\x06\xf7'
blake2b([<Шифруемый пароль>][, digest_size=64], [salt=b””])
— шифрует пароль по алгоритму BLAKE2b, оптимизированному для 64-разрядных систем. Второй параметр задает размер значения в виде числа от 1 до 64, третий — «соль» в виде величины типа bytes
, которая может иметь в длину не более 16 байтов. Возвращает объект, хранящий закодированный пароль:
>>> h = hashlib.blake2b(b"string", digest_size=48, salt=b"saltsaltsalt")
>>> h.digest() b'\x0e\xcf\xb9\xc8G;q\xbaV\xbdV\x16\xd4@/J\x97W\x0c\xc4\xc5{\xd4\xb6\x12\x01z\ x9f\xdd\xf6\xf1\x03o\x97&v\xfd\xa6\x90\x81\xc4T\xb8z\xaf\xc3\x9a\xd9'
П
РИМЕЧАНИЕ
Функции blake2b() и blake2s() поддерживают большое количество параметров, которые применяются только в специфических случаях. Полное описание этих функций можно най- ти в документации по Python.

ГЛ А В А
7
Регулярные выражения
Регулярные выражения предназначены для выполнения в строке сложного поиска или за- мены. В языке Python использовать регулярные выражения позволяет модуль re
. Прежде чем задействовать функции из этого модуля, необходимо подключить модуль с помощью инструкции: import re
7.1. Синтаксис регулярных выражений
Создать откомпилированный шаблон регулярного выражения позволяет функция compile()
. Функция имеет следующий формат:
<Шаблон> = re.compile(<Регулярное выражение>[, <Модификатор>])
В параметре
<Модификатор>
могут быть указаны следующие флаги (или их комбинация через оператор
|
):

I
или
IGNORECASE
— поиск без учета регистра:
>>> import re
>>> p = re.compile(r"^[а-яе]+$", re.I | re.U)
>>> print("Найдено" if p.search("АБВГДЕЕ") else "Нет")
Найдено
>>> p = re.compile(r"^[а-яе]+$", re.U)
>>> print("Найдено" if p.search("АБВГДЕЕ") else "Нет")
Нет

M
или
MULTILINE
— поиск в строке, состоящей из нескольких подстрок, разделенных символом новой строки (
"\n"
). Символ
^
соответствует привязке к началу каждой под- строки, а символ
$
— позиции перед символом перевода строки;

S
или
DOTALL
— метасимвол «точка» по умолчанию соответствует любому символу, кро- ме символа перевода строки (
\n
). Символу перевода строки метасимвол «точка» будет соответствовать в присутствии дополнительного модификатора. Символ
^
соответствует привязке к началу всей строки, а символ
$
— привязке к концу всей строки:
>>> p = re.compile(r"^.$")
>>> print("Найдено" if p.search("\n") else "Нет")
Нет
>>> p = re.compile(r"^.$", re.M)

Глава 7. Регулярные выражения
123
>>> print("Найдено" if p.search("\n") else "Нет")
Нет
>>> p = re.compile(r"^.$", re.S)
>>> print("Найдено" if p.search("\n") else "Нет")
Найдено

X
или
VERBOSE
— если флаг указан, то пробелы и символы перевода строки будут проиг- норированы. Внутри регулярного выражения можно использовать и комментарии:
>>> p = re.compile(r"""^ # Привязка к началу строки
[0-9]+ # Строка должна содержать одну цифру (или более)
$ # Привязка к концу строки """, re.X | re.S)
>>> print("Найдено" if p.search("1234567890") else "Нет")
Найдено
>>> print("Найдено" if p.search("abcd123") else "Нет")
Нет

A
или
ASCII
— классы
\w
,
\W
,
\b
,
\B
,
\d
,
\D
,
\s и
\S
будут соответствовать символам в ко- дировке ASCII (по умолчанию указанные классы соответствуют Unicode-символам);
П
РИМЕЧАНИЕ
Флаги U и UNICODE, включающие режим соответствия Unicode-символам классов \w, \W, \b,
\B
, \d, \D, \s и \S, сохранены в Python 3 лишь для совместимости с ранними версиями это- го языка и никакого влияния на обработку регулярных выражений не оказывают.

L
или
LOCALE
— учитываются настройки текущей локали. Начиная с Python 3.6, могут быть использованы только в том случае, когда регулярное выражение задается в виде значения типов bytes или bytearray
Как видно из примеров, перед всеми строками, содержащими регулярные выражения, указан модификатор r
. Иными словами, мы используем неформатированные строки. Если модификатор не указать, то все слэши необходимо экранировать. Например, строку: p = re.compile(r"^\w+$") нужно было бы записать так: p = re.compile("^\\w+$")
Внутри регулярного выражения символы
,
^
,
$
,
*
,
+
,
?
,
{
,
[
,
]
,
\
,
|
,
(
и
)
имеют специальное значение. Если эти символы должны трактоваться как есть, их следует экранировать с по- мощью слэша. Некоторые специальные символы теряют свое особое значение, если их раз- местить внутри квадратных скобок, — в этом случае экранировать их не нужно. Например, как уже было отмечено ранее, метасимвол «точка» по умолчанию соответствует любому символу, кроме символа перевода строки. Если необходимо найти именно точку, то перед точкой нужно указать символ
\
или разместить точку внутри квадратных скобок:
[.]
. Про- демонстрируем это на примере проверки правильности введенной даты (листинг 7.1).
Листинг 7.1. Проверка правильности ввода даты
# -*- coding: utf-8 -*- import re # Подключаем модуль d = "29,12.2009" # Вместо точки указана запятая p = re.compile(r"^[0-3][0-9].[01][0-9].[12][09][0-9][0-9]$")

124
Часть I. Основы языка Python
# Символ "\" не указан перед точкой if p.search(d): print("Дата введена правильно") else: print("Дата введена неправильно")
# Так как точка означает любой символ,
# выведет: Дата введена правильно p = re.compile(r"^[0-3][0-9]\.[01][0-9]\.[12][09][0-9][0-9]$")
# Символ "\" указан перед точкой if p.search(d): print("Дата введена правильно") else: print("Дата введена неправильно")
# Так как перед точкой указан символ "\",
# выведет: Дата введена неправильно p = re.compile(r"^[0-3][0-9][.][01][0-9][.][12][09][0-9][0-9]$")
# Точка внутри квадратных скобок if p.search(d): print("Дата введена правильно") else: print("Дата введена неправильно")
# Выведет: Дата введена неправильно input()
В этом примере мы осуществляли привязку к началу и концу строки с помощью следующих метасимволов:

^
— привязка к началу строки или подстроки. Она зависит от флагов
M
(или
MULTILINE
) и
S
(или
DOTALL
);

$
— привязка к концу строки или подстроки. Она зависит от флагов
M
(или
MULTILINE
) и
S
(или
DOTALL
);

\A
— привязка к началу строки (не зависит от модификатора);

\Z
— привязка к концу строки (не зависит от модификатора).
Если в параметре
<Модификатор>
указан флаг
M
(или
MULTILINE
), то поиск производится в строке, состоящей из нескольких подстрок, разделенных символом новой строки (
\n
).
В этом случае символ
^
соответствует привязке к началу каждой подстроки, а символ
$
— позиции перед символом перевода строки:
>>> p = re.compile(r"^.+$") # Точка не соответствует \n
>>> p.findall("str1\nstr2\nstr3") # Ничего не найдено
[]
>>> p = re.compile(r"^.+$", re.S) # Теперь точка соответствует \n
>>> p.findall("str1\nstr2\nstr3") # Строка полностью соответствует
['str1\nstr2\nstr3']
>>> p = re.compile(r"^.+$", re.M) # Многострочный режим
>>> p.findall("str1\nstr2\nstr3") # Получили каждую подстроку
['str1', 'str2', 'str3']

Глава 7. Регулярные выражения
125
Привязку к началу и концу строки следует использовать, если строка должна полностью соответствовать регулярному выражению. Например, для проверки, содержит ли строка число (листинг 7.2).
Листинг 7.2. Проверка наличия целого числа в строке
# -*- coding: utf-8 -*- import re # Подключаем модуль p = re.compile(r"^[0-9]+$", re.S) if p.search("245"): print("Число") # Выведет: Число else: print("Не число") if p.search("Строка245"): print("Число") else: print("Не число") # Выведет: Не число input()
Если убрать привязку к началу и концу строки, то любая строка, содержащая хотя бы одну цифру, будет распознана как
Число
(листинг 7.3).
Листинг 7.3. Отсутствие привязки к началу или концу строки
# -*- coding: utf-8 -*- import re # Подключаем модуль p = re.compile(r"[0-9]+", re.S) if p.search("Строка245"): print("Число") # Выведет: Число else: print("Не число") input()
Кроме того, можно указать привязку только к началу или только к концу строки (листинг 7.4).
Листинг 7.4. Привязка к началу и концу строки
# -*- coding: utf-8 -*- import re # Подключаем модуль p = re.compile(r"[0-9]+$", re.S) if p.search("Строка245"): print("Есть число в конце строки") else: print("Нет числа в конце строки")
# Выведет: Есть число в конце строки p = re.compile(r"^[0-9]+", re.S) if p.search("Строка245"): print("Есть число в начале строки") else: print("Нет числа в начале строки")
# Выведет: Нет числа в начале строки input()

126
Часть I. Основы языка Python
Также поддерживаются два метасимвола, позволяющие указать привязку к началу или кон- цу слова:

\b
— привязка к началу слова (началом слова считается пробел или любой символ, не являющийся буквой, цифрой или знаком подчеркивания);

\B
— привязка к позиции, не являющейся началом слова.
Рассмотрим несколько примеров:
>>> p = re.compile(r"\bpython\b")
>>> print("Найдено" if p.search("python") else "Нет")
Найдено
>>> print("Найдено" if p.search("pythonware") else "Нет")
Нет
>>> p = re.compile(r"\Bth\B")
>>> print("Найдено" if p.search("python") else "Нет")
Найдено
>>> print("Найдено" if p.search("this") else "Нет")
Нет
В квадратных скобках
[]
можно указать символы, которые могут встречаться на этом месте в строке. Разрешается записать символы подряд или указать диапазон через дефис:

[09]
— соответствует числу 0 или 9;

[0-9]
— соответствует любому числу от 0 до 9;

[абв]
— соответствует буквам «а», «б» и «в»;

[а-г]
— соответствует буквам «а», «б», «в» и «г»;

[а-яё]
— соответствует любой букве от «а» до «я»;

[АБВ]
— соответствует буквам «А», «Б» и «В»;

[А-ЯЁ]
— соответствует любой букве от «А» до «Я»;

[а-яА-ЯёЁ]
— соответствует любой русской букве в любом регистре;

[0-9а-яА-ЯёЁa-zA-Z]
— любая цифра и любая буква независимо от регистра и языка.
В
НИМАНИЕ
!
Буква «ё» не входит в диапазон [а-я], а буква «Ё» — в диапазон [А-Я].
Значение в скобках инвертируется, если после первой скобки вставить символ
^
. Таким образом можно указать символы, которых не должно быть на этом месте в строке:

[^09]
— не цифра 0 или 9;

[^0-9]
— не цифра от 0 до 9;

[^а-яА-ЯёЁa-zA-Z]
— не буква.
Как вы уже знаете, точка теряет свое специальное значение, если ее заключить в квадрат- ные скобки. Кроме того, внутри квадратных скобок могут встретиться символы, которые имеют специальное значение (например,
^
и
-
). Символ
^
теряет свое специальное значение, если он не расположен сразу после открывающей квадратной скобки. Чтобы отменить спе- циальное значение символа
-
, его необходимо указать после всех символов, перед закры- вающей квадратной скобкой или сразу после открывающей квадратной скобки. Все специ- альные символы можно сделать обычными, если перед ними указать символ
\

Глава 7. Регулярные выражения
127
Метасимвол
|
позволяет сделать выбор между альтернативными значениями. Выражение n|m соответствует одному из символов: n
или m
:
>>> p = re.compile(r"красн((ая)|(ое))")
>>> print("Найдено" if p.search("красная") else "Нет")
Найдено
>>> print("Найдено" if p.search("красное") else "Нет")
Найдено
>>> print("Найдено" if p.search("красный") else "Нет")
Нет
Вместо указания символов можно использовать стандартные классы:

\d
— соответствует любой цифре. При указании флага
A
(
ASCII
) эквивалентно
[0-9]
;

\w
— соответствует любой букве, цифре или символу подчеркивания. При указании фла- га
A
(
ASCII
) эквивалентно
[a-zA-Z0-9_]
;

\s
— любой пробельный символ. При указании флага
A
(
ASCII
) эквивалентно
[\t\n\r\f\v]
;

\D
— не цифра. При указании флага
A
(
ASCII
) эквивалентно
[^0-9]
;

\W
— не буква, не цифра и не символ подчеркивания. При указании флага
A
(
ASCII
) экви- валентно
[^a-zA-Z0-9_]
;

\S
— не пробельный символ. При указании флага
A
(
ASCII
) эквивалентно
[^\t\n\r\f\v]
П
РИМЕЧАНИЕ
В Python 3 поддержка Unicode в регулярных выражениях установлена по умолчанию. При этом все классы трактуются гораздо шире. Так, класс \d соответствует не только десятич- ным цифрам, но и другим цифрам из кодировки Unicode, — например, дробям, класс \w включает не только латинские буквы, но и любые другие, а класс \s охватывает также не- разрывные пробелы. Поэтому на практике лучше явно указывать символы внутри квадрат- ных скобок, а не использовать классы.
Количество вхождений символа в строку задается с помощью квантификаторов:

{n}
— n
вхождений символа в строку. Например, шаблон r"^[0-9]{2}$"
соответствует двум вхождениям любой цифры;

{n,}
— n
или более вхождений символа в строку. Например, шаблон r"^[0-9]{2,}$"
соответствует двум и более вхождениям любой цифры;

{n,m}
— не менее n
и не более m
вхождений символа в строку. Числа указываются через запятую без пробела. Например, шаблон r"^[0-9]{2,4}$"
соответствует от двух до четырех вхождений любой цифры;

*
— ноль или большее число вхождений символа в строку. Эквивалентно комбинации
{0,}
;

+
— одно или большее число вхождений символа в строку. Эквивалентно комбинации
{1,}
;

?
— ни одного или одно вхождение символа в строку. Эквивалентно комбинации
{0,1}
Все квантификаторы являются «жадными». При поиске соответствия ищется самая длинная подстрока, соответствующая шаблону, и не учитываются более короткие соответствия. Рас- смотрим это на примере и получим содержимое всех тегов

вместе с тегами:
>>> s = "Text1Text2Text3"
>>> p = re.compile(r".*", re.S)

128
Часть I. Основы языка Python
>>> p.findall(s)
['Text1Text2Text3']
Вместо желаемого результата мы получили полностью строку. Чтобы ограничить «жад- ность», необходимо после квантификатора указать символ
?
:
>>> s = "Text1Text2Text3"
>>> p = re.compile(r".*?", re.S)
>>> p.findall(s)
['Text1', 'Text3']
Этот код вывел то, что мы искали. Если необходимо получить содержимое без тегов, то нужный фрагмент внутри шаблона следует разместить внутри круглых скобок:
>>> s = "Text1Text2Text3"
>>> p = re.compile(r"(.*?)", re.S)
>>> p.findall(s)
['Text1', 'Text3']
Круглые скобки часто используются для группировки фрагментов внутри шаблона. В этом случае не требуется, чтобы фрагмент запоминался и был доступен в результатах поиска.
Чтобы избежать захвата фрагмента, следует после открывающей круглой скобки разместить символы
?:
(вопросительный знак и двоеточие):
>>> s = "test text"
>>> p = re.compile(r"([a-z]+((st)|(xt)))", re.S)
>>> p.findall(s)
[('test', 'st', 'st', ''), ('text', 'xt', '', 'xt')]
>>> p = re.compile(r"([a-z]+(?:(?:st)|(?:xt)))", re.S)
>>> p.findall(s)
['test', 'text']
В первом примере мы получили список с двумя элементами. Каждый элемент списка явля- ется кортежем, содержащим четыре элемента. Все эти элементы соответствуют фрагмен- там, заключенным в шаблоне в круглые скобки. Первый элемент кортежа содержит фраг- мент, расположенный в первых круглых скобках, второй — во вторых круглых скобках и т. д. Три последних элемента кортежа являются лишними. Чтобы они не выводились в результатах, мы добавили символы
?:
после каждой открывающей круглой скобки. В ре- зультате список состоит только из фрагментов, полностью соответствующих регулярному выражению.
К найденному фрагменту в круглых скобках внутри шаблона можно обратиться с помощью механизма обратных ссылок. Для этого порядковый номер круглых скобок в шаблоне ука- зывается после слэша, например, так:
\1
. Нумерация скобок внутри шаблона начинается с
1
Для примера получим текст между одинаковыми парными тегами:
>>> s = "Text1Text2Text3Text4"
>>> p = re.compile(r"<([a-z]+)>(.*?)\1>", re.S | re.I)
>>> p.findall(s)
[('b', 'Text1'), ('I', 'Text3'), ('b', 'Text4')]
Фрагментам внутри круглых скобок можно дать имена, создав тем самым именованные фрагменты. Для этого после открывающей круглой скобки следует указать комбинацию символов
?P
. В качестве примера разберем e-mail на составные части:

Глава 7. Регулярные выражения
129
>>> email = "test@mail.ru"
>>> p = re.compile(r"""(?P[a-z0-9_.-]+) # Название ящика
@ # Символ "@"
(?P
1   ...   8   9   10   11   12   13   14   15   ...   83

(?:[a-z0-9-]+\.)+[a-z]{2,6}) # Домен """, re.I | re.VERBOSE)
>>> r = p.search(email)
>>> r.group("name") # Название ящика 'test'
>>> r.group("host") # Домен 'mail.ru'
Чтобы внутри шаблона обратиться к именованным фрагментам, используется следующий синтаксис:
(?P=name)
. Для примера получим текст между одинаковыми парными тегами:
>>> s = "Text1Text2Text3"
>>> p = re.compile(r"<(?P[a-z]+)>(.*?)(?P=tag)>", re.S | re.I)
>>> p.findall(s)
[('b', 'Text1'), ('I', 'Text3')]
Кроме того, внутри круглых скобок могут быть расположены следующие конструкции:

(?#...)
— комментарий. Текст внутри круглых скобок игнорируется;

(?=...)
— положительный просмотр вперед. Выведем все слова, после которых распо- ложена запятая:
>>> s = "text1, text2, text3 text4"
>>> p = re.compile(r"\w+(?=[,])", re.S | re.I)
>>> p.findall(s)
['text1', 'text2']

(?!...)
— отрицательный просмотр вперед. Выведем все слова, после которых нет запятой:
>>> s = "text1, text2, text3 text4"
>>> p = re.compile(r"[a-z]+[0-9](?![,])", re.S | re.I)
>>> p.findall(s)
['text3', 'text4']

(?<=...)
— положительный просмотр назад. Выведем все слова, перед которыми распо- ложена запятая с пробелом:
>>> s = "text1, text2, text3 text4"
>>> p = re.compile(r"(?<=[,][ ])[a-z]+[0-9]", re.S | re.I)
>>> p.findall(s)
['text2', 'text3']

(?
— отрицательный просмотр назад. Выведем все слова, перед которыми распо- ложен пробел, но перед пробелом нет запятой:
>>> s = "text1, text2, text3 text4"
>>> p = re.compile(r"(?
>>> p.findall(s)
['text4']

(?(id или name)шаблон1|шаблон2)
— если группа с номером или названием найдена, то должно выполняться условие из параметра шаблон1
, в противном случае должно выпол-

130
Часть I. Основы языка Python няться условие из параметра шаблон2
. Выведем все слова, которые расположены внутри апострофов. Если перед словом нет апострофа, то в конце слова должна быть запятая:
>>> s = "text1 'text2' 'text3 text4, text5"
>>> p = re.compile(r"(')?([a-z]+[0-9])(?(1)'|,)", re.S | re.I)
>>> p.findall(s)
[("'", 'text2'), ('', 'text4')]

(?aiLmsux)
— позволяет установить опции регулярного выражения. Буквы a
, i
,
L
, m
, s
, u
и x
имеют такое же назначение, что и одноименные модификаторы в функции compile()
В
НИМАНИЕ
!
Начиная с Python 3.6, опции, задаваемые внутри регулярного выражения в круглых скобках, объявлены устаревшими и не рекомендованными к использованию. В будущих версиях
Python их поддержка будет удалена.
Рассмотрим небольшой пример. Предположим, необходимо получить все слова, располо- женные после дефиса, причем перед дефисом и после слов должны следовать пробельные символы:
>>> s = "-word1 -word2 -word3 -word4 -word5"
>>> re.findall(r"\s\-([a-z0-9]+)\s", s, re.S | re.I)
['word2', 'word4']
Как видно из примера, мы получили только два слова вместо пяти. Первое и последнее сло- ва не попали в результат, т. к. расположены в начале и в конце строки. Чтобы эти слова по- пали в результат, необходимо добавить альтернативный выбор
(^|\s)
— для начала строки и
(\s|$)
— для конца строки. Чтобы найденные выражения внутри круглых скобок не по- пали в результат, следует добавить символы
?:
после открывающей скобки:
>>> re.findall(r"(?:^|\s)\-([a-z0-9]+)(?:\s|$)", s, re.S | re.I)
['word1', 'word3', 'word5']
Здесь первое и последнее слова успешно попали в результат. Почему же слова word2
и word4 не попали в список совпадений — ведь перед дефисом есть пробел и после слова есть про- бел? Чтобы понять причину, рассмотрим поиск по шагам. Первое слово успешно попадает в результат, т. к. перед дефисом расположено начало строки и после слова есть пробел. По- сле поиска указатель перемещается, и строка для дальнейшего поиска примет следующий вид:
"-word1 <Указатель>-word2 -word3 -word4 -word5"
Обратите внимание на то, что перед фрагментом
-word2
больше нет пробела, и дефис не расположен в начале строки. Поэтому следующим совпадением окажется слово word3
, и указатель снова будет перемещен:
"-word1 -word2 -word3 <Указатель>-word4 -word5"
Опять перед фрагментом
-word4
нет пробела, и дефис не расположен в начале строки. По- этому следующим совпадением окажется слово word5
, и поиск будет завершен. Таким обра- зом, слова word2
и word4 не попадают в результат, поскольку пробел до фрагмента уже был использован в предыдущем поиске. Чтобы этого избежать, следует воспользоваться поло- жительным просмотром вперед
(?=...)
:
>>> re.findall(r"(?:^|\s)\-([a-z0-9]+)(?=\s|$)", s, re.S | re.I)
['word1', 'word2', 'word3', 'word4', 'word5']

Глава 7. Регулярные выражения
131
В этом примере мы заменили фрагмент
(?:\s|$)
на
(?=\s|$)
. Поэтому все слова успешно попали в список совпадений.
7.2. Поиск первого совпадения с шаблоном
Для поиска первого совпадения с шаблоном предназначены следующие функции и методы:
match()
— проверяет соответствие с началом строки. Формат метода: match(<Строка>[, <Начальная позиция>[, <Конечная позиция>]])
Если соответствие найдено, возвращается объект
Match
, в противном случае — значение
None
:
>>> import re
>>> p = re.compile(r"[0-9]+")
>>> print("Найдено" if p.match("str123") else "Нет")
Нет
>>> print("Найдено" if p.match("str123", 3) else "Нет")
Найдено
>>> print("Найдено" if p.match("123str") else "Нет")
Найдено
Вместо метода match()
можно воспользоваться функцией match()
. Формат функции: re.match(<Шаблон>, <Строка>[, <Модификатор>])
В параметре
<Шаблон>
указывается строка с регулярным выражением или скомпилиро- ванное регулярное выражение. В параметре
<Модификатор>
можно указать флаги, ис- пользуемые в функции compile()
. Если соответствие найдено, то возвращается объект
Match
, в противном случае — значение
None
:
>>> p = r"[0-9]+"
>>> print("Найдено" if re.match(p, "str123") else "Нет")
Нет
>>> print("Найдено" if re.match(p, "123str") else "Нет")
Найдено
>>> p = re.compile(r"[0-9]+")
>>> print("Найдено" if re.match(p, "123str") else "Нет")
Найдено
search()
— проверяет соответствие с любой частью строки. Формат метода: search(<Строка>[, <Начальная позиция>[, <Конечная позиция>]])
Если соответствие найдено, возвращается объект
Match
, в противном случае — значение
None
:
>>> p = re.compile(r"[0-9]+")
>>> print("Найдено" if p.search("str123") else "Нет")
Найдено
>>> print("Найдено" if p.search("123str") else "Нет")
Найдено
>>> print("Найдено" if p.search("123str", 3) else "Нет")
Нет
Вместо метода search()
можно воспользоваться функцией search()
. Формат функции: re.search(<Шаблон>, <Строка>[, <Модификатор>])

132
Часть I. Основы языка Python
В параметре
<Шаблон>
указывается строка с регулярным выражением или скомпилиро- ванное регулярное выражение. В параметре
<Модификатор>
можно указать флаги, ис- пользуемые в функции compile()
. Если соответствие найдено, возвращается объект
Match
, в противном случае — значение
None
:
>>> p = r"[0-9]+"
>>> print("Найдено" if re.search(p, "str123") else "Нет")
Найдено
>>> p = re.compile(r"[0-9]+")
>>> print("Найдено" if re.search(p, "str123") else "Нет")
Найдено
fullmatch()
— выполняет проверку, соответствует ли переданная строка регулярному выражению целиком. Формат метода: fullmatch(<Строка>[, <Начальная позиция>[, <Конечная позиция>]])
Если соответствие найдено, то возвращается объект
Match
, в противном случае — значе- ние
None
:
>>> p = re.compile("[Pp]ython")
>>> print("Найдено" if p.fullmatch("Python") else "Нет")
Найдено
>>> print("Найдено" if p.fullmatch("py") else "Нет")
Нет
>>> print("Найдено" if p.fullmatch("PythonWare") else "Нет")
Нет
>>> print("Найдено" if p.fullmatch("PythonWare", 0, 6) else "Нет")
Найдено
Вместо метода fullmatch()
можно воспользоваться функцией fullmatch()
. Формат функции: re.fullmatch(<Шаблон>, <Строка>[, <Модификатор>])
В параметре
<Шаблон>
указывается строка с регулярным выражением или скомпилиро- ванное регулярное выражение. В параметре
<Модификатор>
можно указать флаги, используемые в функции compile()
. Если строка полностью совпадает с шаблоном, воз- вращается объект
Match
, в противном случае — значение
None
:
>>> p = "[Pp]ython"
>>> print("Найдено" if re.fullmatch(p, "Python") else "Нет")
Найдено
>>> print("Найдено" if re.fullmatch(p, "py") else "Нет")
Нет
В качестве примера переделаем нашу программу суммирования произвольного количества целых чисел, введенных пользователем (см. листинг 4.12), таким образом, чтобы при вводе строки вместо числа программа не завершалась с фатальной ошибкой. Предусмотрим также возможность ввода отрицательных целых чисел (листинг 7.5).
Листинг 7.5. Суммирование произвольного количества чисел
# -*- coding: utf-8 -*- import re print("Введите слово 'stop' для получения результата") summa = 0

Глава 7. Регулярные выражения
133 p = re.compile(r"^[-]?[0-9]+$", re.S) while True: x = input("Введите число: ") if x == "stop": break # Выход из цикла if not p.search(x): print("Необходимо ввести число, а не строку!") continue # Переходим на следующую итерацию цикла x = int(x) # Преобразуем строку в число summa += x print("Сумма чисел равна:", summa) input()
Объект
Match
, возвращаемый методами (функциями) match()
, search()
и fullmatch()
,
име- ет следующие атрибуты и методы:
re
— ссылка на скомпилированный шаблон, указанный в методах (функциях) match()
, search()
и fullmatch()
. Через эту ссылку доступны следующие атрибуты:
• groups
— количество групп в шаблоне;
• groupindex
— словарь с названиями групп и их номерами;
• pattern
— исходная строка с регулярным выражением;
• flags
— комбинация флагов, заданных при создании регулярного выражения в функции compile()
, и флагов, указанных в самом регулярном выражении, в конст- рукции
(?aiLmsux)
;
string
— значение параметра
<Строка>
в методах (функциях) match()
, search()
и fullmatch()
;
pos
— значение параметра
<Начальная позиция>
в методах match()
, search()
и fullmatch()
;
endpos
— значение параметра
<Конечная позиция>
в методах match()
, search()
и fullmatch()
;
lastindex
— возвращает номер последней группы или значение
None
, если поиск завер- шился неудачей;
lastgroup
— возвращает название последней группы или значение
None
, если эта группа не имеет имени или поиск завершился неудачей:
>>> p = re.compile(r"(?P[0-9]+)(?P[a-z]+)")
>>> m = p.search("123456string 67890text")
>>> m
<_sre.SRE_Match object at 0x00FC9DE8>
>>> m.re.groups, m.re.groupindex
(2, {'num': 1, 'str': 2})
>>> p.groups, p.groupindex
(2, {'num': 1, 'str': 2})
>>> m.string
'123456string 67890text'
>>> m.lastindex, m.lastgroup
(2, 'str')
>>> m.pos, m.endpos
(0, 22)

134
Часть I. Основы языка Python
group([[, ..., ]])
— возвращает фрагменты, соответ- ствующие шаблону. Если параметр не задан или указано значение
0
, возвращается фрагмент, полностью соответствующий шаблону. Если указан номер или название груп- пы, возвращается фрагмент, совпадающий с этой группой. Через запятую можно указать несколько номеров или названий групп — в этом случае возвращается кортеж, содер- жащий фрагменты, что соответствует группам. Если нет группы с указанным номером или названием, то возбуждается исключение
IndexError
:
>>> p = re.compile(r"(?P[0-9]+)(?P[a-z]+)")
>>> m = p.search("123456string 67890text")
>>> m.group(), m.group(0) # Полное соответствие шаблону
('123456string', '123456string')
>>> m.group(1), m.group(2) # Обращение по индексу
('123456', 'string')
>>> m.group("num"), m.group("str") # Обращение по названию
('123456', 'string')
>>> m.group(1, 2), m.group("num", "str") # Несколько параметров
(('123456', 'string'), ('123456', 'string'))
groupdict([<Значение по умолчанию>])
— возвращает словарь, содержащий значения именованных групп. С помощью необязательного параметра можно указать значение, которое будет выводиться вместо значения
None для групп, не имеющих совпадений:
>>> p = re.compile(r"(?P[0-9]+)(?P[a-z])?")
>>> m = p.search("123456")
>>> m.groupdict()
{'num': '123456', 'str': None}
>>> m.groupdict("")
{'num': '123456', 'str': ''}
groups([<Значение по умолчанию>])
— возвращает кортеж, содержащий значения всех групп. С помощью необязательного параметра можно указать значение, которое будет выводиться вместо значения
None для групп, не имеющих совпадений:
>>> p = re.compile(r"(?P[0-9]+)(?P[a-z])?")
>>> m = p.search("123456")
>>> m.groups()
('123456', None)
>>> m.groups("")
('123456', '')
start([<Номер или название группы>])
— возвращает индекс начала фрагмента, соот- ветствующего заданной группе. Если параметр не указан, то фрагментом является пол- ное соответствие с шаблоном. Если соответствия нет, возвращается значение
-1
;
end([<Номер или название группы>])
— возвращает индекс конца фрагмента, соответ- ствующего заданной группе. Если параметр не указан, то фрагментом является полное соответствие с шаблоном. Если соответствия нет, возвращается значение
-1
;
span([<Номер или название группы>])
— возвращает кортеж, содержащий начальный и конечный индексы фрагмента, соответствующего заданной группе. Если параметр не указан, то фрагментом является полное соответствие с шаблоном. Если соответствия нет, возвращается значение
(–1, -1)
:

Глава 7. Регулярные выражения
135
>>> p = re.compile(r"(?P[0-9]+)(?P[a-z]+)")
>>> s = "str123456str"
>>> m = p.search(s)
>>> m.start(), m.end(), m.span()
(3, 12, (3, 12))
>>> m.start(1), m.end(1), m.start("num"), m.end("num")
(3, 9, 3, 9)
>>> m.start(2), m.end(2), m.start("str"), m.end("str")
(9, 12, 9, 12)
>>> m.span(1), m.span("num"), m.span(2), m.span("str")
((3, 9), (3, 9), (9, 12), (9, 12))
>>> s[m.start(1):m.end(1)], s[m.start(2):m.end(2)]
('123456', 'str')
expand(<Шаблон>)
— производит замену в строке. Внутри указанного шаблона можно использовать обратные ссылки:
\номер группы
,
\g<номер группы>
и
\g<название группы>
Для примера поменяем два тега местами:
>>> p = re.compile(r"<(?P[a-z]+)><(?P[a-z]+)>")
>>> m = p.search("
1   ...   9   10   11   12   13   14   15   16   ...   83
")
>>> m.expand(r"<\2><\1>") # \номер '

'
>>> m.expand(r"<\g<2>><\g<1>>") # \g<номер>
'

'
>>> m.expand(r"<\g><\g>") # \g<название>
'

'
В качестве примера использования метода search()
проверим на соответствие шаблону введенный пользователем адрес электронной почты (листинг 7.6).
Листинг 7.6. Проверка e-mail на соответствие шаблону
# -*- coding: utf-8 -*- import re email = input("Введите e-mail: ") pe = r"^([a-z0-9_.-]+)@(([a-z0-9-]+\.)+[a-z]{2,6})$" p = re.compile(pe, re.I | re.S) m = p.search(email) if not m: print("E-mail не соответствует шаблону") else: print("E-mail", m.group(0), "соответствует шаблону") print("ящик:", m.group(1), "домен:", m.group(2)) input()
Результат выполнения (введенное пользователем значение выделено полужирным шриф- том):
Введите e-mail: user@mail.ru
E-mail user@mail.ru соответствует шаблону ящик: user домен: mail.ru

136
Часть I. Основы языка Python
7.3. Поиск всех совпадений с шаблоном
Для поиска всех совпадений с шаблоном предназначено несколько функций и методов.

Метод findall()
ищет все совпадения с шаблоном. Формат метода: findall(<Строка>[, <Начальная позиция>[, <Конечная позиция>]])
Если соответствия найдены, возвращается список с фрагментами, в противном случае возвращается пустой список. Если внутри шаблона есть более одной группы, то каждый элемент списка будет кортежем, а не строкой:
>>> import re
>>> p = re.compile(r"[0-9]+")
>>> p.findall("2007, 2008, 2009, 2010, 2011")
['2007', '2008', '2009', '2010', '2011']
>>> p = re.compile(r"[a-z]+")
>>> p.findall("2007, 2008, 2009, 2010, 2011")
[]
>>> t = r"(([0-9]{3})-([0-9]{2})-([0-9]{2}))"
>>> p = re.compile(t)
>>> p.findall("322-77-20, 528-22-98")
[('322-77-20', '322', '77', '20'),
('528-22-98', '528', '22', '98')]

Вместо метода findall()
можно воспользоваться функцией findall()
. Формат функции: re.findall(<Шаблон>, <Строка>[, <Модификатор>])
В параметре
<Шаблон>
указывается строка с регулярным выражением или скомпилиро- ванное регулярное выражение. В параметре
<Модификатор>
можно указать флаги, ис- пользуемые в функции compile()
:
>>> re.findall(r"[0-9]+", "1 2 3 4 5 6")
['1', '2', '3', '4', '5', '6']
>>> p = re.compile(r"[0-9]+")
>>> re.findall(p, "1 2 3 4 5 6")
['1', '2', '3', '4', '5', '6']

Метод finditer()
аналогичен методу findall()
, но возвращает итератор, а не список.
На каждой итерации цикла возвращается объект
Match
. Формат метода: finditer(<Строка>[, <Начальная позиция>[, <Конечная позиция>]])
Пример:
>>> p = re.compile(r"[0-9]+")
>>> for m in p.finditer("2007, 2008, 2009, 2010, 2011"): print(m.group(0), "start:", m.start(), "end:", m.end())
2007 start: 0 end: 4 2008 start: 6 end: 10 2009 start: 12 end: 16 2010 start: 18 end: 22 2011 start: 24 end: 28

Глава 7. Регулярные выражения
137

Вместо метода finditer()
можно воспользоваться функцией finditer()
. Ее формат: re.finditer(<Шаблон>, <Строка>[, <Модификатор>])
В параметре
<Шаблон>
указывается строка с регулярным выражением или скомпилиро- ванное регулярное выражение. В параметре
<Модификатор>
можно указать флаги, ис- пользуемые в функции compile()
. Получим содержимое между тегами:
>>> p = re.compile(r"(.+?)", re.I | re.S)
>>> s = "Text1Text2Text3"
>>> for m in re.finditer(p, s): print(m.group(1))
Text1
Text3 7.4. Замена в строке
Метод sub()
ищет все совпадения с шаблоном и заменяет их указанным значением. Если совпадения не найдены, возвращается исходная строка. Метод имеет следующий формат: sub(<Новый фрагмент или ссылка на функцию>, <Строка для замены>
[, <Максимальное количество замен>])
Внутри нового фрагмента можно использовать обратные ссылки
\номер группы
,
\g<номер группы>
и
\g<название группы>
. Для примера поменяем два тега местами:
>>> import re
>>> p = re.compile(r"<(?P[a-z]+)><(?P[a-z]+)>")
>>> p.sub(r"<\2><\1>", "
") # \номер '

'
>>> p.sub(r"<\g<2>><\g<1>>", "
") # \g<номер>
'

'
>>> p.sub(r"<\g><\g>", "
") # \g<название>
'

'
В качестве первого параметра можно указать ссылку на функцию. В эту функцию будет передаваться объект
Match
, соответствующий найденному фрагменту. Результат, возвра- щаемый этой функцией, служит фрагментом для замены. Для примера найдем все числа в строке и прибавим к ним число
10
(листинг 7.7).
Листинг 7.7. Поиск чисел в строке
# -*- coding: utf-8 -*- import re def repl(m):
""" Функция для замены. m — объект Match """ x = int(m.group(0)) x += 10 return "{0}".format(x) p = re.compile(r"[0-9]+")
# Заменяем все вхождения print(p.sub(repl, "2008, 2009, 2010, 2011"))

138
Часть I. Основы языка Python
# Заменяем только первые два вхождения print(p.sub(repl, "2008, 2009, 2010, 2011", 2)) input()
Результат выполнения:
2018, 2019, 2020, 2021 2018, 2019, 2010, 2011
В
НИМАНИЕ
!
Название функции указывается без круглых скобок.
Вместо метода sub()
можно воспользоваться функцией sub()
. Формат функции: re.sub(<Шаблон>, <Новый фрагмент или ссылка на функцию>,
<Строка для замены>[, <Максимальное количество замен>
[, flags=0]])
В качестве параметра
<Шаблон>
можно указать строку с регулярным выражением или ском- пилированное регулярное выражение. Для примера поменяем два тега местами, а также изменим регистр букв (листинг 7.8).
Листинг 7.8. Перестановка тегов с изменением регистра букв
# -*- coding: utf-8 -*- import re def repl(m):
""" Функция для замены. m — объект Match """ tag1 = m.group("tag1").upper() tag2 = m.group("tag2").upper() return "<{0}><{1}>".format(tag2, tag1) p = r"<(?P[a-z]+)><(?P[a-z]+)>" print(re.sub(p, repl, "
1>2>1>2>
1   ...   10   11   12   13   14   15   16   17   ...   83

Смотрите также файлы