ээдд. Прохоренок_Н_А__Дронов_В_А_Python_3_и_PyQt_5_Разработка_приложен. Николай Прохоренок Владимир Дронов

• Название: Николай Прохоренок Владимир Дронов
• Дата: 05.05.2023
• Размер: 7.92 Mb.
• Имя файла: Прохоренок_Н_А__Дронов_В_А_Python_3_и_PyQt_5_Разработка_приложен.pdf
• Тип: Документы; #1111379
• страница: 11 из 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