Как изменить элемент строки python

Введение в тему

В этом уроке мы рассмотрим как заменить подстроку внутри строки, используя метод replace().

Метод replace Python возвращает копию строки, в которой все вхождения искомой подстроки заменяются другой подстрокой.

Что делает метод

Слово replace переводится как «заменять», что название этого метода является отличным описанием того, что он делает. С помощью метода replace можно заменить часть строки, называемую подстрокой или её всю на другую строку. Метод replace позволяет гибко изменять только необходимые части строки str.

Синтаксис

Метод .replace() имеет следующий синтаксис:

str.replace(old, new[, count])


  

Параметры

В качестве аргументов в метод передаются:

str — Строка, к которой применяется метод (тип данных string).

old — Подстрока, которую необходимо найти и заменить (тип данных string).

new — Новая подстрока, которой будет заменена старая (тип данных string).

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

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

my_var = "Ivan, Rinat, Olga, Kira"

#Заменяем все подстроки "Olga" в строке
a = my_var.replace("Olga", "Olya")
print(a)

#Заменяем первую подстроку "i" в строке
b = my_var.replace("i", "I", 1)
print(b)

#Заменяем первые две подстроки "a" в строке
c = my_var.replace("a", "A", 2)
print(c)
# Вывод:

Ivan, Rinat, Olya, Kira

Ivan, RInat, Olga, Kira

IvAn, RinAt, Olga, Kira


  

Возвращаемое значение

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

my_var = "Ivan, Rinat, Olga, Kira"

#Заменяем все вхождения "Olga" в строке
a = my_var.replace("Roman", "Roma")
print(a)

# Вывод:

Ivan, Rinat, Olga, Kira


  

Применение replace для замены нескольких значений

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

my_var = ['Ivan', 'Rinat', 'Olga', 'Kira']

# в новый список записываем элементы начального списка, измененные
# с помощью replace
new_list = [_.replace("i", "A", 1) for _ in my_var]
print(new_list)
# Вывод:

['Ivan', 'RAnat', 'Olga', 'KAra']


  

С помощью словаря

Предыдущий пример позволяет заменить несколько элементов, однако все они имеют одно и то же значение «i». Если необходимо заменить несколько разных значений, например «i» на «I» и «a» на «A», то необходимо реализовать чуть более сложную программу с использованием словарей:

# Функция для замены нескольких значений
def multiple_replace(target_str, replace_values):
# получаем заменяемое: подставляемое из словаря в цикле
for i, j in replace_values.items():
# меняем все target_str на подставляемое
target_str = target_str.replace(i, j)
return target_str

# создаем словарь со значениями и строку, которую будет изменять
replace_values = {"i": "I", "a": "A"}
my_str = "Ivan, Rinat, Olga, Kira"

# изменяем и печатаем строку
my_str = multiple_replace(my_str, replace_values)
print(my_str)
# Вывод:

IvAn, RInAt, OlgA, KIrA


  

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

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

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

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

from collections import OrderedDict


  

Помимо импорта в программе нужно поменять буквально одну строку:

replace_values = {"i": "I", "a": "A"}


  

Изменить её надо на:

replace_values = OrderedDict([("i", "I"), ("a", "A")])


  

Вариант со списками

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

my_str = "Ivan, Rinat, Olga, Kira"
# в цикле передаем список (заменяемое, подставляемое) в метод replace
for x, y in ("i", "I"), ("a", "A"):
my_str = my_str.replace(x, y)
print(my_str)
# Вывод:

IvAn, RInAt, OlgA, KIrA


  

Другие типы python и метод replace

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

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

from datetime import date

t_date = date(2021, 6, 19)
t_date = t_date.replace(day = 1)
print(t_date)
# Вывод:
2021-06-01


  

Для времени метод replace применяется аналогично.

Функцию replace() также можно использовать для замены некоторой строки, присутствующей в csv или текстовом файле. Модуль Python Pandas полезен при работе с наборами данных. Функция pandas.str.replace() function используется для замены строки другой строкой в переменной или столбце данных. Синтаксис:

dataframe.str.replace('old string', 'new string')


  

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

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

Ниже рассмотрим операторы, методы и функции, доступные для работы с текстом.

Строковые операторы

Вы уже видели операторы + и * в применении их к числовым значениям в уроке по операторам в Python . Эти два оператора применяются и к строкам.

Оператор сложения строк +

+ — оператор конкатенации строк. Он возвращает строку, состоящую из других строк, как показано здесь:

>>> s = 'py'
>>> t = 'th'
>>> u = 'on'

>>> s + t
'pyth'
>>> s + t + u
'python'

>>> print('Привет, ' + 'Мир!')
Go team!!!

Оператор умножения строк *

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

s * n
n * s

Вот примеры умножения строк:

>>> s = 'py.'

>>> s * 4
'py.py.py.py.'
>>> 4 * s
'py.py.py.py.'

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

>>> 'py' * -6
''

Если вы создадите строковую переменную и превратите ее в пустую строку, с помощью 'py' * -6, кто-нибудь будет справедливо считать вас немного глупым. Но это сработает.

Оператор принадлежности подстроки in

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

>>> s = 'Python'
>>> s in 'I love Python.'
True
>>> s in 'I love Java.'
False

Есть также оператор not in, у которого обратная логика:

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

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

Более подробно о них ниже.

Функция ord(c) возвращает числовое значение для заданного символа.

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

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

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

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

Unicode — это современный стандарт, который пытается предоставить числовой код для всех возможных символов, на всех возможных языках, на каждой возможной платформе. Python 3 поддерживает Unicode, в том числе позволяет использовать символы 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(s) возвращает количество символов в строке s:

>>> s = 'Простоя строка.'
>>> len(s)
15

Функция str(obj) возвращает строковое представление объекта.

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

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

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

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

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

Индексация строк начинается с нуля: у первого символа индекс 0, следующего 1 и так далее. Индекс последнего символа в python — ‘‘длина строки минус один’’.

Например, схематическое представление индексов строки 'foobar' выглядит следующим образом:

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

>>> s = 'foobar'

>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> s[5]
'r'

Попытка обращения по индексу большему чем len(s) - 1, приводит к ошибке IndexError:

>>> s[6]
Traceback (most recent call last):
  File "", 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)] # отрицательная индексация начинается с -1
'f'

Попытка обращения по индексу меньшему чем -len(s), приводит к ошибке IndexError:

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

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

Срезы строк

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

>>> s = 'python'
>>> s[2:5]
'tho'

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

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

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

>>> s = 'python'
>>> s[:4]
'pyth'
>>> s[0:4]
'pyth'

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

>>> s = 'python'
>>> s[2:]
'thon'
>>> s[2:len(s)]
'thon'

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

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

Пропуск обоих индексов возвращает исходную строку. Это не копия, это ссылка на исходную строку:

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

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

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

Отрицательные индексы можно использовать и со срезами. Вот пример кода Python:

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

Шаг для среза строки

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

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

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

>>> 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 = 'python'
>>> s[5:0:-2]
'nhy'

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

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

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

Это общая парадигма для разворота (reverse) строки:

>>> s = 'Если так говорит товарищ Наполеон, значит, так оно и есть.'
>>> s[::-1]
'.ьтсе и оно кат ,тичанз ,ноелопаН щиравот тировог кат илсЕ'

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

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

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

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

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('Произведение', n, 'на', m, 'равно', prod)
Произведение 20 на 25 равно 500

Но это громоздко. Чтобы выполнить то же самое с помощью f-строки:

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

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

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'Произведение {n} на {m} равно {prod}')
Произведение 20 на 25 равно 500

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

>>> var = 'Гав'
>>> print(f'Собака говорит {var}!')
Собака говорит Гав!
>>> print(f"Собака говорит {var}!")
Собака говорит Гав!
>>> print(f'''Собака говорит {var}!''')
Собака говорит Гав!

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

Строки — один из типов данных, которые Python считает неизменяемыми, что означает невозможность их изменять. Как вы ниже увидите, python дает возможность изменять (заменять и перезаписывать) строки.

Такой синтаксис приведет к ошибке TypeError:

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

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

>>> s = s[:3] + 't' + s[4:]
>>> s
'pytton'

Есть встроенный метод string.replace(x, y):

>>> s = 'python'
>>> s = s.replace('h', 't')
>>> s
'pytton'

Читайте дальше о встроенных методах строк!

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

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

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

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

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

obj.foo(<args>)

Этот код вызывает метод .foo() объекта obj. — аргументы, передаваемые методу (если есть).

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

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

Изменение регистра строки

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

string.capitalize() приводит первую букву в верхний регистр, остальные в нижний.

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

>>> s = 'everyTHing yoU Can IMaGine is rEAl'
>>> s.capitalize()
'Everything you can imagine is real'

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

>>> s = 'follow us @PYTHON'
>>> s.capitalize()
'Follow us @python'

string.lower() преобразует все буквенные символы в строчные.

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

>>> 'everyTHing yoU Can IMaGine is rEAl'.lower()
'everything you can imagine is real'

string.swapcase() меняет регистр буквенных символов на противоположный.

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

>>> 'everyTHing yoU Can IMaGine is rEAl'.swapcase()
'EVERYthING YOu cAN imAgINE IS ReaL'

string.title() преобразует первые буквы всех слов в заглавные

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

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

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

>>> 'follow us @PYTHON'.title()
'Follow Us @Python'

string.upper() преобразует все буквенные символы в заглавные.

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

>>> 'follow us @PYTHON'.upper()
'FOLLOW US @PYTHON'

Найти и заменить подстроку в строке

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

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

string.count([, [, ]]) подсчитывает количество вхождений подстроки в строку.

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

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

Количество вхождений изменится, если указать и :

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

string.endswith([, [, ]]) определяет, заканчивается ли строка заданной подстрокой.

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

>>> 'python'.endswith('on')
True
>>> 'python'.endswith('or')
False

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

>>> 'python'.endswith('yt', 0, 4)
True
>>> 'python'.endswith('yt', 2, 4)
False

string.find([, [, ]]) ищет в строке заданную подстроку.

s.find() возвращает первый индекс в s который соответствует началу строки :

>>> 'Follow Us @Python'.find('Us')
7

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

>>> 'Follow Us @Python'.find('you')
-1

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

>>> 'Follow Us @Python'.find('Us', 4)
7
>>> 'Follow Us @Python'.find('Us', 4, 7)
-1

string.index([, [, ]]) ищет в строке заданную подстроку.

Этот метод идентичен .find(), за исключением того, что он вызывает исключение ValueError, если не найден:

>>> 'Follow Us @Python'.index('you')
Traceback (most recent call last):
  File "", line 1, in <module>
    'Follow Us @Python'.index('you')
ValueError: substring not found

string.rfind([, [, ]]) ищет в строке заданную подстроку, начиная с конца.

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

>>> 'Follow Us @Python'.rfind('o')
15

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

>>> 'Follow Us @Python'.rfind('a')
-1

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

>>> 'Follow Us @Python'.rfind('Us', 0, 14)
7
>>> 'Follow Us @Python'.rfind('Us', 9, 14)
-1

string.rindex([, [, ]]) ищет в строке заданную подстроку, начиная с конца.

Этот метод идентичен .rfind(), за исключением того, что он вызывает исключение ValueError, если не найден:

>>> 'Follow Us @Python'.rindex('you')
Traceback (most recent call last):
  File "", line 1, in <module>
    'Follow Us @Python'.rindex('you')
ValueError: substring not found

string.startswith([, [, ]]) определяет, начинается ли строка с заданной подстроки.

s.startswith() возвращает, True если s начинается с указанного и False если нет:

>>> 'Follow Us @Python'.startswith('Fol')
True
>>> 'Follow Us @Python'.startswith('Go')
False

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

>>> 'Follow Us @Python'.startswith('Us', 7)
True
>>> 'Follow Us @Python'.startswith('Us', 8, 16)
False

Классификация строк

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

string.isalnum() определяет, состоит ли строка из букв и цифр.

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

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

string.isalpha() определяет, состоит ли строка только из букв.

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

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

string.isdigit() определяет, состоит ли строка из цифр (проверка на число).

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

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

string.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() = True и iskeyword() = False.

string.islower() определяет, являются ли буквенные символы строки строчными.

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

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

string.isprintable() определяет, состоит ли строка только из печатаемых символов.

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

>>> 'atb'.isprintable() # t - символ табуляции
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'anb'.isprintable() # n - символ перевода строки
False

Важно: Это единственный .is****() метод, который возвращает True, если s пустая строка. Все остальные возвращаются False.

string.isspace() определяет, состоит ли строка только из пробельных символов.

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

Наиболее часто встречающиеся пробельные символы — это пробел ' ', табуляция 't' и новая строка 'n':

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

Тем не менее есть несколько символов ASCII, которые считаются пробелами. И если учитывать символы Юникода, их еще больше:

>>> 'fu2005r'.isspace()
True

'f' и 'r' являются escape-последовательностями для символов ASCII; 'u2005' это escape-последовательность для Unicode.

string.istitle() определяет, начинаются ли слова строки с заглавной буквы.

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

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

string.isupper() определяет, являются ли буквенные символы строки заглавными.

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

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

Выравнивание строк, отступы

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

string.center([, ]) выравнивает строку по центру.

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

>>> 'py'.center(10)
'    py    '

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

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

Если s больше или равна , строка возвращается без изменений:

>>> 'python'.center(2)
'python'

string.expandtabs(tabsize=8) заменяет табуляции на пробелы

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

>>> 'atbtc'.expandtabs()
'a       b       c'
>>> 'aaatbbbtc'.expandtabs()
'aaa     bbb     c'

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

>>> 'atbtc'.expandtabs(4)
'a   b   c'
>>> 'aaatbbbtc'.expandtabs(tabsize=4)
'aaa bbb c'

string.ljust([, ]) выравнивание по левому краю строки в поле.

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

>>> 'python'.ljust(10)
'python    '

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

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

Если s больше или равна , строка возвращается без изменений:

>>> 'python'.ljust(2)
'python'

string.lstrip([]) обрезает пробельные символы слева

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

>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> 'tnfootnbartnbaz'.lstrip()
'footnbartnbaz'

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

>>> 'https://www.pythonru.com'.lstrip('/:pths')
'www.pythonru.com'

string.replace(, [, ]) заменяет вхождения подстроки в строке.

s.replace(, ) возвращает копию s где все вхождения подстроки , заменены на :

>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love')
'I love python! I love python! I love python!'

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

>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love', 2)
'I love python! I love python! I hate python!'

string.rjust([, ]) выравнивание по правому краю строки в поле.

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

>>> 'python'.rjust(10)
'    python'

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

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

Если s больше или равна , строка возвращается без изменений:

>>> 'python'.rjust(2)
'python'

string.rstrip([]) обрезает пробельные символы справа

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

>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'footnbartnbaztn'.rstrip()
'footnbartnbaz'

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

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

string.strip([]) удаляет символы с левого и правого края строки.

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

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

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

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

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

>>> '   foo bar bazttt'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar bazttt'.strip()
'foo bar baz'

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

string.zfill() дополняет строку нулями слева.

s.zfill() возвращает копию s дополненную '0' слева для достижения длины строки указанной в :

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

Если s содержит знак перед цифрами, он остается слева строки:

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

Если s больше или равна , строка возвращается без изменений:

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

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

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

Методы преобразование строки в список

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

Многие из этих методов возвращают либо список, либо кортеж. Это два похожих типа данных, которые являются прототипами примеров итераций в python. Список заключен в квадратные скобки ( []), а кортеж заключен в простые (()).

Теперь давайте посмотрим на последнюю группу строковых методов.

string.join() объединяет список в строку.

s.join() возвращает строку, которая является результатом конкатенации объекта с разделителем s.

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

Примеры кода помогут вникнуть. В первом примере разделителем s является строка ', ', а список строк:

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

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

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

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

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

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

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

>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
  File "", 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() особенно полезен для создания из них строк.

string.partition() делит строку на основе разделителя.

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

• Часть s до
• Разделитель
• Часть s после

Вот пара примеров .partition()в работе:

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

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

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

s.rpartition() делит строку на основе разделителя, начиная с конца.

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

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

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

string.rsplit(sep=None, maxsplit=-1) делит строку на список из подстрок.

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

>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foontbar   bazrfqux'.rsplit()
['foo', 'bar', 'baz', 'qux']

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

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

Если = None, строка разделяется пробелами, как если бы не был указан вообще.

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

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

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

>>> 'footttbar'.rsplit()
['foo', 'bar']

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

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

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

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

string.split(sep=None, maxsplit=-1) делит строку на список из подстрок.

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

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

Если не указано, между .rsplit() и .split() в python разницы нет.

string.splitlines([]) делит текст на список строк.

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

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

>>> 'foonbarrnbazfquxu2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']

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

>>> 'foofffbar'.splitlines()
['foo', '', '', 'bar']

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

>>> 'foonbarnbaznqux'.splitlines(True)
['foon', 'barn', 'bazn', 'qux']
>>> 'foonbarnbaznqux'.splitlines(8)
['foon', 'barn', 'bazn', 'qux']

Заключение

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

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

• Списки python
• Кортежи (tuple)

s = input()
print(len(s))
t = input()
number = int(t)
u = str(number)
print(s * 3)
print(s + ' ' + u)

s = 'abcdefg'
print(s[1])
print(s[-1])
print(s[1:3])
print(s[1:-1])
print(s[:3])
print(s[2:])
print(s[:-1])
print(s[::2])
print(s[1::2])
print(s[::-1])

s = 'abcdefghijklm'
print(s[0:10:2])
for i in range(0, 10, 2):
    print(i, s[i])

S = 'Hello'
print(S.find('e'))
# вернёт 1
print(S.find('ll'))
# вернёт 2
print(S.find('L'))
# вернёт -1

S = 'Hello'
print(S.find('l'))
# вернёт 2
print(S.rfind('l'))
# вернёт 3

print('Hello'.replace('l', 'L'))
# вернёт 'HeLLo'

print('Abrakadabra'.replace('a', 'A', 2))
# вернёт 'AbrAkAdabra'

print('Abracadabra'.count('a'))
# вернёт 4
print(('a' * 10).count('aa'))
# вернёт 5

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

If you’re looking for ways to remove or replace all or part of a string in Python, then this tutorial is for you. You’ll be taking a fictional chat room transcript and sanitizing it using both the .replace() method and the re.sub() function.

In Python, the .replace() method and the re.sub() function are often used to clean up text by removing strings or substrings or replacing them. In this tutorial, you’ll be playing the role of a developer for a company that provides technical support through a one-to-one text chat. You’re tasked with creating a script that’ll sanitize the chat, removing any personal data and replacing any swear words with emoji.

You’re only given one very short chat transcript:

[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY BLASTED ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!

Even though this transcript is short, it’s typical of the type of chats that agents have all the time. It has user identifiers, ISO time stamps, and messages.

In this case, the client johndoe filed a complaint, and company policy is to sanitize and simplify the transcript, then pass it on for independent evaluation. Sanitizing the message is your job!

The first thing you’ll want to do is to take care of any swear words.

>>> "Fake Python".replace("Fake", "Real")
'Real Python'

>>> transcript = """
... [support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
... [johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY BLASTED ACCOUNT
... [support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
... [johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!"""

>>> transcript.replace("BLASTED", "😤")
[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY 😤 ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!

>>> "Fake Python".replace("fake", "Real")
'Fake Python'

>>> transcript.replace("BLASTED", "😤").replace("Blast", "😤")
[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY 😤 ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : 😤! You're right!

# transcript_multiple_replace.py

REPLACEMENTS = [
    ("BLASTED", "😤"),
    ("Blast", "😤"),
    ("2022-08-24T", ""),
    ("+00:00", ""),
    ("[support_tom]", "Agent "),
    ("[johndoe]", "Client"),
]

transcript = """
[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY BLASTED ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!
"""

for old, new in REPLACEMENTS:
    transcript = transcript.replace(old, new)

print(transcript)

$ python transcript_multiple_replace.py
Agent  10:02:23 : What can I help you with?
Client 10:03:15 : I CAN'T CONNECT TO MY 😤 ACCOUNT
Agent  10:03:30 : Are you sure it's not your caps lock?
Client 10:04:03 : 😤! You're right!

# transcript_regex.py

import re

REGEX_REPLACEMENTS = [
    (r"blastw*", "😤"),
    (r" [-T:+d]{25}", ""),
    (r"[supportw*]", "Agent "),
    (r"[johndoe]", "Client"),
]

transcript = """
[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY BLASTED ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!
"""

for old, new in REGEX_REPLACEMENTS:
    transcript = re.sub(old, new, transcript, flags=re.IGNORECASE)

print(transcript)

$ python transcript_regex.py
Agent  : What can I help you with?
Client : I CAN'T CONNECT TO MY 😤 ACCOUNT
Agent  : Are you sure it's not your caps lock?
Client : 😤! You're right!

# transcript_regex_callback.py

import re

transcript = """
[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY BLASTED ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!
"""

def sanitize_message(match):
    print(match)

re.sub(r"[-T:+d]{25}", sanitize_message, transcript)

$ python transcript_regex_callback.py
<re.Match object; span=(15, 40), match='2022-08-24T10:02:23+00:00'>
<re.Match object; span=(79, 104), match='2022-08-24T10:03:15+00:00'>
<re.Match object; span=(159, 184), match='2022-08-24T10:03:30+00:00'>
<re.Match object; span=(235, 260), match='2022-08-24T10:04:03+00:00'>

# transcript_regex_callback.py

import re

ENTRY_PATTERN = (
    r"[(.+)] "  # User string, discarding square brackets
    r"[-T:+d]{25} "  # Time stamp
    r": "  # Separator
    r"(.+)"  # Message
)
BAD_WORDS = ["blast", "dash", "beezlebub"]
CLIENTS = ["johndoe", "janedoe"]

def censor_bad_words(message):
    for word in BAD_WORDS:
        message = re.sub(rf"{word}w*", "😤", message, flags=re.IGNORECASE)
    return message

def censor_users(user):
    if user.startswith("support"):
        return "Agent"
    elif user in CLIENTS:
        return "Client"
    else:
        raise ValueError(f"unknown client: '{user}'")

def sanitize_message(match):
    user, message = match.groups()
    return f"{censor_users(user):<6} : {censor_bad_words(message)}"

transcript = """
[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY BLASTED ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!
"""

print(re.sub(ENTRY_PATTERN, sanitize_message, transcript))

def sanitize_message(match):
    user, message = match.groups()
    return f"{censor_users(user):<6} : {censor_bad_words(message)}"

$ python transcript_regex_callback.py
Agent  : What can I help you with?
Client : I CAN'T CONNECT TO MY 😤 ACCOUNT
Agent  : Are you sure it's not your caps lock?
Client : 😤! You're right!

В статье по основным типам данных в 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 предоставляет множество функций, встроенных в интерпретатор и всегда доступных. Вот некоторые из них, которые работают со строками:

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

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 содержит хотя бы один непечатаемый символ. Неалфавитные символы игнорируются:

>>> 'atb'.isprintable()
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'anb'.isprintable()
False

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

s.isspace()

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

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

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

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

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

>>> 'fu2005r'.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‘) пробелами. По умолчанию пробелы заполняются при условии остановки табуляции в каждом восьмом столбце:

>>> 'atbtc'.expandtabs()
'a       b       c'
>>> 'aaatbbbtc'.expandtabs()
'aaa     bbb     c'

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

>>> 'atbtc'.expandtabs(4)
'a   b   c'
>>> 'aaatbbbtc'.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   '
>>> 'tnfootnbartnbaz'.lstrip()
'footnbartnbaz'

Если указан необязательный аргумент <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'
>>> 'footnbartnbaztn'.rstrip()
'footnbartnbaz'

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

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

s.strip([<chars>])

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

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

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

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

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

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

>>> '   foo bar bazttt'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar bazttt'.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']
>>> 'foontbar   bazrfqux'.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> опущен. В этом случае последовательные пробелы объединяются в один разделитель, и результирующий список никогда не будет содержать пустых строк:

>>> 'footttbar'.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 на строки и возвращает их в виде спика. Любой из следующих символов или последовательностей символов считается границей линии:

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

>>> 'foonbarrnbazfquxu2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']

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

>>> 'foofffbar'.splitlines()
['foo', '', '', 'bar']

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

>>> 'foonbarnbaznqux'.splitlines(True)
['foon', 'barn', 'bazn', 'qux']
>>> 'foonbarnbaznqux'.splitlines(1)
['foon', 'barn', 'bazn', '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'fooxddbar'
>>> b
b'fooxddbar'
>>> b[3]
221
>>> int(0xdd)
221

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

>>> b = rb'fooxddbar'
>>> 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'x00x00x00x00x00x00x00x00'
>>> 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'fooxddbar'
>>> 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'xaahFx82xcc'
>>> 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'xaahFx82xcc'

>>> 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'x00x00x00x00x00x00')

>>> 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.bxeer.baz')

>>> ba[8:11] = b'qux'
>>> ba
bytearray(b'foo.bxeer.qux')

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

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

Вывод

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

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

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

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

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