В языке Python строки — это тип данных, который используется для представления текста. Это один из базовых типов, с которым мы имеем дело в каждом проекте на Python.
Данная статья является полным руководством по использованию строк в Python. Прочитав ее, вы узнаете, как создавать строки и работать с ними. В частности, мы рассмотрим:
И не только это!
В Python вы можете создать строку, используя двойные или одинарные кавычки.
Например:
name = "Alice" hobby = 'golf'
Когда дело доходит до выбора одинарных или двойных кавычек, нужно быть последовательным. То есть вы можете использовать и те, и другие, но придерживайтесь одного стиля во всем проекте.
Применять строки и производить различные манипуляции с ними вам придется часто. Что касается «манипуляций», со строками можно делать множество вещей. Например, объединять, нарезать, изменять, находить подстроки и многое другое.
Далее поговорим об операторах строк.
Возможно вы уже знаете об основных математических операторах Python.
От редакции Pythonist. На эту тему у нас есть статья «Операторы в Python».
С известной аккуратностью операторы сложения и умножения можно также применять и для строк:
В дополнении к этим двум операторам есть еще один, очень полезный. Он называется оператор in
. С его помощью можно проверить, содержит ли строка определенную подстроку или символ.
Давайте рассмотрим подробнее, как работают эти операторы.
В Python вы можете объединить две или более строк с помощью оператора сложения (+).
Например:
part1 = "some" part2 = "where" word = part1 + part2 print(word) # Результат: # somewhere
Чтобы умножать строки в Python, можно использовать оператор умножения (*).
Например:
word = "hello" threeWords = word * 3 print(threeWords) # Результат: # hellohellohello
В Python оператор in
можно использовать для проверки нахождения подстроки в строке.
Другими словами, с его помощью можно узнать, есть ли внутри строки определенное слово или символ.
Оператор in возвращает значение True
, если внутри строки есть проверяемая подстрока. В противном случае возвращается значение False
.
Например:
sentence = "This is just a test" testFound = "test" in sentence print(testFound) # Результат: # True
Теперь давайте рассмотрим другой пример. На этот раз проверим, есть ли в слове определенный символ:
word = "Hello" eFound = "e" in word print(eFound) # Результат: # True
Далее поговорим про индексацию строк.
В Python строка представляет собой набор символов. Каждый символ строки имеет индекс — порядковый номер.
Благодаря этой индексации можно получить доступ к конкретному символу в данной строке, что весьма удобно.
Индексация строк Python начинается с нуля.
Это означает, что 1-й символ строки имеет индекс 0, 2-й символ имеет индекс 1 и так далее.
Чтобы получить доступ к символу с определенным индексом, нужно использовать квадратные скобки:
string[i]
.
Это выражение возвращает i-й символ строки. Например:
word = "Hello" c1 = word[0] print(c1) # Результат: # H
Если индекс выходит за пределы длины строки, вы увидите ошибку IndexError
.
Давайте рассмотрим следующий пример.
Новичку в программировании может быть трудно запомнить, что индексация начинается с 0. Например, последний символ строки из 5
символов имеет индекс 4
. Но давайте посмотрим, что произойдет, если вы вдруг подумаете, что это 5:
word = "Hello" last = word[5] print(last) # Результат: # IndexError: string index out of range
Как можно заметить, результатом является ошибка, указывающая, что индекс находится вне допустимого диапазона.
Это потому, что с индексом 5 мы пытаемся получить доступ к 6-му элементу. Но поскольку данная строка имеет только 5 символов, доступ к 6-му с треском проваливается.
Таким образом, следует быть осторожным и не пытаться получить доступ к отсутствующему элементу строки.
Из предыдущего раздела стало ясно как получить доступ к определенному символу строки.
Но иногда требуется получить доступ к определенному диапазону внутри строки.
Сделать это можно при помощи так называемой нарезки строк.
Самый простой вариант операции нарезки требует указания начального и конечного индекса:
string[start:end]
.
Результатом является срез символов исходной строки. В него входят символы от начального до конечного индекса (при этом символ с конечным индексом в срез не входит).
Например, возьмем первые три буквы строки:
word = "Hello" firstThree = word[0:3] print(firstThree) # Результат: # Hel
Полный синтаксис оператора среза включает в себя параметр шага и имеет следующий вид:
string[start:end:step]
.
Параметр шага (step) указывает, через сколько символов следует перепрыгивать. По умолчанию он равен 1
, как вы наверно уже догадались.
Например, возьмем каждый второй символ из первых 8
символов строки:
word = "Hello world" firstThree = word[0:8:2] print(firstThree) # Результат: # Hlow
Теперь вы должны понимать основные принципы нарезки строк в Python.
На практике срезы применяются очень разнообразно. Например, некоторые или даже все параметры среза можно опускать, а отсчет символов может идти в обратном направлении.
Но чтобы не раздувать материал, здесь мы не будем вдаваться в детали срезов.
Довольно часто возникает необходимость добавить переменные внутрь строки Python.
Для этого можно использовать F-строки. F-строка означает просто «форматированная строка». Она позволяет нам аккуратно размещать код внутри строки.
Чтобы создать F-строку, нужно добавить символ f
непосредственно перед строкой и обозначить фигурными скобками код, внедряемый в строку.
Например:
name = "Alice" greeting = f"Hello, {name}! How are you doing?" print(greeting) # Результат: # Hello, Alice! How are you doing?
Как можно заметить, это аккуратным образом встраивает в строку имя, хранящееся в переменной name
. Благодаря этому нам не нужно разбивать строку на три части, что было бы несколько неудобно.
Давайте рассмотрим еще один пример, чтобы убедиться, что внутри F-строки можно также запускать код:
calculation = f"5 * 6 = {5 * 6}." print(calculation) # Результат: # 5 * 6 = 30
От редакции Pythonist: на тему форматирования строк у нас есть отдельная статья — «Форматирование строк».
В языке Python строки изменять нельзя.
Это связано с тем, что строки относятся к неизменяемым типам данных и представляет собой неизменяемые наборы символов.
От редакции Pythonist: на тему изменяемости объектов в Python рекомендуем почитать статью «Python 3: изменяемый, неизменяемый…».
Новичков это может несколько сбивать с толку.
Но изменять именно исходную строку приходится не часто, так что особых проблем неизменяемость строк не вызывает.
Если вам нужна измененная строка, можно просто создать новую строку из исходной с уже внесенными в нее изменениями. То есть новая строка является просто модифицированной копией исходной версии нашей строки.
На самом деле существует множество полезных встроенных методов для изменения строк. Эти методы помогают решить большинство повседневных задач.
И оставшаяся часть данной статьи будет посвящена именно этим методам.
Во встроенном в Python модуле string
есть множество удобных методов, которые можно использовать для работы со строками.
Они делают жизнь программиста гораздо проще.
Эти методы предназначены для решения самых общих задач, связанных как с изменением строк, так и с работой со строками в целом.
Например, можно заменить символ в строке при помощи метода replace()
. Без этого метода это было бы не так просто сделать. Вам пришлось бы реализовать собственную логику для замены символа, так как непосредственное изменение строки невозможно.
И таких методов в Python довольно много. Если быть точными, то их 47. Не пытайтесь запомнить их все. Лучше почитайте про каждый из этих методов и попробуйте применить их.
Можно также добавить данную статью в закладки и возвращаться к ней потом по мере надобности.
Следующая таблица представляет собой шпаргалку с методами строк в Python. А ниже этой таблицы вы найдете более подробное описание каждого метода и пару полезных примеров по нему:
Имя метода | Описание метода |
capitalize | Преобразует первый символ строки в верхний регистр. |
casefold | Преобразует строку в нижний регистр. Поддерживает больше вариантов, чем метод lower() . Используется при локализации либо глобализации строк. |
center | Возвращает центрированную строку. |
count | Возвращает количество вхождений символа или подстроки в строке. |
encode | Производит кодировку строки. |
endswith | Проверяет, заканчивается ли строка определенным символом либо определенной подстрокой. |
expandtabs | Указывает размер табуляции для строки и возвращает его. |
find | Ищет определенный символ или подстроку. Возвращает позицию, где он был впервые обнаружен. |
format | Старый способ добавления переменных внутрь строки (выше мы рассмотрели современный метод F-строк). Форматирует строку, встраивая в нее значения и возвращая результат. |
format_map | Форматирует определенные значения в строке. |
index | Ищет символ или подстроку в строке. Возвращает индекс, по которому он был впервые обнаружен. |
isalnum | Проверяет, все ли символы строки являются буквенно-цифровыми. |
isalpha | Проверяет, все ли символы строки являются буквенными. |
isascii | Проверяет, все ли символы строки являются символами ASCII. |
isdecimal | Проверяет, все ли символы строки являются десятичными числами. |
isdigit | Проверяет, все ли символы строки являются цифрами. |
isidentifier | Проверяет, является ли строка идентификатором. |
islower | Проверяет, все ли символы строки находятся в нижнем регистре. |
isnumeric | Проверяет, все ли символы строки являются числами. |
isprintable | Проверяет, все ли символы строки доступны для печати. |
isspace | Проверяет, все ли символы строки являются пробелами. |
istitle | Проверяет, соответствует ли строка правилам написания заголовков (каждое слово начинается с заглавной буквы). |
isupper | Проверяет, все ли символы строки находятся в верхнем регистре. |
join | Соединяет элементы итерируемого объекта (например, списка) в одну строку. |
ljust | Возвращает выровненную по левому краю версию строки. |
lower | Приведение всех символов строки к нижнему регистру. |
lstrip | Удаляет пробелы слева от строки. |
maketrans | Создает таблицу преобразования символов (для метода translate() ). |
partition | Разбивает строку на три части. Искомая центральная часть указывается в качестве аргумента. |
removeprefix | Удаляет префикс из начала строки и возвращает строку без него. |
removesuffix | Удаляет суффикс из конца строки и возвращает строку без него. |
replace | Возвращает строку, в которой определенный символ или подстрока заменены чем-то другим (другим символом или подстрокой). |
rfind | Ищет в строке определенный символ или подстроку. Возвращает последний индекс, по которому он был найден. |
rindex | Ищет в строке определенный символ или подстроку. Возвращает последний индекс, по которому он был найден (отличие данного метода от предыдущего только в том, что в случае неудачного поиска он возвращает ошибку). |
rjust | Возвращает выровненную по правому краю версию строки. |
rpartition | Разбивает строку на три части. Искомая центральная часть указывается в качестве аргумента. |
rsplit | Разбивает строку по указанному разделителю и возвращает результат в виде списка. |
rstrip | Удаляет пробелы справа от строки. |
split | Разбивает строку по указанному разделителю и возвращает ее в виде списка элементов данной строки. |
splitlines | Разбивает строку по разрывам (символам переноса строк) и возвращает список строк. |
startswith | Проверяет, начинается ли строка с указанного символа или подстроки. |
strip | Возвращает строку с удаленными пробелами с двух сторон. |
swapcase | Все символы в верхнем регистре переводятся в нижний и наоборот. |
title | Преобразует каждое слово строки так, чтобы оно начиналось с заглавной буквы. |
translate | Возвращает переведенную строку. |
upper | Переводит все символы строки в верхний регистр. |
zfill | Заполняет строку символами 0 . |
В данном разделе дается более подробное описание каждого метода.
Помимо теории, для всех методов представлены полезные примеры.
Итак, начнем по порядку!
Чтобы сделать первую букву строки заглавной, удобно использовать данный метод.
"hello, world".capitalize() # Результат: # Hello, world
Чтобы преобразовать все символы строки в нижний регистр, удобно использовать встроенный метод casefold()
.
"HELLO, WORLD".casefold() # Результат: # hello world
Этот метод создает новую строку, переводя каждый символ строки в нижний регистр.
Разница между методами casefold()
и lower()
заключается в том, что метод casefold()
умеет преобразовывать специальные буквы других языков. Другими словами, использование casefold()
имеет смысл, когда ваше приложение должно поддерживать глобализацию или локализацию на другой язык.
Например, давайте преобразуем предложение на немецком языке, чтобы избавиться от большого двойного знака (ß). Это невозможно при использовании метода lower()
:
"Eine Großes bier".lower() # eine großes bier" "Eine Großes bier".casefold() # eine grosses bier"
Метод center()
используется, чтобы окружить (заполнить с двух сторон) строку заданными символами.
Этот метод имеет следующий синтаксис:
string.center(num_characters, separator)
При вызове этого метода необходимо указать общее количество символов в строке и символ, которым строка будет окружена (заполнена с двух сторон).
Например, давайте добавим символы тире вокруг слова и сделаем всю строку длиной 20 символов:
txt = "banana" x = txt.center(20, "-") print(x) # Результат: # -------banana-------
Метод count()
подсчитывает, сколько раз символ или подстрока встречается в строке.
Например, посчитаем количество букв l в предложении:
"Hello, world".count("l") # Возвращает 3
Или давайте посчитаем, сколько раз слово «Hello» встречается в этом же предложении:
"Hello, world".count("Hello") # Возвращает 1
Чтобы изменить кодировку строки, используйте встроенный метод encode()
.
Этот метод имеет следующий синтаксис:
string.encode(encoding=encoding, errors=errors)
Кодировкой по умолчанию является UTF-8. В случае неудачи кидается ошибка.
Например, давайте преобразуем строку в кодировку UTF-8:
title = 'Hello world' print(title.encode()) # Результат: # b'Hello world'
Этот метод можно вызвать с двумя необязательными параметрами:
Существует 6 типов ошибок:
strict
ignore
replace
xmlcharrefreplace
backslashreplace
Вот несколько примеров ASCII-кодировки с разными типами ошибок:
txt = "My name is Kimi Räikkönen" print(txt.encode(encoding="ascii", errors="ignore")) print(txt.encode(encoding="ascii", errors="replace")) print(txt.encode(encoding="ascii", errors="xmlcharrefreplace")) print(txt.encode(encoding="ascii", errors="backslashreplace")) print(txt.encode(encoding="ascii", errors="namereplace"))
Результат:
b'My name is Kimi Rikknen' b'My name is Kimi R?ikk?nen' b'My name is Kimi Räikkönen' b'My name is Kimi R\\xe4ikk\\xf6nen' b'My name is Kimi R\\N{LATIN SMALL LETTER A WITH DIAERESIS}ikk\\N{LATIN SMALL LETTER O WITH DIAERESIS}nen'
Данный метод применяется для проверки, заканчивается ли строка или ее часть заданным символом или подстрокой.
Например:
sentence = "Hello, welcome to my world." print(sentence.endswith(".")) # Результат: # True
При помощи метода expandtabs()
можно указать размер табуляции. Этот метод полезен, если ваши строки содержат табы.
Например:
sentence = "H\te\tl\tl\to" print(sentence.expandtabs(1)) print(sentence.expandtabs(2)) print(sentence.expandtabs(3)) print(sentence.expandtabs(4)) print(sentence.expandtabs(5))
Результат:
H e l l o H e l l o H e l l o H e l l o H e l l o
Метод find()
находит индекс первого вхождения символа или подстроки в строку. Если совпадения нет, возвращается -1
.
Также можно указать диапазон, в котором выполняется поиск. Полный синтаксис для использования этого метода имеет следующий вид:
string.find(value, start, end)
Например:
sentence = "Hello world" x = sentence.find("world") print(x) # Результат: # 6
Это означает, что строку world
можно найти по индексу 6 в заданном предложении.
В качестве другого примера давайте найдем подстроку в заданном диапазоне:
sentence = "This is a test" x = sentence.find("is", 3, 8) print(x) # Результат: # 5
Метод format()
форматирует строку, встраивая в нее значения. Это несколько устаревший подход к форматированию строк в Python.
Метод format() имеет следующий синтаксис:
string.format(value1, value2, ... , valuen)
Здесь value — это переменные, которые вставляются в строку. В дополнение к этому вам необходимо указать (при помощи фигурных скобок) места для этих переменных в строке.
Давайте посмотрим на следующий пример:
name = "John" age = 21 sentence = "My name is {} and I am {} years old".format(name, age) print(sentence) # Результат: # My name is John and I am 21 years old
Метод format_map()
используется, чтобы напрямую преобразовать словарь в строку.
Вот его синтаксис:
string.format_map(dict)
Чтобы это работало, вам нужно указать (при помощи фигурных скобок) места в строке, куда будут помещены значения словаря.
Например:
data = {"name": "John", "age": 21} sentence = "My name is {name} and I am {age} years old".format_map(data) print(sentence) # Результат: # My name is John and I am 21 years old
Метод index()
находит индекс первого вхождения символа или подстроки в строку. Если он не находит значение, то вызывается исключение. Этим он отличается от метода find()
.
Также можно указать диапазон, в котором будет производится поиск.
Синтаксис данного метода имеет следующий вид:
string.index(value, start, end)
Например:
sentence = "Hello world" x = sentence.index("world") print(x) # Результат: # 6
Это говорит о том, что подстроку world
можно найти по индексу 6 в данной строке.
В качестве другого примера давайте найдем подстроку в заданном диапазоне:
sentence = "This is a test" x = sentence.index("is", 3, 8) print(x) # Результат: # 5
Разница между методами index()
и find()
заключается в том, что index()
выдает ошибку, если не находит значения. Метод find()
возвращает -1
.
Чтобы проверить, являются ли все символы строки буквенно-цифровыми, используется метод isalnum()
.
Например:
sentence = "This is 50" print(sentence.isalnum()) # Результат: # False
Чтобы проверить, все ли символы строки являются буквами, используется метод isalpha()
.
Например:
sentence = "Hello" print(sentence.isalpha()) # Результат: # True
Чтобы проверить, все ли символы строки являются ASCII символами, используется метод isascii()
.
Например:
sentence = "Hello" print(sentence.isalpha()) # Результат: # True
Чтобы проверить, являются ли все символы строки числами в десятичной системе исчисления, используется метод isdecimal()
.
Например:
sentence = "\u0034" print(sentence.isdecimal()) # Результат: # True
Чтобы проверить, все ли символы строки являются числами, используется метод isdigit()
.
Например:
sentence = "34" print(sentence.isdigit()) # Результат: # True
Чтобы проверить, все ли символы строки являются идентификаторами, используется метод isidentifier()
.
Например:
sentence = "Hello" print(sentence.isidentifier()) # Результат: # True
Чтобы проверить, находятся ли все символы строки в нижнем регистре, используется встроенный метод islower()
.
Например:
"Hello, world".islower() # Результат: # False
Этот метод проверяет, все ли символы строки находятся в нижнем регистре. Если это так, он возвращает True
. В противном случае False
.
Чтобы проверить, все ли символы строки являются числами, используется метод isnumeric()
.
Например:
sentence = "5000" print(sentence.isnumeric()) # Результат: # True
Чтобы проверить, все ли символы строки доступны для печати, используется метод isprintable()
.
Например:
sentence = "This a is test" print(sentence.isprintable()) # Результат: # True
Чтобы проверить, являются ли все символы строки пробелами, используется метод isspace()
.
Например:
sentence = " " print(sentence.isspace()) # Результат: # True
Чтобы проверить, все ли первые символы каждого слова в строке начинаются с заглавной буквы, используется метод istitle()
.
Например:
sentence = "Hello There This Is A Test" print(sentence.istitle()) # Результат: # True
Чтобы проверить, находятся ли все символы строки в верхнем регистре, используется встроенный метод isupper()
:
Например:
"HELLO, WORLD".isupper() # Результат: # True
Этот метод проверяет, все ли символы строки в верхнем регистре. Если это так, он возвращает True
. В противном случае False
.
Чтобы объединить группу элементов (например, списка) в одну строку, используется метод join()
.
Например:
words = ["This", "is", "a", "test"] sentence = " ".join(words) print(sentence) # Результат: # This is a test
Чтобы добавить определенные символы, например пробелы, справа от строки, используется метод ljust()
.
Вот его синтаксис:
string.ljust(num_characters, separator)
Например, добавим справа от строки символ тире:
print("Hello".ljust(20, "-")) # Результат: # Hello---------------
Чтобы привести строку Python к нижнему регистру, используется встроенный метод lower()
.
Например:
"HELLO, WORLD".lower() # Результат: # hello world
Этот метод создает новую строку, переводя каждый символ первоначальной строки в нижний регистр.
Чтобы удалить начальные символы из строки, используется метод lstrip()
.
По умолчанию этот метод удаляет все пробелы в начале строки.
Например:
print(" test".lstrip()) # Результат: # test
В качестве другого примера давайте удалим все дефисы в начале следующей строки:
print("---test---".lstrip("-")) # Результат: # test---
Чтобы создать таблицу сопоставления строк, используется метод maketrans()
. Эта таблица применяется вместе с методом translate()
.
Синтаксис имеет следующий вид:
string.maketrans(a, b, c)
a
является обязательным. Если указан только он один, то он должен быть словарем, который определяет порядок замены строк. В противном случае параметр a
должен быть строкой, которая показывает, какие символы нужно будет менять.b
является необязательным. Он должен быть одинаковой длины с параметром a
. Каждый символ в a
будет заменен соответствующим символом в b
.c
также является необязательным. Он определяет, какие символы нужно будет удалить из исходной строки.Например, заменим в предложении символы о
на х
:
sentence = "Hello World" trans_table = sentence.maketrans("o", "x") print(sentence.translate(trans_table)) # Результат: # Hellx Wxrld
Чтобы разделить строку на три части, используется метод partition()
. Он разбивает строку вокруг определенного символа или подстроки. Результат возвращается в виде кортежа.
Например, можно с его помощью разделить предложение вокруг заданного слова:
sentence = "This is a test" parts = sentence.partition("a") print(parts) # Результат: # ('This is', 'a', 'test')
Для удаления начала строки используется метод removeprefix()
. Надо заметить, что это относительно новый метод, он работает только начиная с версии Python 3.9 и выше.
Например, давайте удалим слово This
из данного предложения:
sentence = "This is a test" print(sentence.removeprefix("This")) # Результат: # is a test
Для удаления конца строки используется метод removesuffix(). Это также новый метод, он работает только с версией Python 3.9 и выше.
Например, давайте удалим из данного предложения последнее слово test:
sentence = "This is a test" print(sentence.removesuffix("test")) # Результат: # This is a
Чтобы заменить символ или подстроку внутри строки на что-то другое, используется метод replace()
:
Он имеет следующий синтаксис:
string.replace(old, new, count)
Здесь:
Например:
sentence = "This is a test" updated_sentence = sentence.replace("This", "It") print(updated_sentence) # Результат: # It is a test
Для нахождения индекса последнего вхождения символа или подстроки в строку используется метод rfind()
. При отсутствии совпадений возвращается значение -1
.
Синтаксис:
string.rfind(val, start, end)
Здесь:
Например:
sentence = "This car is my car" last_index = sentence.rfind("car") print(last_index) # Результат: # 15
Для нахождения индекса последнего вхождения символа или подстроки в строку также можно использовать метод rindex()
. Но если вхождений найдено не будет, данный метод вызовет исключение. В этом его отличие от метода rfind()
, который возвращает -1.
Его синтаксис имеет вид:
string.rindex(val, start, end)
Здесь:
sentence = "This car is my car" last_index = sentence.rindex("car") print(last_index) # Результат: # 15
Метод rjust()
используется для добавления слева от строки определенных символов, например пробелов.
У него следующий синтаксис:
string.rjust(num_characters, separator)
Например, добавим символы тире в начало строки:
print("Hello".rjust(20, "-")) # Результат: # ---------------Hello
Данный метод разделяет строку на три части относительно последнего вхождения искомого символа или подстроки. Результат возвращается в виде кортежа.
Например:
sentence = "This car is my car, you cannot drive it" parts = sentence.rpartition("car") print(parts) # Результат: # ('This car is my ', 'car', ', you cannot drive it')
Для разбиения строки по определенному разделителю начиная с правой стороны используется метод rsplit()
. Результат возвращается в виде списка.
Его синтаксис имеет вид:
string.rsplit(separator, max)
Здесь:
split()
Например, давайте разделим справа строку, разделенную запятыми. Но при этом сделаем только одно разбиение:
items = "apple, banana, cherry" split_items = items.rsplit(",", 1) print(split_items) # Результат: # ['apple, banana', ' cherry']
Обратите внимание, что данный массив состоит только из двух строк.
При помощи метода rstrip()
можно удалять определенные символы, начиная с конца строки.
Если не указывать аргументов, данный метод будет пытаться удалять пробелы справа от строки.
Например, давайте удалим символ тире из строки:
print("Hello-----".rstrip("-")) # Результат: # Hello
При помощи метода split()
строку можно превратить в список строк, разбив ее на части. Это один из наиболее широко используемых строковых методов Python.
По умолчанию данный метод разбивает строку на основе пробелов.
Вот его синтаксис:
string.split(separator, max)
Здесь:
Например:
sentence = "This is a test" # Разбить по пробелам parts = sentence.split() print(parts) # Результат: # ['This', 'is', 'a', 'test']
В качестве другого примера давайте разобьем список, разделенный запятыми, ровно два раза, по двум первым запятым:
sentence = "Apple, Banana, Orange, Mango, Pineapple" parts = sentence.split(",", 2) print(parts) # Результат: # ['Apple', ' Banana', ' Orange, Mango, Pineapple']
Обратите внимание, что в данном списке только 3 элемента.
Чтобы разбить текст, считанный в виде строки, по символам разрыва строки, используется метод splitlines()
.
Например:
sentence = "Apple\nBanana\nOrange\nMango\nPineapple" parts = sentence.splitlines() print(parts) # Результат: # ['Apple', 'Banana', 'Orange', 'Mango', 'Pineapple']
Вы также можете оставить символы разрыва строк в конце каждой строки. Для этого нужно передать параметр True в качестве аргумента данного метода:
sentence = "Apple\nBanana\nOrange\nMango\nPineapple" parts = sentence.splitlines(True) print(parts) # Результат: # ['Apple\n', 'Banana\n', 'Orange\n', 'Mango\n', 'Pineapple']
Чтобы проверить, начинается ли строка с определенного значения, используется метод startwith()
.
Вот его синтаксис:
string.startswith(val, start, end)
Здесь:
Например:
sentence = "Hello world" print(sentence.startswith("Hello")) # Результат: # True
Теперь перейдем к другому примеру. На этот раз давайте посмотрим, есть ли в строке, начиная с 6-го индекса, подстрока wor
:
sentence = "Hello world" print(sentence.startswith("wor", 6)) # Результат: # True
Чтобы удалить определенные символы или подстроку из строки, используется метод strip()
. По умолчанию этот метод удаляет пробелы. Также можно указать аргумент, который будет определять, какие именно символы нужно удалить.
Например, давайте удалим все символы тире из строки:
word = "--------test---" stripped_word = word.strip("-") print(stripped_word) # Результат: # test
Чтобы сделать строчные буквы заглавными, а заглавные строчными, используется метод swapcase()
.
Например:
"HELLO, world".swapcase() # Результат: # hello, WORLD
Этот метод создает новую строку, заменяя все заглавные буквы на строчные и наоборот.
Чтобы сделать первую букву каждого слова в строке заглавной, используется метод title()
.
Например:
"hello, world".title() # Результат: # Hello, World
Этот метод создает новую строку, делая первую букву каждого слова заглавной.
Чтобы заменить определенные символы строки на другие символы, используется метод translate()
.
Но прежде чем это делать, нужно создать таблицу сопоставления при помощи метода maketrans()
.
Например, давайте заменим буквы о
на х
:
sentence = "Hello World" trans_table = sentence.maketrans("o", "x") print(sentence.translate(trans_table)) # Результат: # Hellx Wxrld
Чтобы преобразовать строку Python в верхний регистр, используется встроенный метод upper()
.
Например:
"Hello, world".upper() # Результат: # HELLO WORLD
Этот метод создает новую строку, переводя каждый символ исходной строки в верхний регистр.
Данный метод добавляет нули перед исходной строкой.
В качестве аргумента нужно передать желаемую длину строки и, метод добавит нужное количество нулей перед строкой.
Например:
word = "Test" filled_word = word.zfill(10) print(filled_word) # Результат: # 000000Test
Обратите внимание, что общая длина этой строки теперь равна 10.
Видите как много существует методов строк!
Надеюсь, вам понравилась эта статья!
Удачного кодинга!
Перевод статьи Arturri Jalli «Python Strings: A Complete Guide [2022]».
Pydantic - это мощная библиотека проверки данных и управления настройками для Python, созданная для повышения…
Python предлагает набор библиотек, удовлетворяющих различные потребности в визуализации, будь то академические исследования, бизнес-аналитика или…
В Python для представления данных в двоичной форме можно использовать байты. Из этой статьи вы…
В этой статье рассказывается о том, что такое Werkzeug и как Flask использует его для…
При работе с датами часто возникает необходимость прибавлять к дате или вычитать из нее различные…
В этом руководстве мы рассмотрим, как добавить социальную аутентификацию с помощью GitHub и Google в…