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

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

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

Содержание

Обработка строк

В следующих разделах описаны операторы, методы и функции, доступные для работы со строками.

Операторы строк

Вы уже видели операторы + и *, применяемые к числовым операндам в уроке по операторам и выражениям в Python. Эти два оператора могут быть применены и к строкам.

Оператор +

Оператор + объединяет строки. Он возвращает строку, состоящую из операндов, соединенных вместе, как показано здесь:

>>> s = 'foo'
>>> t = 'bar'
>>> u = 'baz'

>>> s + t
'foobar'
>>> s + t + u
'foobarbaz'

>>> print('Go team' + '!!!')
Go team!!!

Оператор *

Оператор * создает несколько копий строки. Если s-строка, а n-целое число, то любое из следующих выражений возвращает строку, состоящую из n сцепленных копий s:

s * n
n * s

Вот примеры обеих форм:

>>> s = 'foo.'

>>> s * 4
'foo.foo.foo.foo.'
>>> 4 * s
'foo.foo.foo.foo.'

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

>>> 'foo' * -8
''

Если бы вы создали строковую переменную и инициализировали ее пустой строкой, присвоив ей значение 'foo' * -8, любой справедливо подумал бы, что вы немного глупы. Но это сработает.

Оператор in

Python также предоставляет оператор членства, который можно использовать со строками. Оператор in возвращает True, если первый операнд содержится во втором, и False в противном случае:

>>> s = 'foo'

>>> s in 'That\'s food for thought.'
True
>>> s in 'That\'s good for now.'
False

Существует также оператор not in, который делает обратное:

>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False

Встроенные строковые функции

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

Функция Описание
chr() Преобразует целое число в символ
ord() Преобразует символ в целое число
len() Возвращает длину строки
str() Возвращает строковое представление объекта

Они более подробно рассматриваются ниже.

ord(c)

Возвращает целочисленное значение для данного символа.

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

Самая простая схема в обычном использовании называется ASCII. Он охватывает общие латинские символы, с которыми вы, вероятно, больше всего привыкли работать. Для этих символов ord(c) возвращает значение ASCII для символа c:

>>> ord('a')
97
>>> ord('#')
35

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

Unicode — это амбициозный стандарт, который пытается предоставить числовой код для каждого возможного символа, на каждом возможном языке, на каждой возможной платформе. Python 3 широко поддерживает Юникод, включая разрешение символов Юникода в строках.

Пока вы остаетесь в области общих символов, существует небольшая практическая разница между ASCII и Unicode. Но функция ord() также возвращает числовые значения для символов Юникода:

>>> ord('€')
8364
>>> ord('∑')
8721

chr(n)

Возвращает символьное значение для данного целого числа.

chr() делает обратное ord(). При заданном числовом значении n chr(n) возвращает строку, представляющую символ, соответствующий n:

>>> chr(97)
'a'
>>> chr(35)
'#'

chr() также обрабатывает символы Юникода:

>>> chr(8364)
'€'
>>> chr(8721)
'∑'

len(s)

Возвращает длину строки.

С помощью функции len() вы можете проверить длину строки Python. len(s) возвращает количество символов в s:

>>> s = 'I am a string.'
>>> len(s)
14

str(obj)

Возвращает строковое представление объекта.

Практически любой объект в Python может быть представлен в виде строки. str(obj) возвращает строковое представление объекта obj:

>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('foo')
'foo'

Индексация Строк

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

В Python строки-это упорядоченные последовательности символьных данных, и поэтому их можно индексировать таким образом. Доступ к отдельным символам в строке можно получить, указав имя строки, за которым следует число в квадратных скобках ([]).

Индексация строк в Python основана на нуле: первый символ в строке имеет индекс 0, следующий-индекс 1 и так далее. Индекс последнего символа будет равен длине строки минус единица.
Например, схематическое представление индексов строки ‘foobar‘ будет выглядеть следующим образом:

Индексы строк

Отдельные символы могут быть доступны по индексу следующим образом:

>>> s = 'foobar'

>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> len(s)
6
>>> s[len(s)-1]
'r'

Попытка индексировать за пределами конца строки приводит к ошибке:

>>> s[6]
Traceback (most recent call last):
  File " <pyshell#17>", line 1, in  <module> 
    s[6]
IndexError: string index out of range

Строковые индексы также могут быть заданы отрицательными числами, и в этом случае индексация происходит от конца строки назад: -1 относится к последнему символу, -2-к предпоследнему символу и т. д. Вот та же самая диаграмма, показывающая как положительные, так и отрицательные индексы в строке ‘foobar‘:

Положительные и отрицательные индексы строк

Вот несколько примеров негативной индексации:

>>> s = 'foobar'

>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)]
'f'

Попытка индексирования с отрицательными числами за пределами начала строки приводит к ошибке:

>>> s[-7]
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    s[-7]
IndexError: string index out of range

Для любой непустой строки s, s[len(s)-1] и s[-1] оба возвращают последний символ. Нет никакого индекса, который имеет смысл для пустой строки.

Нарезка строк

Python также допускает форму синтаксиса индексирования, которая извлекает подстроки из строки, известную как нарезка строк. Если s является строкой, то выражение вида [m:n] возвращает часть s, начинающуюся с позиции m и вплоть до позиции n, но не включая ее:

>>> s = 'foobar'
>>> s[2:5]
'oba'

Помните: строковые индексы основаны на нуле. Первый символ в строке имеет индекс 0. Это относится как к стандартному индексированию, так и к нарезке.

Опять же, второй индекс указывает первый символ, который не включен в результат—символ ‘r‘ (s[5]) в приведенном выше примере. Это может показаться немного неинтуитивным, но это приводит к такому результату, который имеет смысл: выражение s[m:n] вернет подстроку длиной n - m символов, в данном случае 5 - 2 = 3.

Если вы опустите первый индекс, срез начнется в начале строки. Таким образом, s[:m] и s[0:m] эквивалентны:

>>> s = 'foobar'

>>> s[:4]
'foob'
>>> s[0:4]
'foob'

Аналогично, если вы опустите второй индекс, как в s[n:], срез простирается от первого индекса до конца строки. Это хорошая, лаконичная альтернатива более громоздкому s[n:len(s)]:

>>> s = 'foobar'

>>> s[2:]
'obar'
>>> s[2:len(s)]
'obar'

Для любых строк и любого целого числа n (0 = n = len(s)), s[:n] + s[n:] будет равно s:

>>> s = 'foobar'

>>> s[:4] + s[4:]
'foobar'
>>> s[:4] + s[4:] == s
True

Опущение обоих индексов возвращает исходную строку целиком. Буквально. Это не копия, а ссылка на исходную строку:

>>> s = 'foobar'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
True

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

>>> s[2:2]
''
>>> s[4:2]
''

Отрицательные индексы также могут быть использованы при нарезке. -1 относится к последнему символу, -2-к предпоследнему и так далее, как и в случае простого индексирования. На приведенной ниже диаграмме показано, как срезать подстроку «oob«из строки «foobar«, используя как положительные, так и отрицательные индексы:

Нарезка строк с положительными и отрицательными индексами

Вот соответствующий код Python:

>>> s = 'foobar'

>>> s[-5:-2]
'oob'
>>> s[1:4]
'oob'
>>> s[-5:-2] == s[1:4]
True

Указание шага в срезе строки

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

Например, для строки ‘foobar‘ фрагмент 0:6:2 начинается с первого символа и заканчивается последним символом (целой строкой), а каждый второй символ пропускается. Это показано на следующей диаграмме:

Индексирование строки с шагом

Аналогично, 1:6:2 задает срез, начинающийся со второго символа (индекс 1) и заканчивающийся последним символом, и снова значение шага 2 вызывает пропуск всех остальных символов:

Еще одно индексирование с шагом

Иллюстративный REPL код показан здесь:

>>> s = 'foobar'

>>> s[0:6:2]
'foa'

>>> s[1:6:2]
'obr'

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

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'

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

>>> s = 'foobar'
>>> s[5:0:-2]
'rbo'

В приведенном выше примере 5:0:-2 означает “начать с последнего символа и отступить назад на 2, вплоть до первого символа, но не включая его.”

Когда вы отступаете назад, если первый и второй индексы опущены, значения по умолчанию меняются интуитивно: первый индекс по умолчанию находится в конце строки, а второй индекс по умолчанию-в начале. Вот вам пример:

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::-5]
'55555'

Это обычная парадигма для обращения строки вспять:

>>> s = 'If Comrade Napoleon says it, it must be right.'
>>> s[::-1]
'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'

Интерполяция переменных в строку

В Python версии 3.6 был введен новый механизм форматирования строк. Эта функция формально называется форматированным строковым литералом, но чаще всего упоминается под псевдонимом f-string.

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

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

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('The product of', n, 'and', m, 'is', prod)
The product of 20 and 25 is 500

Но это слишком громоздко. Чтобы сделать то же самое, используйте f-строку:

  • Укажите либо нижний регистр f либо верхний регистр F непосредственно перед открывающей кавычкой строкового литерала. Это говорит Python, что это f-строка вместо стандартной строки.
  • Укажите любые переменные, которые будут интерполированы в фигурных скобках ({}).

Переделанный с помощью f-строки, приведенный выше пример выглядит гораздо чище:

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'The product of {n} and {m} is {prod}')
The product of 20 and 25 is 500

Любой из трех механизмов цитирования Python может быть использован для определения f-строки:

>>> var = 'Bark'

>>> print(f'A dog says {var}!')
A dog says Bark!
>>> print(f"A dog says {var}!")
A dog says Bark!
>>> print(f'''A dog says {var}!''')
A dog says Bark!

Изменение Строк

Короче говоря, вы не можете. Строки-это один из типов данных, которые Python считает неизменяемыми, то есть не подлежащими изменению. Фактически, все типы данных, которые вы видели до сих пор, неизменны. (Python предоставляет типы данных, которые являются изменяемыми, как вы скоро увидите.)

Подобное утверждение приведет к ошибке:

>>> s = 'foobar'
>>> s[3] = 'x'
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    s[3] = 'x'
TypeError: 'str' object does not support item assignment

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

>>> s = s[:3] + 'x' + s[4:]
>>> s
'fooxar'

Для этого также существует встроенный строковый метод:

>>> s = 'foobar'
>>> s = s.replace('b', 'x')
>>> s
'fooxar'

Читайте дальше для получения дополнительной информации о встроенных строковых методах!

Встроенные строковые методы

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

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

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

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

obj.foo(<args>)

Это вызывает метод .foo() на объекте obj.<args> указывает аргументы, передаваемые методу (если таковые имеются).

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

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

Преобразования Регистра

Методы этой группы выполняют преобразование регистра в целевой строке.

s.capitalize()

Возвращает целевую строку с заглавной первой буквой.

s.capitalize() возвращает копию s с первым символом, преобразованным в верхний регистр, и всеми остальными символами, преобразованными в нижний регистр:

>>> s = 'foO BaR BAZ quX'
>>> s.capitalize()
'Foo bar baz qux'

Неалфавитные символы остаются неизменными:

>>> s = 'foo123#BAR#.'
>>> s.capitalize()
'Foo123#bar#.'

s.lower()

Преобразует буквенные символы в строчные.

s.lower() возвращает копию s со всеми заглавными символами, преобразованными в нижний регистр:

>>> 'FOO Bar 123 baz qUX'.lower()
'foo bar 123 baz qux'

s.swapcase()

Меняет местами регистр буквенных символов.

s.swapcase() возвращает копию s с заглавными буквенными символами, преобразованными в строчные и наоборот:

>>> 'FOO Bar 123 baz qUX'.swapcase()
'foo bAR 123 BAZ Qux'

s.title()

Преобразует целевую строку в » регистр заголовка.”

s.title() возвращает копию s, в которой первая буква каждого слова преобразуется в верхний регистр, а остальные буквы-в нижний:

>>> 'the sun also rises'.title()
'The Sun Also Rises'

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

>>> "what's happened to ted's IBM stock?".title()
"What'S Happened To Ted'S Ibm Stock?"

s.upper()

Преобразует буквенные символы в заглавные.

s.upper() возвращает копию s со всеми буквенными символами, преобразованными в верхний регистр:

>>> 'FOO Bar 123 baz qUX'.upper()
'FOO BAR 123 BAZ QUX'

Найти и заменить

Эти методы предоставляют различные средства поиска целевой строки для указанной подстроки.

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

s.count(<sub>[, <start>[, <end>]])

Подсчитывает вхождения подстроки в целевую строку.

s.count(<sub>) возвращает количество неперекрывающихся вхождений подстроки <sub> в s:

>>> 'foo goo moo'.count('oo')
3

Подсчет ограничен количеством вхождений в подстроку, обозначенную <start> и <end>, если они указаны:

>>> 'foo goo moo'.count('oo', 0, 8)
2

s.endswith(<suffix>[, <start>[, <end>]])

Определяет, заканчивается ли целевая строка заданной подстрокой.

s.endswith(<suffix>) возвращает True, если s заканчивается указанным <suffix>, и False в противном случае:

>>> 'foobar'.endswith('bar')
True
>>> 'foobar'.endswith('baz')
False

Сравнение ограничивается подстрокой, обозначенной <start> и <end>, если они указаны:

>>> 'foobar'.endswith('oob', 0, 4)
True
>>> 'foobar'.endswith('oob', 2, 4)
False

s.find(<sub>[, <start>[, <end>]])

Выполняет поиск в целевой строке заданной подстроки.

Вы можете использовать .find(), чтобы увидеть, содержит ли строка определенную подстроку. s.find(<sub>) возвращает самый низкий индекс в s, где находится подстрока <sub> :

>>> 'foo bar foo baz foo qux'.find('foo')
0

Этот метод возвращает -1, если указанная подстрока не найдена:

>>> 'foo bar foo baz foo qux'.find('grault')
-1

Поиск ограничен подстрокой, указанной <start> и <end>, если они указаны:

>>> 'foo bar foo baz foo qux'.find('foo', 4)
8
>>> 'foo bar foo baz foo qux'.find('foo', 4, 7)
-1

s.index(<sub>[, <start>[, <end>]])

Выполняет поиск в целевой строке заданной подстроки.

Этот метод идентичен методу .find(), за исключением того, что он вызывает ошибку, если <sub> не найден, а не возвращает -1:

>>> 'foo bar foo baz foo qux'.index('grault')
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    'foo bar foo baz foo qux'.index('grault')
ValueError: substring not found

s.rfind(<sub>[, <start>[, <end>]])

Поиск в целевой строке заданной подстроки, начинающейся в конце.

s.rfind(<sub>) возвращает самый высокий индекс в s, где найдена подстрока <sub> :

>>> 'foo bar foo baz foo qux'.rfind('foo')
16

Как и в случае с .find(), если подстрока не найдена, возвращается -1:

>>> 'foo bar foo baz foo qux'.rfind('grault')
-1

Поиск ограничен подстрокой, указанной <start> и <end>, если они указаны:

>>> 'foo bar foo baz foo qux'.rfind('foo', 0, 14)
8
>>> 'foo bar foo baz foo qux'.rfind('foo', 10, 14)
-1

s.rindex(<sub>[, <start>[, <end>]])

Поиск в целевой строке заданной подстроки, начинающейся в конце.

Этот метод идентичен методу .rfind(), за исключением того, что он вызывает ошибку, если <sub> не найден, а не возвращает -1:

>>> 'foo bar foo baz foo qux'.rindex('grault')
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    'foo bar foo baz foo qux'.rindex('grault')
ValueError: substring not found

s.startswith(<prefix>[, <start>[, <end>]])

Определяет, начинается ли целевая строка с заданной подстроки.

При использовании метода .startswith() s.startswith(<suffix>) возвращает True, если s начинается с указанного <suffix> , и False в противном случае:

>>> 'foobar'.startswith('foo')
True
>>> 'foobar'.startswith('bar')
False

Сравнение ограничивается подстрокой, обозначенной <start> и <end>, если они указаны:

>>> 'foobar'.startswith('bar', 3)
True
>>> 'foobar'.startswith('bar', 3, 2)
False

Классификация Символов

Методы этой группы классифицируют строку на основе содержащихся в ней символов.

s.isalnum()

Определяет, состоит ли целевая строка из буквенно-цифровых символов.

s.isalnum() возвращает True, если s непусто и все его символы являются буквенно-цифровыми(либо буквой, либо цифрой), и False в противном случае:

>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False

s.isalpha()

Определяет, состоит ли целевая строка из буквенных символов.

s.isalpha() возвращает True, если s непусто и все его символы алфавитны, и False в противном случае:

>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False

s.isdigit()

Определяет, состоит ли целевая строка из цифровых символов.

Вы можете использовать метод .isdigit(), чтобы проверить, состоит ли ваша строка только из цифр. s.isdigit() возвращает True, если s непусто и все его символы являются числовыми цифрами, и False в противном случае:

>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False

s.isidentifier()

Определяет, является ли целевая строка допустимым идентификатором Python.

s.isidentifier() возвращает True, если s является допустимым идентификатором Python в соответствии с определением языка, и False в противном случае:

>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False

Примечание: .isidentifier() вернет True для строки, которая соответствует ключевому слову Python, даже если это на самом деле не является допустимым идентификатором:

>>> 'and'.isidentifier()
True

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

>>> from keyword import iskeyword
>>> iskeyword('and')
True

Если вы действительно хотите убедиться, что строка будет служить допустимым идентификатором Python, вы должны проверить, что .isidentifier() является истинным, а iskeyword() — ложным.

s.islower()

Определяет, являются ли буквенные символы целевой строки строчными.

s.islower() возвращает True, если s непусто и все содержащиеся в нем буквенные символы строчные, и False в противном случае. Неалфавитные символы игнорируются:

>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False

s.isprintable()

Определяет, состоит ли целевая строка полностью из печатаемых символов.

s.isprintable() возвращает True, если s пуст или все содержащиеся в нем буквенные символы доступны для печати. Он возвращает False, если s содержит хотя бы один непечатаемый символ. Неалфавитные символы игнорируются:

>>> 'a\tb'.isprintable()
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'a\nb'.isprintable()
False

Примечание: Только метод .isxxxx() возвращает True, если s является пустой строкой. Все остальные возвращают False для пустой строки.

s.isspace()

Определяет, состоит ли целевая строка из пробельных символов.

s.isspace() возвращает True, если s непусто и все символы являются пробелами, и False в противном случае.

Наиболее часто встречающимися пробелами являются пробел ‘ ‘, табуляция ‘\t‘ и новая строка ‘\n‘:

>>> ' \t \n '.isspace()
True
>>> '   a   '.isspace()
False

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

>>> '\f\u2005\r'.isspace()
True

s.istitle()

Определяет, является ли целевая строка заголовком.

s.istitle() возвращает True, если s непусто, первый буквенный символ каждого слова прописной, а все остальные буквенные символы в каждом слове строчные. В противном случае он возвращает False:

>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True

Примечание: вот как документация Python описывает .istitle(), если вы находите это более интуитивно понятным: “заглавные символы могут следовать только за несокращенными символами, а строчные-только за прописными.”

s.isupper()

Определяет, являются ли буквенные символы целевой строки заглавными.

s.isupper() возвращает True, если s непусто и все содержащиеся в нем буквенные символы заглавные, и False в противном случае. Неалфавитные символы игнорируются:

>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False

Форматирование Строк

Методы этой группы изменяют или улучшают формат строки.

s.center(<width>[, <fill>])

Центрирует строку в поле.

s.center(<width>) возвращает строку, состоящую из s, центрированных в поле width <width&gt;. По умолчанию заполнение состоит из символа пробела ASCII:

>>> 'foo'.center(10)
'   foo    '

Если указан необязательный аргумент <fill>, то он используется в качестве символа заполнения:

>>> 'bar'.center(10, '-')
'---bar----'

Если аргумент уже имеет длину не менее <width>, то он возвращается без изменений:

>>> 'foo'.center(2)
'foo'

s.expandtabs(tabsize=8)

Разворачивает столбцы в строку.

s.expandtabs() заменяет каждый символ табуляции (‘\t‘) пробелами. По умолчанию пробелы заполняются при условии остановки табуляции в каждом восьмом столбце:

>>> 'a\tb\tc'.expandtabs()
'a       b       c'
>>> 'aaa\tbbb\tc'.expandtabs()
'aaa     bbb     c'

tabsize является необязательным параметром, определяющим остановку колонны:

>>> 'a\tb\tc'.expandtabs(4)
'a   b   c'
>>> 'aaa\tbbb\tc'.expandtabs(tabsize=4)
'aaa bbb c'

s.ljust(<width>[, <fill>])

Левостороннее выравнивание строки в поле.

s.ljust(<width>) возвращает строку, состоящую из s, выровненных по левому краю в поле ширина <width>. По умолчанию заполнение состоит из символа пробела ASCII:

>>> 'foo'.ljust(10)
'foo       '

Если указан необязательный аргумент <fill>, то он используется в качестве символа заполнения:

>>> 'foo'.ljust(10, '-')
'foo-------'

Если s уже достигает ширины такой как <width>, то он возвращается без изменений:

>>> 'foo'.ljust(2)
'foo'

s.lstrip([<chars>])

Обрезает ведущие символы из строки.

s.lstrip() возвращает копию s с любыми пробелами, удаленными с левого конца:

>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> '\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz'

Если указан необязательный аргумент <chars>, то это строка, указывающая набор удаляемых символов:

>>> 'http://www.realpython.com'.lstrip('/:pth')
'www.realpython.com'

s.replace(<old>, <new>[, <count>])

Заменяет вхождения подстроки в строке.

В Python для удаления символа из строки можно использовать метод string.replace(). Метод s.replace(<old>, <new>) возвращает копию s со всеми вхождениями подстроки <old>, замененной на <new>.:

>>> 'foo bar foo baz foo qux'.replace('foo', 'grault')
'grault bar grault baz grault qux'

Если указан необязательный аргумент <count>, то выполняется максимум замен <count>, начиная с левого конца s:

>>> 'foo bar foo baz foo qux'.replace('foo', 'grault', 2)
'grault bar grault baz foo qux'

s.rjust(<width>[, <fill>])

Правостороннее выравнивание строки в поле.

s.rjust(<width>) возвращает строку, состоящую из s, выровненных по правому краю в поле ширины <width>. По умолчанию заполнение состоит из символа пробела ASCII:

>>> 'foo'.rjust(10)
'       foo'

Если указан необязательный аргумент <fill>, то он используется в качестве символа заполнения:

>>> 'foo'.rjust(10, '-')
'-------foo'

Если s уже по крайней мере равен <width>, то он возвращается без изменений:

>>> 'foo'.rjust(2)
'foo'

s.rstrip([<chars>])

Обрезает конечные символы из строки.

s.rstrip() возвращает копию s с любыми пробелами, удаленными с правого конца:

>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'foo\t\nbar\t\nbaz\t\n'.rstrip()
'foo\t\nbar\t\nbaz'

Если указан необязательный аргумент <chars>, то это строка, указывающая набор удаляемых символов:

>>> 'foo.$$$;'.rstrip(';$.')
'foo'

s.strip([<chars>])

Удаляет символы с левого и правого концов строки.

s.strip() по существу эквивалентен вызову s.lstrip() и s.rstrip() последовательно. Без аргумента <chars> он удаляет начальные и конечные пробелы:

>>> s = '   foo bar baz\t\t\t'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'

Как и в случае с .lstrip() и .rstrip(), необязательный аргумент <chars> указывает набор удаляемых символов:

>>> 'www.realpython.com'.strip('w.moc')
'realpython'

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

>>> '   foo bar baz\t\t\t'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar baz\t\t\t'.strip()
'foo bar baz'

>>> 'www.realpython.com'.lstrip('w.moc').rstrip('w.moc')
'realpython'
>>> 'www.realpython.com'.strip('w.moc')
'realpython'

s.zfill(<width>)

Подкладывает строку слева нулями.

s.zfill(<width>) возвращает копию s, заполненную слева символами ‘0‘ до указанной <width>:

>>> '42'.zfill(5)
'00042'

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

>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'

Если s уже по крайней мере равен <width>, то он возвращается без изменений:

>>> '-42'.zfill(3)
'-42'

.zfill() наиболее полезен для строковых представлений чисел, но Python все равно будет обнулять строку, которая не является таковой.:

>>> 'foo'.zfill(6)
'000foo'

Преобразование между строками и списками

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

Многие из этих методов возвращают либо список, либо кортеж. Это составные типы данных, которые являются прототипическими примерами итерируемые объекты в Python. Они описаны в следующем уроке, так что вы скоро узнаете о них! До тех пор просто думайте о них как о последовательностях значений. Список заключен в квадратные скобки ([]), а кортеж-в круглые скобки (()).

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

s.join(<iterable>)

Конкатенация строк из итерируемого объекта.

s.join(<iterable>) возвращает строку, полученную в результате объединения объектов в <iterable>, разделенных s.

Обратите внимание, что .join() вызывается на s, строке-разделителе. <iterable> также должна быть последовательностью строковых объектов.

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

>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'

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

В следующем примере <iterable> задается как одно строковое значение. Когда строковое значение используется в качестве итеративного, оно интерпретируется как список отдельных символов строки:

>>> list('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'.join('corge')
'c:o:r:g:e'

Таким образом, в результате ‘:.join('corge') получается строка, состоящая из каждого символа в ‘corge‘, разделенного ‘:‘.

Этот пример терпит неудачу, потому что один из объектов в <iterable> не является строкой:

>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    '---'.join(['foo', 23, 'bar'])
TypeError: sequence item 1: expected str instance, int found

Это можно исправить с помощью:

>>> '---'.join(['foo', str(23), 'bar'])
'foo---23---bar'

Скоро увидите, многие составные объекты в Python могут быть истолкованы как итеративные, и .join() особенно полезен для создания строк из них.

s.partition(<sep>)

Делит строку на основе разделителя.

s.partition(<sep>) разбивает s при первом вхождении строки <sep>. Возвращаемое значение представляет собой кортеж из трех частей, состоящий из:

  • Часть s, предшествующая <sep>
  • Сам <sep>
  • Часть s, следующая за <sep>

Вот несколько примеров .partition() в действии:

>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

Если <sep> не найден в s, возвращаемый кортеж содержит s, за которым следуют две пустые строки:

>>> 'foo.bar'.partition('@@')
('foo.bar', '', '')

s.rpartition(<sep>)

Делит строку на основе разделителя.

s.rpartition(<sep>) функционирует точно так же, как s.partition(<sep>), за исключением того, что s разделяется при последнем вхождении <sep> вместо первого вхождения:

>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

>>> 'foo@@bar@@baz'.rpartition('@@')
('foo@@bar', '@@', 'baz')

s.rsplit(sep=None, maxsplit=-1)

Разбивает строку на список подстрок.

Без аргументов s.split() разбивает s на подстроки, разделенные любой последовательностью пробелов, и возвращает подстроки в виде списка:

>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foo\n\tbar   baz\r\fqux'.rsplit()
['foo', 'bar', 'baz', 'qux']

Если указан <sep>, то он используется в качестве разделителя для разделения:

>>> 'foo.bar.baz.qux'.rsplit(sep='.')
['foo', 'bar', 'baz', 'qux']

(Если <sep> задано со значением None, строка разделяется пробелом, как если бы <sep> вообще не было задано.)

Когда <sep> явно задан в качестве разделителя, предполагается, что последовательные разделители в s разделяют пустые строки, которые будут возвращены:

>>> 'foo...bar'.rsplit(sep='.')
['foo', '', '', 'bar']

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

>>> 'foo\t\t\tbar'.rsplit()
['foo', 'bar']

Если указан необязательный параметр ключевого слова <maxsplit>, то выполняется максимум такое количество разбиений, начиная с правого конца s:

>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=1)
['www.realpython', 'com']

Значение по умолчанию для <maxsplit> равно -1, что означает, что должны быть выполнены все возможные разбиения— так же, как если бы <maxsplit> был полностью опущен:

>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=-1)
['www', 'realpython', 'com']
>>> 'www.realpython.com'.rsplit(sep='.')
['www', 'realpython', 'com']

s.split(sep=None, maxsplit=-1)

Разбивает строку на список подстрок.

s.split() ведет себя точно так же, как s.rsplit(), за исключением того, что если задано <maxsplit>, то разбиения отсчитываются с левого конца s, а не с правого:

>>> 'www.realpython.com'.split('.', maxsplit=1)
['www', 'realpython.com']
>>> 'www.realpython.com'.rsplit('.', maxsplit=1)
['www.realpython', 'com']

Если <maxsplit> не указан, то .split() и .rsplit() неразличимы.

s.splitlines([<keepends>])

Разрывает строку на границах линий.

s.splitlines() разбивает s на строки и возвращает их в виде спика. Любой из следующих символов или последовательностей символов считается границей линии:

Escape-символ Описание
\n Новая строка
\r Возврат к началу строки
\r\n Возврат к началу строки + заполнение
\v или \x0b Подведение Линии
\f или \x0c Перевод на следующий лист(Form Feed)
\x1c Разделение файлов
\x1d разделитель групп
\x1e разделитель записей
\x85 Следующая Строка (Контрольный Код C1)
\u2028 Разделитель Строк Unicode
\u2029 Разделитель Абзацев Unicode

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

>>> 'foo\nbar\r\nbaz\fqux\u2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']

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

>>> 'foo\f\f\fbar'.splitlines()
['foo', '', '', 'bar']

Если необязательный аргумент <keepends> указан и является истинным, то границы строк сохраняются в результирующих строках:

>>> 'foo\nbar\nbaz\nqux'.splitlines(True)
['foo\n', 'bar\n', 'baz\n', 'qux']
>>> 'foo\nbar\nbaz\nqux'.splitlines(1)
['foo\n', 'bar\n', 'baz\n', 'qux']

Объекты bytes

Объект bytes является одним из основных встроенных типов для манипулирования двоичными данными. Объект bytes — это неизменяемая последовательность однобайтовых значений. Каждый элемент в объекте bytes представляет собой небольшое целое число в диапазоне от 0 до 255.

Определение литерала объекта bytes

Байтовый литерал определяется так же, как и строковый литерал с добавлением префикса ‘b‘ :

>>> b = b'foo bar baz'
>>> b
b'foo bar baz'
>>> type(b)
<class 'bytes'>

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

>>> b'Contains embedded "double" quotes'
b'Contains embedded "double" quotes'

>>> b"Contains embedded 'single' quotes"
b"Contains embedded 'single' quotes"

>>> b'''Contains embedded "double" and 'single' quotes'''
b'Contains embedded "double" and \'single\' quotes'

>>> b"""Contains embedded "double" and 'single' quotes"""
b'Contains embedded "double" and \'single\' quotes'

В байтовом литерале допускаются только символы ASCII. Любое символьное значение больше 127 должно быть указано с помощью соответствующей escape-последовательности:

>>> b = b'foo\xddbar'
>>> b
b'foo\xddbar'
>>> b[3]
221
>>> int(0xdd)
221

Префикс ‘r‘ может использоваться в байтовом литерале для отключения обработки escape-последовательностей, как и в случае со строками:

>>> b = rb'foo\xddbar'
>>> b
b'foo\\xddbar'
>>> b[3]
92
>>> chr(92)
'\\'

Определение объекта bytes с помощью встроенной функции bytes()

Функция bytes() также создает объект bytes. Какой тип байтов возвращается объекту, зависит от аргумента(ов), переданного функции. Возможные формы приведены ниже.

bytes(<s>, <encoding>)

Создает объект bytes из строки.

bytes(<s>, <encoding>) преобразует строку <s> в объект bytes, используя str.encode() в соответствии с заданной <encoding>:

>>> b = bytes('foo.bar', 'utf8')
>>> b
b'foo.bar'
>>> type(b)
<class 'bytes'>

Техническое Примечание: В этой форме функции bytes() требуется аргумент <encoding>. «Кодирование» относится к способу перевода символов в целочисленные значения. Значение «utf 8» указывает на формат преобразования Unicode UTF-8, который является кодировкой, способной обрабатывать все возможные символы Unicode. UTF-8 также можно указать, указав «UTF8«, «utf-8» или «UTF-8» для <encoding>.

Дополнительные сведения см. В документации Unicode. До тех пор, пока вы имеете дело с обычными латинскими символами, UTF-8 будет хорошо служить вам.

bytes(<size>)

Создает объект bytes, состоящий из нулевых (0x00) байтов.

bytes(<size>) определяет объект bytes указанного <size>, который должен быть положительным целым числом. Результирующий объект bytes инициализируется нулевыми (0x00) байтами:

>>> b = bytes(8)
>>> b
b'\x00\x00\x00\x00\x00\x00\x00\x00'
>>> type(b)
<class 'bytes'>

bytes(<iterable>)

Создает объект bytes из итерируемого объекта.

bytes(<iterable>) определяет объект bytes из последовательности целых чисел, сгенерированных <iterable>. <iterable> должен быть итегрируемым, который генерирует последовательность целых чисел n в диапазоне 0 ≤ n ≤ 255:

>>> b = bytes([100, 102, 104, 106, 108])
>>> b
b'dfhjl'
>>> type(b)
<class 'bytes'>
>>> b[2]
104

Операции с байтовыми объектами

Как и строки, объекты bytes поддерживают общие операции последовательности:

  • Операторы in и not in:
  • >>> b = b'abcde'
    
    >>> b'cd' in b
    True
    >>> b'foo' not in b
    True
    
  • Операторы конкатенации (+) и репликации (*) :
  • >>> b = b'abcde'
    
    >>> b + b'fghi'
    b'abcdefghi'
    >>> b * 3
    b'abcdeabcdeabcde'
    
  • Индексирование и нарезка:
  • >>> b = b'abcde'
    
    >>> b[2]
    99
    >>> b[1:3]
    b'bc'
    
  • Встроенные функции:
  • >>> len(b)
    5
    >>> min(b)
    97
    >>> max(b)
    101
    

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

>>> b = b'foo,bar,foo,baz,foo,qux'

>>> b.count(b'foo')
3

>>> b.endswith(b'qux')
True

>>> b.find(b'baz')
12

>>> b.split(sep=b',')
[b'foo', b'bar', b'foo', b'baz', b'foo', b'qux']

>>> b.center(30, b'-')
b'---foo,bar,foo,baz,foo,qux----'

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

>>> b = b'foo.bar'

>>> b + '.baz'
Traceback (most recent call last):
  File "<pyshell#72>", line 1, in 
    b + '.baz'
TypeError: can't concat bytes to str
>>> b + b'.baz'
b'foo.bar.baz'

>>> b.split(sep='.')
Traceback (most recent call last):
  File "<pyshell#74>", line 1, in 
    b.split(sep='.')
TypeError: a bytes-like object is required, not 'str'
>>> b.split(sep=b'.')
[b'foo', b'bar']

Хотя определение и представление байтового объекта основано на тексте ASCII, на самом деле он ведет себя как неизменяемая последовательность небольших целых чисел в диапазоне от 0 до 255 включительно. Вот почему один элемент из объекта bytes отображается как целое число:

>>> b = b'foo\xddbar'
>>> b[3]
221
>>> hex(b[3])
'0xdd'
>>> min(b)
97
>>> max(b)
221

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

>>> b[2:3]
b'c'

Вы можете преобразовать объект bytes в список целых чисел с помощью встроенной функции list()

>>> list(b)
[97, 98, 99, 100, 101]

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

bytes.fromhex(<s>)

Возвращает объект bytes, построенный из строки шестнадцатеричных значений.

bytes.fromhex(<s>) возвращает объект bytes, полученный в результате преобразования каждой пары шестнадцатеричных цифр в <s> в соответствующее значение байта. Шестнадцатеричные пары цифр в <s> могут быть дополнительно разделены пробелами, которые игнорируются:

>>> b = bytes.fromhex(' aa 68 4682cc ')
>>> b
b'\xaahF\x82\xcc'
>>> list(b)
[170, 104, 70, 130, 204]

Примечание: этот метод является методом класса, а не методом объекта. Он привязан к классу bytes, а не к объекту bytes. В следующих уроках по объектно-ориентированному программированию вы гораздо глубже изучите различие между классами, объектами и соответствующими им методами. А пока просто обратите внимание, что этот метод вызывается в классе bytes, а не в объекте b.

b.hex()

Возвращает строку, содержащую шестнадцатеричное значение из объекта в байтах.

b.hex() возвращает результат преобразования байтов объекта b в строку шестнадцатеричных пар цифр. То есть он делает обратное .fromhex():

>>> b = bytes.fromhex(' aa 68 4682cc ')
>>> b
b'\xaahF\x82\xcc'

>>> b.hex()
'aa684682cc'
>>> type(b.hex())
<class 'str'>

Примечание: В отличие от .fromhex(), .hex() — это объектный метод, а не метод класса. Таким образом, он вызывается на объекте класса bytes, а не на самом классе.

Объекты bytearray

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

  • В Python нет специального синтаксиса для определения литерала байтового массива, такого как префикс ‘b‘, который может использоваться для определения объекта bytes. Объект bytearray всегда создается с помощью встроенной функции bytearray() :
  • >>> ba = bytearray('foo.bar.baz', 'UTF-8')
    >>> ba
    bytearray(b'foo.bar.baz')
    
    >>> bytearray(6)
    bytearray(b'\x00\x00\x00\x00\x00\x00')
    
    >>> bytearray([100, 102, 104, 106, 108])
    bytearray(b'dfhjl')
    
  • Объекты bytearray изменчивы. Вы можете изменить содержимое объекта bytearray с помощью индексации и нарезки:
  • >>> ba = bytearray('foo.bar.baz', 'UTF-8')
    >>> ba
    bytearray(b'foo.bar.baz')
    
    >>> ba[5] = 0xee
    >>> ba
    bytearray(b'foo.b\xeer.baz')
    
    >>> ba[8:11] = b'qux'
    >>> ba
    bytearray(b'foo.b\xeer.qux')
    

Объект bytearray также может быть построен непосредственно из объекта bytes:

>>> ba = bytearray(b'foo')
>>> ba
bytearray(b'foo')

Вывод

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

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

Оригинал статьи: Strings and Character Data in Python

Автор оригинальной статьи: John Sturtz

Автор перевода: Кирилл Мартын-Назаров

Опубликовано Вадим В. Костерин

ст. преп. кафедры ИТЭ. Автор более 130 научных и учебно-методических работ. Лауреат ВДНХ (серебряная медаль).

Оставьте комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *