Python предлагает много способов получить последний символ строки. Но чтобы в них разобраться, сперва нужно понять, как работает индексирование в Python. Чтобы указать, какой фрагмент строки вы хотите получить, можно использовать квадратные скобки, а в них поместить индекс нужного символа.
Например, в строке “stand firm in the faith” всего 23 символа.
testString = "stand firm in the faith"
print("The length of testString is: %d" % len(testString))
# Вывод:
# The length of testString is: 23
При этом последняя буква “h” имеет индекс 22. Почему 22, а не 23? Потому что в Python индексация начинается с 0. Т.е. первый символ в строке имеет индекс 0, второй – 1 и так далее.
Еще Python имеет замечательную особенность: индексация может идти и в обратном порядке! Просто используйте отрицательные числа, начиная с -1. Под индексом -1 будет последний символ строки, под индексом -2 – предпоследний и т.д.
Получаем последний символ строки
Чтобы получить последний символ строки, можно просто обратиться к нему по индексу. Но такое жесткое прописывание индекса связано с определенными проблемами. Для начала вы должны знать сам индекс, а для этого – длину строки. Далее мы опишем несколько лучших методов.
testString = "stand firm in the faith"
lastChar = testString[22]
print("The last character of testString is: %s" % lastChar)
# Вывод:
# The last character of testString is: h
Применение функции len()
Более детерминированный способ получения последнего индекса в строке – это использование функции len() для получения длины строки. В данном случае функция len() вернет 23. Чтобы получить индекс последнего символа, нужно вычесть единицу из длины строки.
testString = "stand firm in the faith"
lastChar = testString[len(testString) - 1]
print("The last character of testString is: %s" % lastChar)
# Вывод:
# The last character of testString is: h
Отрицательный индекс
Вероятно, самый простой способ получить последний символ строки в Python – это использовать отрицательные индексы. Использование отрицательных чисел для индексации в Python позволяет начать отсчет с конца строки. Таким образом, если в строке “stand firm in the faith” вам нужен только последний символ строки, можно обратиться к нему по индексу -1.
testString = "stand firm in the faith"
lastChar = testString[-1]
print("The last character of testString is: %s" % lastChar)
# Вывод:
# The last character of testString is: h
Осторожность при работе с пустой строкой
Все вышеперечисленные методы могут вызвать исключение, если мы не включим в программу проверку ошибок. В следующем примере мы создадим новую строку, в которой не будет ни одного символа. Если мы попытаемся обратиться по индексу к несуществующему символу, Python выбросит исключение.
sampleString = "" lastChar = sampleString[-1]
Результат:
Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: string index out of range
Простой способ исправить этот пример – проверить, что наша строка имеет ненулевую длину (т.е. содержит какие-то символы).
testString = ""
if len(testString) > 0:
lastChar = testString[len(testString) - 1]
print("The last character of testString is: %s" % lastChar)
else:
print("The string was empty")
# Вывод:
# The string was empty
Прежде чем пытаться извлечь первый, последний или любой другой символ строки, стоит убедиться, что такой индекс в строке есть, иначе получите исключение.
Получаем последние n символов строки
Вы также можете захватить не один последний символ, а несколько. Для этого мы будем использовать то, что в Python называется оператором среза.
При помощи среза можно задать диапазон символов. Для этого указываются индексы начала и конца диапазона символов (их разделяет двоеточие). Важно обратить внимание, что символ под начальным индексом войдет в срез, а под конечным – нет. Если при использовании среза вы получаете слишком много или слишком мало символов, то это, скорее всего, связано с непониманием того, как он используется.
testString = "stand firm in the faith"
extractedString = testString[6:10]
print("Extracted string: %s" % extractedString)
# Вывод:
# Extracted string: firm
Примечание редакции: о срезах можно почитать в статье “Срез массива в Python”. Срезы строк работают аналогично.
Как получить последние символы строки с помощью среза
Чтобы получить последние n символов, просто выберите начальный и конечный индекс для среза. Например, если мы хотим получить последнее слово нашей тестовой строки “stand firm in the faith”, мы используем начальный индекс 18. Конечный индекс можно не указывать. В таком случае по умолчанию срез будет до конца строки.
testString = "stand firm in the faith"
lastChars = testString[18:]
print("The last five character of testString is: %s" % lastChars)
# Вывод:
# The last five character of testString is: faith
Можно пойти другим путем и применить функцию len(). Для определения начального индекса среза из длины строки нужно будет вычесть 6. Мы вычитаем единицу, потому что индексация начинается с нуля, и еще 5 – потому что в последнем слове 5 символов.
testString = "stand firm in the faith"
lastChars = testString[len(testString)-6:]
print("The last five character of testString is: %s" % lastChars)
# Вывод:
# The last five character of testString is: faith
Использование срезов с отрицательной индексацией
Этот вариант немного странный, но это может быть именно то, что вы ищете. Вы можете использовать отрицательную индексацию, чтобы указать начальный индекс, а затем не указывать конечный индекс, чтобы захватить остальную часть строки.
testString = "stand firm in the faith"
lastChars = testString[-5:]
print("The last five character of testString is: %s" % lastChars)
# Вывод:
# The last five character of testString is: faith
Как получить последнее слово в строке
Если вы имеете дело с предложениями и пытаетесь получить последнее слово в строке, лучше всего проделать некоторые манипуляции со строками.
Разделите исходную строку на массив новых строк с помощью функции split(). Первый аргумент функции split() указывает конкретный символ, по которому нужно разделить данную строку. Это может быть любой из символов Юникода, даже специальные символы. В нашем случае мы хотим разделить строку по пробелам. После разделения нам останется только выбрать одну из перечисленных выше техник для захвата последнего слова. Для примера используем отрицательный индекс.
testString = "stand firm in the faith"
words = testString.split(" ")
print("The last word of testString is: %s" % words[-1])
# Вывод:
# The last word of testString is: faith
Примечание редакции: о применении функции split() можно почитать в статье “Разделение строки в Python”.
Осторожно при работе с пустой строкой
Это менее рискованно, чем обращение к последнему элементу строки по индексу, поскольку функция split(), вызванная для пустой строки, вернет массив с содержимым [”], и исключение не будет выброшено. Тем не менее, хорошей практикой является добавление обработки ошибок, чтобы в дальнейшем в программе не возникало неожиданного поведения.
sampleString = ""
testString = ""
words = testString.split(' ')
print(words)
print("The last word of testString is: %s" % words[-1])
# Вывод:
# ['']
# The last word of testString is:
Ошибки нет, но это, вероятно, не тот результат, которого ожидает наш код. Исправление аналогично предыдущему примеру проверки ошибок:
testString = ""
if testString.count(" ") > 0:
words = testString.split(' ')
print("The last word of testString is: %s" % words[-1])
else:
print("There was not multiple words in the string")
# Вывод:
# There was not multiple words in the string
В общем, независимо от того, сколько символов строки вы извлекаете, важно убедиться, что в строке их не меньше запрошенного числа.
Удаление пробельных символов из строки
Возможно, вы хотите получить последний символ строки, чтобы узнать, является он печатным или пробельным. Вместо того чтобы выписывать эту оценку, можно использовать один из встроенных строковых методов. В этом примере мы покажем, как использовать метод strip().
testString = "this string has white space on the end "
print("[%s]" % testString)
# Вывод:
# [this string has white space on the end ]
testString = "this string has white space on the end "
testString = testString.strip()
print("[%s]" % testString)
# Вывод:
# [this string has white space on the end]
Как видите, метод strip() удалил пробелы из конца строки. Поэтому, если вы пытались получить последний символ, чтобы проверить, нужно ли удалять пробелы, метод strip() – гораздо более простой способ достижения той же цели.
Перевод статьи «Python: How to get the last character in a string».
You ended up with an empty string, so there is nothing to index anymore:
>>> ''[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
You do so by shortening capacity in the while loop:
capacity = capacity[1:len(capacity)-2]
You start with 100000, then make that '000', then '':
>>> capacity = '100000'
>>> capacity[1:len(capacity)-2]
'000'
>>> capacity[1:len(capacity)-2][1:len(capacity)-2]
''
You may have missed you are doing this as you are never printing the value of capacity in the loop.
You can always index from the end using negative indices:
>>> 'last character'[-1]
'r'
This works for slicing too:
>>> 'last character'[5:-4]
'chara'
Подскажите, пожалуйста, как узнать последний символ определенной строки списка.
Например, дан список list = ["aaab","aade","abez"]
Как вывести последний символ элемента list[0], чтобы получилось b
То есть мне нужна конструкция по аналогии с Java list[0].charAt(list[0].length()-1)
задан 22 окт 2019 в 20:06
3
Самый простой и красивый способ — обращение по отрицательному индексу, который помогает получать элементы в обратном порядке:
-1— последний элемент-2— предпоследний элемент- …
Пример:
items = ["aaab", "aade", "abez"]
print(items[0][-1])
# b
print(items[0][len(items[0]) - 1])
# b
for x in items:
print(x, x[-1], x[-2], x[-3], x[-4], sep=' | ')
# aaab | b | a | a | a
# aade | e | d | a | a
# abez | z | e | b | a
ответ дан 25 окт 2019 в 21:57
gil9redgil9red
76.3k6 золотых знаков51 серебряный знак117 бронзовых знаков
4
stroke = ['asd','','']
print([i for i in stroke[0][::-1]][0])
ответ дан 22 окт 2019 в 20:51
finallyfinally
2,37610 серебряных знаков29 бронзовых знаков
В первой главе мы познакомились с таким типом данных, как строка (str). Мы умеем складывать строки, умножать их на число и даже сравнивать между собой.
Если рассмотреть строку детальнее, то она состоит из символов, каждый из которых стоит на своём месте. Другими словами, строка — упорядоченная последовательность (коллекция) символов.
Слово «коллекция» в Python применяется не только к строкам. Коллекциями в Python также называют типы данных, в которых можно хранить сразу несколько значений.
В упорядоченных коллекциях, к которым относится строка, каждое значение автоматически имеет свой номер — индекс. Индексация в коллекциях Python начинается со значения 0. При этом пробел, запятая, управляющие символы n, t и прочие тоже получают свой индекс в строке. Для доступа к определённому символу строки по индексу нужно указать его в квадратных скобках сразу после имени переменной.
Давайте создадим программу, которая выводит первый символ строки, введённой пользователем:
text = input()
print(text[0])
Если пользователь введёт пустую строку, то наша программа выдаст ошибку:
IndexError: string index out of range
В пустой строке нет символов, и программа вышла за пределы строки. Таким образом, нельзя получить значение по индексу, который за пределами строки. Перед обращением к символу строки по индексу можно проверять, не выходит ли он за пределы строки, используя известную нам функцию len следующим образом:
text = input("Введите строку: ")
i = int(input("Введите индекс символа: "))
if i < len(text):
print(text[i])
else:
print("Индекс выходит за пределы строки")
Давайте подумаем, как можно взять последний символ строки? Для этого нам потребуется воспользоваться функцией len:
text = input()
print(text[len(text) - 1])
Однако в Python можно упростить эту запись, убрав из неё функцию len. И тогда в качестве индекса просто будет использоваться отрицательное число:
text = input()
print(text[-1])
Таким образом, последний символ имеет индекс -1, предпоследний -2 и т. д.
Так как строка — упорядоченная коллекция, то можно пройти по этой коллекции в цикле, указав в качестве индекса итерируемую переменную цикла. Например, вывести на строке каждый символ введённой пользователем строки:
text = input()
for i in range(len(text)):
print(text[i])
Существует и другой способ пройти по символам строки в цикле. Если не требуется на каждой итерации цикла знать индекс текущего символа, то цикл можно оформить следующим образом:
text = input()
for letter in text:
print(letter)
При такой записи цикла программа проходит не по индексам строки, а непосредственно по её символам. Так, переменная letter на каждой итерации цикла принимает значение очередного символа строки text.
Если требуется совместить проход непосредственно по символам строки с определением индекса итерации, то можно воспользоваться функцией enumerate. Она возвращает пары значений — номер элемента коллекции и сам этот элемент. Эта функция удобна, когда нужно пройти именно по элементам коллекции, но при этом ещё и знать индекс каждого элемента.
text = input()
for i, letter in enumerate(text):
print(f"{i}. {letter}")
Для строк в Python существует ещё одна полезная операция — срез (slice).
Срез позволяет взять часть строки, указав начальный и конечный индексы (конечный индекс не включается в диапазон). Также можно указать шаг, с которым срез будет взят (по умолчанию шаг 1). Например, в одной из прошлых глав мы аналогичным образом использовали функцию range.
Кроме того, в срезах можно использовать отрицательную индексацию. А если срез выходит за пределы строки, то программа не упадёт с ошибкой, а просто вернёт существующую часть строки.
Следующий пример показывает возможные варианты использования срезов:
text = "Привет, мир!"
print(text[8:11])
print(text[:6])
print(text[8:])
print(text[:])
print(text[::2])
Обратите внимание: строка является неизменяемой коллекцией. Это означает, что изменить отдельный символ строки нельзя.
Например, попытаемся в следующей программе изменить значение одного из символов строки:
word = "мир"
word[0] = "п"
Программа выдаст ошибку:
TypeError: 'str' object does not support item assignment
Мы уже знаем, что взаимодействовать с переменными в Python можно с помощью операций и функций. Рассмотрим ещё один способ взаимодействия — методы.
Методы похожи на функции, но вызываются не сами по себе, а для конкретной переменной. Для каждого типа данных есть свой набор методов. Чтобы вызвать метод, его нужно указать через точку после имени переменной. В круглых скобках после имени метода дополнительно можно обозначить аргументы (параметры) вызываемого метода, как это делаем с функциями.
Например, у строк есть метод islower(), который проверяет, что в строке не встречаются большие буквы, и возвращает в таком случае значение True, иначе — False:
print("а".islower())
print("A".islower())
True False
В следующей таблице перечислены часто используемые методы строк и примеры их работы. Важный момент: методы строк не меняют исходную строку, а возвращают новое значение, которое можно сохранить в переменной.
str.capitalize()
| Метод | str.capitalize() |
| Описание | Возвращает копию строки, у которой первая буква заглавная, а остальные приведены к строчным |
| Пример | s = «hello, World!» s.capitalize() |
| Результат | Hello, world! |
str.count(sub)
| Метод | str.count(sub) |
| Описание | Возвращает количество неперекрывающихся вхождений подстроки sub. К примеру, если искать в строке «ААААА» неперекрывающиеся значения «АА», то первое вхождение будет «AAAAA». Второе — «AAAAA». Больше неперекрывающихся вхождений нет. Так, поиск последующих вхождений подстроки происходит с индекса, который следует за последним найденным вхождением |
| Пример | s = «Hello, world!» s.count(«l») |
| Результат | 3 |
str.endswith(suffix)
| Метод | str.endswith(suffix) |
| Описание | Возвращает True, если строка оканчивается на подстроку suffix. Иначе возвращает False. suffix может быть кортежем проверяемых окончаний строки |
| Пример | s = «Hello, world!» s.endswith(«world!») |
| Результат | True |
str.find(sub)
| Метод | str.find(sub) |
| Описание | Возвращает индекс первого вхождения подстроки sub. Если подстрока не найдена, то возвращает -1 |
| Пример | s = «Hello, world!» s.find(«o») |
| Результат | 4 |
str.index(sub)
| Метод | str.index(sub) |
| Описание | Возвращает индекс первого вхождения подстроки sub. Вызывает исключение ValueError, если подстрока не найдена. Тема ошибок (исключений) будет разбираться на одной из следующих глав |
| Пример | s = «Hello, world!» s.index(«o») |
| Результат | 4 |
str.isalnum()
| Метод | str.isalnum() |
| Описание | Возвращает True, если все символы строки являются буквами и цифрами и в строке есть хотя бы один символ. Иначе возвращает False |
| Пример | s = «abc123» s.isalnum() |
| Результат | True |
str.isalpha()
| Метод | str.isalpha() |
| Описание | Возвращает True, если все символы строки являются буквами и в строке есть хотя бы один символ. Иначе возвращает False |
| Пример | s = «Letters» s.isalpha() |
| Результат | True |
str.isdigit()
| Метод | str.isdigit() |
| Описание | Возвращает True, если все символы строки являются цифрами и в строке есть хотя бы один символ. Иначе возвращает False |
| Пример | s = «123» s.isdigit() |
| Результат | True |
str.islower()
| Метод | str.islower() |
| Описание | Возвращает True, если все буквы в строке маленькие и в строке есть хотя бы одна буква. Иначе возвращает False |
| Пример | s = «word123» s.islower() |
| Результат | True |
str.isupper()
| Метод | str.isupper() |
| Описание | Возвращает True, если все буквы в строке большие и в строке есть хотя бы одна буква. Иначе возвращает False |
| Пример | s = «WORD123» s.isupper() |
| Результат | True |
str.join(str_col)
| Метод | str.join(str_col) |
| Описание | Возвращает строку, полученную конкатенацией (сложением) строк — элементов коллекции str_col (обозначение коллекции с элементами типа данных «строка»). Разделителем является строка, для которой вызван метод |
| Пример | a = [«1», «2», «3»] «; «.join(a) |
| Результат | «1; 2; 3» |
str.ljust(width, fillchar)
| Метод | str.ljust(width, fillchar) |
| Описание | Возвращает строку длиной width с выравниванием по левому краю. Строка дополняется справа символами fillchar до требуемой длины. По умолчанию значение fillchar — пробел |
| Пример | s = «text» s.ljust(10, «=») |
| Результат | «text======» |
str.rstrip(chars)
| Метод | str.rstrip(chars) |
| Описание | Возвращает строку, у которой в конце удалены символы, встречающиеся в строке chars. Если значение chars не задано, то пробельные символы удаляются |
| Пример | s = «stringBCCA» s.rstrip(«ABC») |
| Результат | «string» |
str.split(sep)
| Метод | str.split(sep) |
| Описание | Возвращает список строк по разделителю sep. По умолчанию sep — любое количество пробельных символов |
| Пример | s = «one, two, three» s.split(«, «) |
| Результат | [«one», «two», «three»] |
str.startswith(prefix)
| Метод | str.startswith(prefix) |
| Описание | Возвращает True, если строка начинается на подстроку prefix, иначе возвращает False. prefix может быть кортежем проверяемых префиксов строки. Под кортежами подразумевается неизменяемая последовательность элементов |
| Пример | s = «Hello, world!» s.startswith(«Hello») |
| Результат | True |
str.strip(chars)
| Метод | str.strip(chars) |
| Описание | Возвращает строку, у которой в начале и в конце удалены символы, встречающиеся в строке chars. Если значение chars не задано, то пробельные символы удаляются |
| Пример | s = «abc Hello, world! cba» s.strip(» abc») |
| Результат | «Hello, world!» |
str.title()
| Метод | str.title() |
| Описание | Возвращает строку, в которой каждое отдельное слово начинается с буквы в верхнем регистре, а остальные буквы идут в нижнем |
| Пример | s = «hello, world!» s.title() |
| Результат | «Hello, World!» |
str.upper()
| Метод | str.upper() |
| Описание | Возвращает копию строки, у которой все буквы приведены к верхнему регистру |
| Пример | s = «Hello, world!» s.upper() |
| Результат | «HELLO, WORLD!» |
str.zfill(width)
| Метод | str.zfill(width) |
| Описание | Возвращает строку, дополненную слева символами «0» до длины width |
| Пример | s = «123» s.zfill(5) |
| Результат | «00123» |
Рассмотрим ещё одну коллекцию в Python — список (list). Этот тип данных является упорядоченной коллекцией, которая может в качестве элементов иметь значения любого типа данных.
Один из способов создания списков — перечислить его элементы в квадратных скобках и присвоить это значение переменной, которая и станет в итоге списком в программе:
numbers = [10, 20, 30]
В примере мы создали список, состоящий из трёх элементов — целых чисел. Список может хранить значения любого типа, поэтому можно создать список со следующими элементами:
mixed_list = [10, 20.55, "text"]
Индексация в списках работает так же, как и в строках, — начальный индекс 0. Можно использовать отрицательные индексы, а также доступны срезы:
numbers = [10, 20, 30, 40, 50]
print(numbers[0])
print(numbers[-1])
print(numbers[1:3])
print(numbers[::-1])
Результат работы программы:
10 50 [20, 30] [50, 40, 30, 20, 10]
В отличие от строки, список относится к изменяемой коллекции. У списка можно изменить отдельный элемент, добавить новые или удалить существующие. Для изменения существующего элемента нужно указать его в левой части операции присваивания, а в правой указать новое значение этого элемента:
numbers = [10, 20, 50]
numbers[2] = 30
print(numbers)
Вывод программы:
[10, 20, 30]
Если требуется добавить элемент в конец списка, то можно использовать метод append().
Например, напишем программу, в которой список последовательно заполняется 10 целочисленными значениями с клавиатуры:
numbers = []
for i in range(10):
numbers.append(int(input()))
print(numbers)
Вывод программы:
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Для удаления элемента из списка применяется операция del. Нужно указать индекс элемента, который требуется удалить:
numbers = [10, 20, 50]
del numbers[-1]
print(numbers)
Вывод программы:
[10, 20]
С помощью del можно удалить несколько элементов списка. Для этого вместо одного элемента указываем срез:
numbers = [1, 2, 3, 4, 5]
del numbers[::2]
print(numbers)
Вывод программы:
[2, 4]
Полезные методы и функции списков и примеры их работы приведены в следующей таблице.
| Операция | Описание | Пример | Результат |
|---|---|---|---|
| x in s | Возвращает True, если в списке s есть элемент x. Иначе False | 1 in [1, 2, 3] | True |
| x not in s | Возвращает False, если в списке s есть элемент x. Иначе True | 4 not in [1, 2, 3] | True |
| s + t | Возвращает список, полученный конкатенацией списков s и t | [1, 2] + [3, 4, 5] | [1, 2, 3, 4, 5] |
| s * n (n * s) | Возвращает список, полученный дублированием n раз списка s | [1, 2, 3] * 3 | [1, 2, 3, 1, 2, 3, 1, 2, 3] |
| len(s) | Возвращает длину списка s | len([1, 2, 3]) | 3 |
| min(s) | Возвращает минимальный элемент списка | min([1, 2, 3]) | 1 |
| max(s) | Возвращает максимальный элемент списка | max([1, 2, 3]) | 3 |
| s.index(x) | Возвращает индекс первого найденного элемента x. Вызывается исключение ValueError, если элемент не найден | [1, 2, 3, 2, 1].index(2) | 1 |
| s.count(x) | Возвращает количество элементов x | [1, 1, 1, 2, 3, 1].count(1) | 4 |
| s.append(x) | Добавляет элемент x в конец списка | s = [1, 2] s.append(3) print(s) |
[1, 2, 3] |
| s.clear() | Удаляет все элементы списка | s = [1, 2, 3] s.clear() print(s) |
[] |
| s.copy() | Возвращает копию списка | [1, 2, 3].copy() | [1, 2, 3] |
| s.extend(t) или s += t | Расширяет список s элементами списка t | s = [1, 2, 3] s.extend([4, 5]) print(s) |
[1, 2, 3, 4, 5] |
| s.insert(i, x) | Вставляет элемент x в список по индексу i | s = [1, 3, 4] s.insert(1, 2) print(s) |
[1, 2, 3, 4] |
| s.pop(i) | Возвращает и удаляет элемент с индексом i. Если i не указан, то возвращается и удаляется последний элемент | s = [1, 2, 3] x = s.pop() print(x) print(s) |
3 [1, 2] |
| s.remove(x) | Удаляет первый элемент со значением x | s = [1, 2, 3, 2, 1] s.remove(2) print(s) |
[1, 3, 2, 1] |
| s.reverse() | Меняет порядок элементов списка на противоположный (переворачивает список) | s = [1, 2, 3] s.reverse() print(s) |
[3, 2, 1] |
| s.sort() | Сортирует список по возрастанию, меняя исходный список. Для сортировки по убыванию используется дополнительный аргумент reverse=True | s = [2, 3, 1] s.sort() print(s) |
[1, 2, 3] |
| sorted(s) | Возвращает отсортированный по возрастанию список, не меняя исходный. Для сортировки по убыванию используется дополнительный аргумент reverse=True | s = [2, 3, 1] new_s = sorted(s, reverse=True) print(new_s) |
[3, 2, 1] |
Ещё одной коллекцией в Python является кортеж (tuple). Кортеж является неизменяемой упорядоченной коллекцией. В кортеже нельзя заменить значение элемента, добавить или удалить элемент. Простыми словами, кортеж — неизменяемый список. Свойство неизменяемости используется для защиты от случайных или намеренных изменений.
Задать кортеж можно следующим образом:
numbers = (1, 2, 3, 4, 5)
Если нужно создать кортеж из одного элемента, то запись будет такой:
one_number = (1, )
Запятая в примере показывает, что в скобках не совершается операция, а идёт перечисление элементов кортежа.
Для кортежей доступны те операции и методы списков, которые не изменяют исходный кортеж.
В качестве примера использования кортежей приведём программу для обмена значений двух переменных:
a = 1
b = 2
(a, b) = (b, a)
# можно опустить круглые скобки и записать так a, b = b, a
print(f"a = {a}, b = {b}")
Вывод программы:
a = 2, b = 1
Между коллекциями можно производить преобразования. Покажем их на примере преобразования строки в список и кортеж (элементы строки, символы становятся элементами списка и кортежа соответственно):
text = "Привет, мир!"
list_symbols = list(text)
tuple_symbols = tuple(text)
text_from_list = str(list_symbols)
print(list_symbols)
print(tuple_symbols)
print(text_from_list)
Вывод программы:
['П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!']
('П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!')
['П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!']
Обратите внимание: преобразование коллекций к типу данных str не объединяет элементы этой коллекции в одну строку, а возвращает представление коллекции в виде строки.
В уроке по присвоению типа переменной в 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 предоставляет множество функций, которые встроены в интерпретатор. Вот несколько, которые работают со строками:
| Функция | Описание |
|---|---|
| chr() | Преобразует целое число в символ |
| ord() | Преобразует символ в целое число |
| len() | Возвращает длину строки |
| str() | Изменяет тип объекта на string |
Более подробно о них ниже.
Функция 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 на строки и возвращает их в списке. Любой из следующих символов или последовательностей символов считается границей строки:
| Разделитель | Значение |
|---|---|
| n | Новая строка |
| r | Возврат каретки |
| rn | Возврат каретки + перевод строки |
| v или же x0b | Таблицы строк |
| f или же x0c | Подача формы |
| x1c | Разделитель файлов |
| x1d | Разделитель групп |
| x1e | Разделитель записей |
| x85 | Следующая строка |
| u2028 | Новая строка (Unicode) |
| u2029 | Новый абзац (Unicode) |
Вот пример использования нескольких различных разделителей строк:
>>> '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)