Как мне получить подстроку строки в Python?

avatar
Joan Venge
19 марта 2009 в 17:29
3295256
16
2398

Есть ли способ подстроки строки в Python, чтобы получить новую строку от третьего символа до конца строки?

Может быть, как myString[2:end]?

Если оставление второй части означает «до конца», а если оставить первую часть, начинается ли она с начала?

Источник
mario ruiz
21 марта 2018 в 17:29
2

Этот содержит четкое объяснение pythoncentral.io/cutting-and-slicing-strings-in-python

Ответы (16)

avatar
Paolo Bergantino
19 марта 2009 в 17:30
3474
>>> x = "Hello World!"
>>> x[2:]
'llo World!'
>>> x[:2]
'He'
>>> x[:-2]
'Hello Worl'
>>> x[-2:]
'd!'
>>> x[2:-2]
'llo Worl'

Python называет эту концепцию «нарезкой», и она работает не только со строками. Взгляните на здесь, чтобы получить полное представление.

avatar
user18475123
4 апреля 2022 в 10:59
3
text = "StackOverflow"
#using python slicing, you can get different subsets of the above string

#reverse of the string
text[::-1] # 'wolfrevOkcatS' 

#fist five characters
text[:5] # Stack'

#last five characters
text[-5:] # 'rflow'

#3rd character to the fifth character
text[2:5] # 'rflow'

#characters at even positions
text[1::2] # 'tcOefo'
avatar
kannappan
22 декабря 2021 в 06:55
0

У меня есть более простое решение, использующее цикл for для поиска заданной подстроки в строке. Допустим, у нас есть две строковые переменные,

.
main_string = "lullaby"
match_string = "ll"

Если вы хотите проверить, существует ли данная строка совпадения в основной строке, вы можете сделать это,

match_string_len = len(match_string)
for index,value in enumerate(main_string):
    sub_string = main_string[index:match_string_len+index]
    if sub_string == match_string:
       print("match string found in main string")
avatar
Harsh
29 марта 2021 в 06:18
1
str1='There you are'
>>> str1[:]
'There you are'

>>> str1[1:]
'here you are'

#To print alternate characters skipping one element in between

>>> str1[::2]
'Teeyuae'

#To print last element of last two elements
>>> str1[:-2:-1]
'e'

#Similarly
>>> str1[:-2:-1]
'e'


#Using slice datatype

>>> str1='There you are'
>>> s1=slice(2,6)
>>> str1[s1]
'ere '


avatar
Code Carbonate
3 июля 2020 в 14:26
1
a="Helloo"
print(a[:-1])

В приведенном выше коде [: -1] объявляет печать от начала до максимального предела -1.

ВЫХОД:

>>> Hello

Примечание. Здесь [: -1] также совпадает с [0: -1] и [0: len (a) -1]

a="I Am Siva"
print(a[2:])

ВЫХОД :

>>> Am Siva

В приведенном выше коде a [2:] объявляет выводить от индекса 2 до последнего элемента.

Помните, что если вы установите максимальный предел для печати строки как (x), тогда он будет печатать строку до (x-1), а также помните, что индекс списка или строки всегда будет начинаться с 0.

avatar
Edson Horacio Junior
29 апреля 2020 в 18:31
7

Ну, у меня возникла ситуация, когда мне нужно было перевести PHP-скрипт на Python, и у него было много случаев использования substr(string, beginning, LENGTH).
Если бы я выбрал Python string[beginning:end], мне пришлось бы вычислять много конечных индексов, поэтому проще было использовать string[beginning:][:length], это избавило меня от многих проблем.

avatar
CopyPasteIt
17 февраля 2019 в 13:01
8

Если myString содержит номер счета, который начинается со смещения 6 и имеет длину 9, то вы можете извлечь номер счета следующим образом: acct = myString[6:][:9].

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

myString[2:][:999999]

Работает - ошибка не возникает, и по умолчанию не выполняется «заполнение строк».

victortv
12 марта 2019 в 22:49
1

Я думаю, если вы хотите использовать этот метод myString[offset:][:length] в случае OP, вы можете просто использовать myString[offset:][:]

CopyPasteIt
12 марта 2019 в 22:58
1

@VictorVal Ответ для тех (вроде меня), кто изучил Python как второй (третий, четвертый, ...) язык программирования и хочет использовать знакомые «синтаксические крючки», чтобы приблизиться к этому языку. Любые знатоки языка, скорее всего, сочтут мой ответ немного глупым.

Sebi
12 июня 2019 в 08:10
0

Следует ли помечать такие ответы для удаления? Другие ответы объясняют подобное решение намного лучше, и, увидев это, я почесал голову и несколько минут посмотрел на python, прежде чем понял, что это просто ответ такого типа.

avatar
Aaron Hall
23 июня 2017 в 21:53
22

Есть ли способ подстроки строки в Python, чтобы получить новую строку от 3-го символа до конца строки?

Может быть, как myString[2:end]?

Да, это действительно работает, если вы назначаете или связываете имя, end, с константным синглтоном, None:

>>> end = None
>>> myString = '1234567890'
>>> myString[2:end]
'34567890'

Нотация среза имеет 3 важных аргумента:

  • начало
  • стоп
  • шаг

Их значения по умолчанию, если они не указаны, равны None, но мы можем передать их явно:

>>> stop = step = None
>>> start = 2
>>> myString[start:stop:step]
'34567890'

Если оставление второй части означает «до конца», если оставить первую часть, начинается ли она с начала?

Да, например:

>>> start = None
>>> stop = 2
>>> myString[start:stop:step]
'12'

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

Когда шаг равен None, по умолчанию срез использует 1 для шага. Если вы сделаете шаг с отрицательным целым числом, Python достаточно умен, чтобы пройти от конца к началу.

>>> myString[::-1]
'0987654321'

Я подробно объясняю нотацию срезов в своем ответе на вопрос «Объяснить нотацию срезов».

avatar
levi
31 августа 2016 в 04:50
4

Использование жестко заданных индексов само по себе может вызвать затруднения.

Чтобы этого избежать, Python предлагает встроенный объект slice().

string = "my company has 1000$ on profit, but I lost 500$ gambling."

Если мы хотим знать, сколько денег у меня осталось.

Обычное решение:

final = int(string[15:19]) - int(string[43:46])
print(final)
>>>500

Использование срезов:

EARNINGS = slice(15, 19)
LOSSES = slice(43, 46)
final = int(string[EARNINGS]) - int(string[LOSSES])
print(final)
>>>500

Используя срез, вы улучшаете читаемость.

ASalazar
25 января 2017 в 17:27
5

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

avatar
ostrokach
31 августа 2016 в 04:28
8

Я хотел бы добавить к обсуждению два момента:

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

    'abcde'[2:None] == 'abcde'[2:] == 'cde'
    

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

    def substring(s, start, end):
        """Remove `start` characters from the beginning and `end` 
        characters from the end of string `s`.
    
        Examples
        --------
        >>> substring('abcde', 0, 3)
        'abc'
        >>> substring('abcde', 1, None)
        'bcde'
        """
        return s[start:end]
    
  2. Python имеет срез объектов:

    idx = slice(2, None)
    'abcde'[idx] == 'abcde'[2:] == 'cde'
    
avatar
Rudi Uhl
18 марта 2015 в 12:01
5

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

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

 >>>myString = 'Hello World'
 >>>end = 5

 >>>myString[2:end]
 'llo'

Если вы оставите первую часть, вы получите

 >>>myString[:end]
 'Hello' 

И если вы оставите: посередине, вы получите простейшую подстроку, которая будет 5-м символом (счет начинается с 0, поэтому в данном случае это пробел):

 >>>myString[end]
 ' '
avatar
Michał Leon
4 августа 2012 в 11:43
148

Обычно Substr () (т.е. PHP и Perl) работает следующим образом:

s = Substr(s, beginning, LENGTH)

Итак, параметры: beginning и LENGTH.

Но поведение Python другое; он ожидает начала и одного после END (!). Новичкам это сложно заметить. Итак, правильная замена Substr (s, начало, LENGTH) -

s = s[ beginning : beginning + LENGTH]
Nicu Surdu
29 мая 2013 в 13:58
85

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

PhilHibbs
10 января 2019 в 13:34
3

И для полноты картины Java похожа на Python в том, что метод String.substring () принимает начало и конец. Эта функция меня сильно укусила, я предполагал, что она имеет длину, как и любая другая функция подстроки в мире.

victortv
12 марта 2019 в 22:47
6

(Вероятно) более питонический способ сделать это - s[beginning:][:length]

Gloweye
9 октября 2019 в 09:00
2

Как человек, который начал с Python вместо [грязного слова] -языка, такого как PHP, я думаю, что Python намного проще и интуитивно понятен со своей строкой [начало: конец]. Длина обычно не имеет значения.

avatar
Endophage
20 марта 2012 в 00:58
444

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

some_string[::-1]

Или выбор альтернативных символов:

"H-e-l-l-o- -W-o-r-l-d"[::2] # outputs "Hello World"

Возможность перехода вперед и назад по строке поддерживает согласованность с возможностью массива срезов от начала или до конца.

Endophage
12 февраля 2013 в 17:59
24

@mtahmed абсолютно относится к вопросу. Что, если вы хотите создать подстроку, выбрав альтернативные символы из строки? Это будет my_string [:: 2]

John Lockwood
22 декабря 2017 в 11:03
0

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

Endophage
4 января 2018 в 18:47
2

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

Zoliqa
21 марта 2021 в 23:03
0

Понятно, что если поставить some_string [:: - 1], то вернутся строки в обратном порядке. Однако я действительно не понимаю, что вы делаете в этом случае с другими числами? Пример: test_string [5: 1: -1] - приведет к совершенно другому результату, чем я ожидал. Как первое и второе числа повлияют на строку, если третье число равно «-1»?

avatar
codingscientist
2 марта 2012 в 05:19
71

Обычный способ добиться этого - разрезать строку.

MyString[a:b] дает вам подстроку от индекса a до (b - 1).

avatar
gimel
19 марта 2009 в 18:02
28

Здесь отсутствует один пример: полная (неглубокая) копия.

>>> x = "Hello World!"
>>> x
'Hello World!'
>>> x[:]
'Hello World!'
>>> x==x[:]
True
>>>

Это обычная идиома для создания копии типов последовательностей (не интернированных строк), [:]. Shallow копирует список, см. Синтаксис фрагмента списка Python, используемый без очевидной причины .

Nicu Surdu
29 мая 2013 в 13:48
17

Это почти не имеет отношения к вопросу о подстроке. Даже не относится к струне. Сказать stringA = stringB достаточно ...

gimel
29 мая 2013 в 14:31
2

Полная копия [:] создает НОВУЮ КОПИЮ, использует синтаксис среза и читается как «подстрока от начала до конца».

bfontaine
30 декабря 2016 в 21:21
2

В чем смысл, если строки неизменяемы? a=b должно быть достаточно.

ShadowRanger
21 июня 2017 в 19:29
1

@gimel: На самом деле [:] для неизменяемого типа вообще не копирует. В то время как mysequence[:] в основном безвреден, когда mysequence является неизменяемым типом, например str, tuple, bytes (Py3) или unicode (Py2), a = b[:] просто эквивалентно <1535> тратит немного времени на отправку срезов байтовых кодов, на которые объект отвечает, возвращая себя, поскольку бессмысленно неглубоко копировать, когда, помимо тестов на идентичность объекта, это эквивалентно просто возвращению другой ссылки на неизменное «я».

Aaron Hall♦
25 октября 2017 в 14:33
3

Попытка обобщить другие критические замечания по этому ответу: в Python строки неизменяемы, поэтому нет причин делать копию строки - поэтому s[:] вообще не копирует: s = 'abc'; s0 = s[:]; assert s is s0. Да, это был идиоматический способ скопировать список в Python до тех пор, пока списки не получат list.copy, но у полного фрагмента неизменяемого типа нет причин делать копию, потому что его нельзя изменить, поэтому может быть только один в памяти, и нам не следует тратить время на ее копирование. Поскольку этот ответ неверен и даже не отвечает на вопрос - следует ли его удалить?

avatar
bouvard
19 марта 2009 в 17:31
10

Вы все поняли, за исключением "конца". Это называется срезной нотацией. Ваш пример должен выглядеть так:

new_sub_string = myString[2:]

Если вы опустите второй параметр, это неявно конец строки.