Python подстрока в строке: Как найти символ в строке python методом find() c примерами

Содержание

Как найти символ в строке python методом find() c примерами

Часто нам нужно найти символ в строке python. Для решения этой задачи разработчики используют метод find(). Он помогает найти индекс первого совпадения подстроки в строке. Если символ или подстрока не найдены, find возвращает -1.

Синтаксис

string.find(substring,start,end)

Метод find принимает три параметра:

  • substring (символ/подстрока) — подстрока, которую нужно найти в данной строке.
  • start (необязательный) — первый индекс, с которого нужно начинать поиск. По умолчанию значение равно 0.
  • end (необязательный) — индекс, на котором нужно закончить поиск. По умолчанию равно длине строки.

Поиск символов методом find() со значениями по умолчанию

Параметры, которые передаются в метод, — это подстрока, которую требуются найти, индекс начала и конца поиска. Значение по умолчанию для начала поиска — 0, а для конца — длина строки.

В этом примере используем метод со значениями по умолчанию.

Метод find() будет искать символ и вернет положение первого совпадения. Даже если символ встречается несколько раз, то метод вернет только положение первого совпадения.


>>> string = "Добро пожаловать!"
>>> print("Индекс первой буквы 'о':", string.find("о"))
Индекс первой буквы 'о': 1

Поиск не с начала строки с аргументом start

Можно искать подстроку, указав также начальное положение поиска.

В этом примере обозначим стартовое положение значением 8 и метод начнет искать с символа с индексом 8. Последним положением будет длина строки — таким образом метод выполнит поиска с индекса 8 до окончания строки.


>>> string = "Специалисты назвали плюсы и минусы Python"
>>> print("Индекс подстроки 'али' без учета первых 8 символов:", string.find("али", 8))
Индекс подстроки 'али' без учета первых 8 символов: 16

Поиск символа в подстроке со start и end

С помощью обоих аргументов (start и end) можно ограничить поиск и не проводить его по всей строке. Найдем индексы слова «пожаловать» и повторим поиск по букве «о».


>>> string = "Добро пожаловать!"
>>> start = string.find("п")
>>> end = string.find("ь") + 1
>>> print("Индекс первой буквы 'о' в подстроке:", string.find("о", start, end))
Индекс первой буквы 'о' в подстроке: 7

Проверка есть ли символ в строке

Мы знаем, что метод find() позволяет найти индекс первого совпадения подстроки. Он возвращает -1 в том случае, если подстрока не была найдена.


>>> string = "Добро пожаловать!"
>>> print("Есть буква 'г'?", string.find("г") != -1)
Есть буква 'г'? False
>>> print("Есть буква 'т'?", string.find("т") != -1)
Есть буква 'т'? True

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

Функция rfind() напоминает find(), а единое отличие в том, что она возвращает максимальный индекс. В обоих случаях же вернется -1, если подстрока не была найдена.

В следующем примере есть строка «Добро пожаловать!». Попробуем найти в ней символ «о» с помощью методов find() и rfind().


>>> string = "Добро пожаловать"
>>> print("Поиск 'о' методом find:", string.find("о"))
Поиск 'о' методом find: 1
>>> print("Поиск 'о' методом rfind:", string.rfind("о"))
Поиск 'о' методом rfind: 11

Вывод показывает, что find() возвращает индекс первого совпадения подстроки, а rfind() — последнего совпадения.

Второй способ поиска — index()

Метод index() помогает найти положение данной подстроки по аналогии с find(). Единственное отличие в том, что index() бросит исключение в том случае, если подстрока не будет найдена, а find() просто вернет -1.

Вот рабочий пример, показывающий разницу в поведении index() и find():


>>> string = "Добро пожаловать"
>>> print("Поиск 'о' методом find:", string.find("о"))
Поиск 'о' методом find: 1
>>> print("Поиск 'о' методом index:", string.index("о"))
Поиск 'о' методом index: 1

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


>>> string = "Добро пожаловать"
>>> print("Поиск 'г' методом find:", string.find("г"))
Поиск 'г' методом find: 1
>>> print("Поиск 'г' методом index:", string.index("г"))
Traceback (most recent call last):
File "pyshell#21", line 1, in module
print("Поиск 'г' методом index:", string.index("г"))
ValueError: substring not found

В этом примере мы пытались найти подстроку «г». Ее там нет, поэтому find() возвращает -1, а index() бросает исключение.

Поиск всех вхождений символа в строку

Чтобы найти общее количество совпадений подстроки в строке можно использовать ту же функцию find(). Пройдемся циклом while по строке и будем задействовать параметр start из метода find().

Изначально переменная start будет равна -1, что бы прибавлять 1 у каждому новому поиску и начать с 0. Внутри цикла проверяем, присутствует ли подстрока в строке с помощью метода find.

Если вернувшееся значение не равно -1, то обновляем значением count.

Вот рабочий пример:


my_string = "Добро пожаловать"
start = -1
count = 0

while True:
start = my_string.find("о", start+1)
if start == -1:
break
count += 1

print("Количество вхождений символа в строку: ", count )

Количество вхождений символа в строку:  4

Выводы

  • Метод find() помогает найти индекс первого совпадения подстроки в данной строке. Возвращает -1, если подстрока не была найдена.
  • В метод передаются три параметра: подстрока, которую нужно найти, start со значением по умолчанию равным 0 и end со значением по умолчанию равным длине строки.
  • Можно искать подстроку в данной строке, задав начальное положение, с которого следует начинать поиск.
  • С помощью параметров start и end можно ограничить зону поиска, чтобы не выполнять его по всей строке.
  • Функция rfind() повторяет возможности find(), но возвращает максимальный индекс (то есть, место последнего совпадения). В обоих случаях возвращается -1, если подстрока не была найдена.
  • index() — еще одна функция, которая возвращает положение подстроки. Отличие лишь в том, что index() бросает исключение, если подстрока не была найдена, а find() возвращает -1.
  • find() можно использовать в том числе и для поиска общего числа совпадений подстроки.

строки — Поиск упорядоченной подстроки в строке Python

Наивное решение, которое использует сравнение символов по умолчанию (основанное на порядковом номере ord(char)), может вернуть неверный результат для не-ascii символов, поэтому сравнение необходимо проводить, используя функцию специфичную для заданного алфавита:

def longest_alphabetical_substring(text, rank=lambda char: char):
    if not text: # empty
        return text
    longest = substr = []
    prev = text[0]
    for char in text[1:]:
        substr.append(prev)
        if rank(prev) > rank(char): # end of alphabetical substring
            if len(longest) < len(substr):
                longest = substr
            substr = []
        prev = char
    substr.append(prev)
    return type(prev)().join(substr if len(longest) < len(substr) else longest)

Здесь rank функция задаёт порядок букв. Сравнение по умолчанию перестаёт работать даже для текста с одним языком:

print(longest_alphabetical_substring("sabrrtuwacaddabra")) # OK ascii
# -> abrrtuw
print(longest_alphabetical_substring(u"абвгдеёжка")) #XXX WRONG!
# -> абвгдеё

Чтобы исправить, можно использовать Юникодное сравнение:

import icu # PyICU

rank = icu.Collator.createInstance(icu.Locale('ru')).getSortKey
print(longest_alphabetical_substring(u"абвгдеёжка", rank))
# -> абвгдеёжк

Чтобы поддерживать буквы, которые могут состоять из нескольких символов, можно использовать \X регулярное выражение, которое ищет grapheme cluster в тексте:

import regex as re # $ pip install regex

print(longest_alphabetical_substring(u"абвгдеёжка")) #XXX WRONG!
# -> абвгдее
print(longest_alphabetical_substring(re.findall(r"\X", u"абвгдеёжка"))) #XXX WRONG!
# -> абвгдеё
print(longest_alphabetical_substring(re.findall(r"\X", u"абвгдеёжка"), rank))
# -> абвгдеёжк
print(longest_alphabetical_substring(re.findall(r"\X", u"абвгдеёжка")))
# -> абвгдеёжк
print(longest_alphabetical_substring(re.findall(r"\X", u"абвгдеёжка"), rank))
# -> абвгдеёжк

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

>>> print(ascii(u"ё"))
'\u0435\u0308'

Предпоследний пример случайно дал верный результат и без rank функции, но на это не стоит рассчитывать и следует всегда передавать соответствующую алфавиту rank функцию.2(N)). Есть и более сложные в реализации алгоритмы за линейное время.

Edit:
В коде закомментирована краткая реализацию на Python c плохой асимптотикой.
Заменил на реализацию алгоритма Manber-Myers отсюда (должна быть асимптотика O(NlogN), но, как я понял, реализация этого не обеспечивает для произвольных входных данных)

LCP строится за линейное время — я привел эффективный и простой алгоритм Kасаи.

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

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

#медленная реализация
#def get_suffix_array(s):
#    return sorted(range(len(s)), key=lambda i: s[i:])

from collections import defaultdict

def sort_bucket(s, bucket, order):
    d = defaultdict(list)
    for i in bucket:
        key = s[i + order // 2:i + order]
        d[key].append(i)
    result = []
    for k, v in sorted(d.items()):
        if len(v) > 1:
            result += sort_bucket(s, v, 2 * order)
        else:
            result.append(v[0])
    return result


def suffix_array_ManberMyers(s):
    return sort_bucket(s, range(len(s)), 1)

def lcp_kasai(s, suffarr):
    n = len(suffarr)
    k = 0
    lcp = [0] * n
    rank = [0] * n
    for i in range(n):
        rank[suffarr[i]] = i

    for  i in range(n):
        if (k>0):
            k -= 1
        if(rank[i]==n-1):
             k = 0
             continue
        j = sa[rank[i]+1]
        while((i+k<n) & (j+k<n) & (s[i+k]==s[j+k])):
            k += 1
        lcp[rank[i]] = k
    return lcp

sa = suffix_array_ManberMyers("ACGTTGCATGTCGCATGATGCATGAGAGCT$")
print(sa)
lc = lcp_kasai("ACGTTGCATGTCGCATGATGCATGAGAGCT$", sa)
print(lc)

вывод суффиксного массива и lcp:

[30, 0, 24, 26, 21, 14, 17, 7, 20, 13, 6, 11, 1, 28, 23, 25, 16, 19, 12, 5, 
 27, 9, 2, 29, 10, 22, 15, 18, 4, 8, 3]
[0, 1, 2, 1, 4, 3, 3, 0, 5, 4, 1, 2, 1, 0, 3, 2, 1, 6, 5, 2, 1, 2, 0, 1, 1,
 3, 2, 6, 2, 1, 0]

в lcp мы видим два куска длиной два (это означает, что две подстроки встречаются трижды) со значением >=4: 5, 4 и 6, 5, начинающиеся на 8 и 17 позициях. Эти позиции в суффиксном массиве содержат индексы в исходной строке 20 и 19, чему соответствуют подстроки

CATG и GCAT

У Python есть метод подстроки «содержит»? Ru Python

Я ищу метод string.contains или string.indexof в Python.

Вы можете использовать оператор in :

 if "blah" not in somestring: continue 

Если это просто поиск подстроки, вы можете использовать string.find("substring") .

Вы должны быть немного осторожны с find , index и, хотя, как и подстроками. Другими словами, это:

 s = "This be a string" if s.find("is") == -1: print "No 'is' here!" else: print "Found 'is' in the string." 

Он напечатает Found 'is' in the string. Аналогично, if "is" in s: будет оцениваться True . Это может быть или не быть тем, что вы хотите.

if needle in haystack: это обычное использование, как говорит Майкл, – он полагается на оператора in , более читаемый и быстрее, чем вызов метода.

Если вам действительно нужен метод вместо оператора (например, чтобы сделать какой-то странный key= для очень своеобразного вида …?), Это будет 'haystack'.__contains__ . Но так как ваш пример предназначен для использования в if , я думаю, вы действительно не имеете в виду то, что вы говорите ;-). Это не хорошая форма (и не читаемая, и не эффективная) напрямую использовать специальные методы – они предназначены для использования вместо операторов и встроенных функций, которые им делегируют.

В принципе, вы хотите найти подстроку в строке в python. Существует два способа поиска подстроки в строке в Python.

Способ 1: in операторе

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

True если подстрока была найдена в строке else False .

 >>> "King" in "King's landing" True >>> "Jon Snow" in "King's landing" False 

Метод 2: метод str.find()

Второй метод – использовать метод str.find() . Здесь мы вызываем метод .find() в строке, в которой должна быть найдена подстрока. Мы передаем подстроку методу find () и проверяем его возвращаемое значение. Если его значение отличается от -1, подстрока была найдена в строке, в противном случае – нет. Возвращаемое значение – это индекс, в котором была найдена подстрока.

 >>> some_string = "valar morghulis" >>> some_string.find("morghulis") 6 >>> some_string.find("dohaeris") -1 

Я бы рекомендовал вам использовать первый метод, поскольку он более Pythonic и интуитивно понятен.

Нет, никакого string.contains(str) , но есть оператор in :

 if substring in someString: print "It's there!!!" 

Вот более сложный рабочий пример:

 # Print all files with dot in home directory import commands (st, output) = commands.getstatusoutput('ls -a ~') print [f for f in output.split('\n') if '.' in f ] 

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

 'foo' in '**foo**' # returns True 

Противоположность (дополнение), которую задает первоначальный вопрос, отсутствует:

 'foo' not in '**foo**' # returns False 

Это семантически то же самое, что

not 'foo' in '**foo**' но это гораздо более читаемо и явно предусмотрено в языке как улучшение удобочитаемости.

Избегайте использования ниже

Как и было обещано, вот метод contains :

 str.__contains__('**foo**', 'foo') 

возвращает значение True . Вы также можете вызвать эту функцию из экземпляра суперструны:

 '**foo**'.__contains__('foo') 

Но не надо. Методы, начинающиеся с подчеркивания, считаются семантически частными. Единственная причина, по которой это нужно использовать, – это расширение функции, а not in функциональности (например, при подклассификации str ):

 class NoisyString(str): def __contains__(self, other): print('testing if "{0}" in "{1}"'.format(other, self)) return super(NoisyString, self).__contains__(other) ns = NoisyString('a string with a substring inside') 

и сейчас:

 >>> 'substring' in ns testing if "substring" in "a string with a substring inside" True

Кроме того, избегайте следующих строковых методов:

 >>> '**foo**'.index('foo') 2 >>> '**foo**'.find('foo') 2 >>> '**oo**'.find('foo') -1 >>> '**oo**'.index('foo') Traceback (most recent call last): File "<pyshell#40>", line 1, in <module> '**oo**'.index('foo') ValueError: substring not found 

У других языков нет методов прямого тестирования подстрок, поэтому вам придется использовать эти типы методов, но с Python более эффективно использовать оператор сравнения:

 def in_(s, other): return other in s def contains(s, other): return s.__contains__(other) def find(s, other): return s.find(other) != -1 def index(s, other): try: s.index(other) except ValueError: return False else: return True import timeit 

И теперь мы видим, что использование in

 >>> min(timeit.repeat(lambda: in_('superstring', 'str'))) 0.18740022799465805 >>> min(timeit.repeat(lambda: in_('superstring', 'not'))) 0.18568819388747215

намного быстрее, чем ниже:

 >>> min(timeit.repeat(lambda: contains('superstring', 'str'))) 0.28179835493210703 >>> min(timeit.repeat(lambda: contains('superstring', 'not'))) 0.2830145370680839 >>> min(timeit.repeat(lambda: find('superstring', 'str'))) 0.3496236199280247 >>> min(timeit.repeat(lambda: find('superstring', 'not'))) 0.35399469605181366 >>> min(timeit.repeat(lambda: index('superstring', 'str'))) 0.3490336430259049 >>> min(timeit.repeat(lambda: index('superstring', 'not'))) 0.6793600760865957 

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

 "foo" in "foobar" True "foo" in "Foobar" False "foo" in "Foobar".lower() True "foo".capitalize() in "Foobar" True "foo" in ["bar", "foo", "foobar"] True "foo" in ["fo", "o", "foobar"] False 

Предостережение. Списки являются итерабельными, а метод in действует на iterables, а не только на строки.

По-видимому, нет ничего подобного для векторного сравнения. Очевидным способом Python для этого было бы:

 names = ['bob', 'john', 'mike'] any(st in 'bob and john' for st in names) >> True any(st in 'mary and jane' for st in names) >> False 

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

 str1 = "This be a string" find_this = "tr" if find_this in str1: print find_this, " is been found in ", str1 else: print find_this, " is not found in ", str1 

В Python есть два простых способа достижения этого:

Путь Pythonic: использование Python’s in in Keyword-

in принимает два «аргумента», один слева ( подстрока ) и один справа, и возвращает « True если левый аргумент содержится внутри аргумента прав, а если нет, он возвращает False .

 example_string = "This is an example string" substring = "example" print(substring in example_string) 

Вывод:

 True 

Непитонический путь: использование str.find на Python:

Метод find возвращает позицию строки в строке или -1, если она не найдена. Но просто проверьте, нет ли позиции -1.

 if example_string.find(substring) != -1: print('Substring found!') else: print('Substring not found!') 

Вывод:

 Substring found! 

Вот ваш ответ:

 if "insert_char_or_string_here" in "insert_string_to_search_here": //DOSTUFF 

Для проверки, является ли он ложным:

 if not "insert_char_or_string_here" in "insert_string_to_search_here": //DOSTUFF 

ИЛИ:

 if "insert_char_or_string_here" not in "insert_string_to_search_here": //DOSTUFF 

Python: поиск в строке | Python

В сегодняшнем посте разбираем поиск подстроки в строке. Задачи стоят элементарнейшие. В отличие от задача по преобразованию строки в число, задачи по поиску решаются в python с помощью встроенных функций. Для решения наших задач определим строки:
# исходная строка
string = "Some string for example."
# подстрока, которая явно входит в исходную строку
substring = "string"
# подстрока, которая явно не ходит в исходную строку
other_substring = "other string"
Задача №1 — узнать, входит ли подстрока в строку.  Операция substring in string вернет нам в результате логический ответ: True в случае, если substring входит в строку, и False в случае, если не входит. Для наглядности приведу ниже пример.
# Для начала хотим узнать, входит ли подстрока в строку
if substring in string:
    print ("Подстрока "%s" входит в строку "%s"" % (substring, string))
else:
    print ("Подстрока "%s" не входит в строку "%s"" % (substring, string))

# Та же самая процедура с другой подстрокой
if other_substring in string:
    print ("Подстрока "%s" входит в строку "%s"" % (other_substring, string))
else:
    print ("Подстрока "%s" не входит в строку "%s"" % (other_substring, string))
Задача №2 — узнать позицию вхождения подстроки в строку. Данную задачу решаем с помощью функции find(self, sub[, start[, end]]). Сразу перейдем к примерам:
# Узнаем, с какой позиции подстрока входит в строку
print(string.find(substring))
# 5
# Ищем, начиная с позиции 20
print(string.find(substring, 20))
# 44
# Ищем в диапазоне позиций 20 - 30
print(string.find(substring, 20, 30))
# -1

# И смотрим на результат, если подстрока не входит в строку
print(string.find(other_substring))
# -1
Далее стоит перед нами задача №3 — вычислить количество вхождений подстроки в строку. С ней легко справляется функция count(self, sub[, start[, end]])
# Нам интересно количество вхождений подстроки в строку
print(string.count(substring))
# 2
Задача №4 — проверить входит ли подстрока в строку без учета регистра. Для этого мы воспользуемся функцией преобразования символов строки в нижний/верхний регистр и применим к примеру №1.
# Для начала хотим узнать, входит ли подстрока в строку
if substring.lower() in string.lower():
    print ("Подстрока "%s" входит в строку "%s"" % (substring, string))
else:
    print ("Подстрока "%s" не входит в строку "%s"" % (substring, string))

# Та же самая процедура с другой подстрокой
if other_substring.upper() in string.upper():
    print ("Подстрока "%s" входит в строку "%s"" % (other_substring, string))
else:
    print ("Подстрока "%s" не входит в строку "%s"" % (other_substring, string))
На этом я остановлюсь, пожалуй. Если возникли вопросы, пожелания или предложения, то оставляйте комментарии. Отвечу всем.

Извлечение подстроки из строки на основе позиции символа-Python



Я пытаюсь извлечь подстроки из приведенной ниже строки

   package: name='com.example.tracker' versionCode='1' versionName='1.0'

как строка 1: versionCode=’1′ и как строка 2: versionName=’1.0′

Я использовал str.find(‘versionCode), который возвращает мне индекс ‘v’ в коде версии, и я использовал длину строки для доступа к ‘1’. Однако есть время, когда код версии может быть двузначным числом, поэтому я не могу исправить расположение этой цифры. Есть ли способ достичь этого?

Если строка

    package: name='com.example.tracker' versionCode='12' versionName='12.0'

Мне нужно извлечь 12 и 12.0. Моя реализация может поддерживать одиночные цифры, но цифры будут отличаться.

 if line.find('versionCode') != -1:
            x = line.find('versionCode') 
            versionCode = line[x+13:x+15] 
python string substring
Поделиться Источник Siddharthan Asokan     17 сентября 2013 в 23:49

3 ответа


  • Win batch scripting: извлечение подстроки из строки

    Я хочу извлечь подстроку из строки на основе разделителя / . Извлечение подстроки должно быть голодным, поэтому я хочу получить все символы из строки до последнего / . Пример: Строка: /ab/bcd/casd/adsd/se/23 Подстрока: /ab/bcd/casd/adsd/se/ P.S.: Я видел другие QnAs, и они не отвечают на…

  • Извлечение подстроки на различных разделителях

    Я новичок в android. Мне нужно извлечь различные подстроки из строки в моем приложении. То, что извлечение подстрок зависит от различных и различных разделителей и их комбинации. Шаблон строковых разделителей выглядит следующим образом : xxx|xxx|#yyy|ww~aaaaa|ww~ii|ww~t|*|yyy Теперь мне нужно…



1

Для этого вам нужно будет использовать регулярные выражения .

В каждой из приведенных ниже строк мы используем шаблон (.*?) для выполнения не жадного поиска в кавычках для извлечения строки, а затем извлекаем group(1) , а не group(0) для возвращаемого объекта, поскольку 0 возвращает полное совпадение по всей входной строке, а 1 дает первую группу захвата regex.

import re

packageDetails = "package: name='com.example.tracker' versionCode='1' versionName='1.0'"
name = re.search("name='(.*?)'", packageDetails).group(1)
versionCode = re.search("versionCode='(.*?)'", packageDetails).group(1)
versionName = re.search("versionName='(.*?)'", packageDetails).group(1)

print "package name is :", name
print "version code is :", versionCode
print "version name is :", versionName 

И это выводит:

package name is : com.example.tracker
version code is : 1
version name is : 1.0

Поделиться Unknown     17 сентября 2013 в 23:58



1

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

packageDetails = "package: name='com.example.tracker' versionCode='1' versionName='1.0'"
details = packageDetails
params = ['name=', 'versionCode=', 'versionName=']
params.reverse()
values = []
for p in params:
    details, v = details.split(p)
    values.append(v.strip().strip("'"))
values.reverse()

Поделиться chapelo     18 сентября 2013 в 01:11



0

Или вы могли бы создать словарь:

>>> details = { x.split('=')[0] : x.split('=')[1].strip("'") for x in a.split()[1:] }
>>> details
{
  "name" : "com.example.tracker",
  "versionCode" : "1",
  "versionName" : "1.0"
}
>>> details['name']
"com.example.tracker"
>>> details['versionCode'] == '1'
true

Или если вы не заботитесь о раздевании «‘»s

>>> dict(x.split('=') for x in a.split()[1:])
{
  "name" : "'com.example.tracker'",
  "versionCode" : "'1'",
  "versionName" : "'1.0'"
}

Поделиться AChampion     18 сентября 2013 в 00:48


Похожие вопросы:


Извлечение подстроки из строки случайных букв

У меня есть строка, которая является случайной по своей природе, например ‘CBLBTTCCBB’. Моя цель состоит в том, чтобы подсчитать вхождения строки CTLBT в строке CBLBTTCCBB . Повторение букв,…


Извлечение подстроки из строки в assembly

Я ищу, чтобы извлечь подстроку из строки переменной длины (ввод с клавиатуры). Вот мой вклад: 1.A строка. 2.An индекс / начальная позиция для подстроки. 3.length подстроки. Я должен вывести…


поиск подстроки из обратной строки с помощью Python

Интересно, есть ли аккуратный API в Python для поиска строки назад (из определенной позиции в строке), например, в строке Hello StackOverflow Hello Python, предположим, я хочу найти индекс подстроки…


Win batch scripting: извлечение подстроки из строки

Я хочу извлечь подстроку из строки на основе разделителя / . Извлечение подстроки должно быть голодным, поэтому я хочу получить все символы из строки до последнего / . Пример: Строка:…


Извлечение подстроки на различных разделителях

Я новичок в android. Мне нужно извлечь различные подстроки из строки в моем приложении. То, что извлечение подстрок зависит от различных и различных разделителей и их комбинации. Шаблон строковых…


Извлечение подстроки из строки на основе разделителя

Я пытаюсь извлечь данные из закодированного штрих-кода 2D. Часть извлечения работает нормально, и я могу получить значение в текстовом вводе. E.g., декодированная строка ]d2 01 05000456013482 17…


powershell получить sum определенной позиции подстроки

Как я могу получить sum файла из подстроки и поместить sum в определенную позицию (другую строку) с помощью powershell, если есть следующие условия: Получите sum чисел от позиции 3 до 13 строки,…


Каков самый простой способ найти символы строки после последнего вхождения данного символа в Python?

Я пытаюсь найти самый простой способ возврата подстроки, состоящей из символов строки после последнего вхождения данного символа в Python. Пример: s = ‘foo-bar-123-7-foo2’ Меня интересуют персонажи…


Извлечение подстроки из совпадающей строки

Я пытаюсь извлечь подстроку из строки после сопоставления для 24 в начале строки. Подстрока — это идентификатор MAC, начинающийся с позиции 6 до конца строки. Я знаю, что метод подстроки может…


Сортировка строки на основе подстроки

У меня есть список таких строк B2B16, A1B01, S1B32, A1B23, B1B44 Я хочу отсортировать порядок строк на основе подстроки (3,4) каждой из 5 строк. Я хочу отсортировать строку на основе подстроки…

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



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

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

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

python string substring
Поделиться Источник Joan Venge     19 марта 2009 в 17:29

13 ответов




3377

>>> x = "Hello World!"
>>> x[2:]
'llo World!'
>>> x[:2]
'He'
>>> x[:-2]
'Hello Worl'
>>> x[-2:]
'd!'
>>> x[2:-2]
'llo Worl'

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

Поделиться Paolo Bergantino     19 марта 2009 в 17:30



426

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

some_string[::-1]

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

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

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

Поделиться Endophage     20 марта 2012 в 00:58



139

Substr() обычно (т. е. PHP и Perl) работает таким образом:

s = Substr(s, beginning, LENGTH)

Таким образом, параметры beginning и LENGTH .

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

s = s[ beginning : beginning + LENGTH]

Поделиться Michał Leon     04 августа 2012 в 11:43



65

Распространенным способом достижения этой цели является нарезка строк.

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

Поделиться codingscientist     02 марта 2012 в 05:19



26

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

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

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

Поделиться gimel     19 марта 2009 в 18:02



19

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

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

Да, это действительно работает, если вы назначаете или привязываете имя end к константе singleton, 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'

Я очень подробно объясняю нотацию среза в своем ответе, чтобы объяснить вопрос о нотации среза.

Поделиться Aaron Hall     23 июня 2017 в 21:53


  • как извлечь множественную подстроку из строки в Python?

    Я имею в виду вопрос, как извлечь подстроку из строки в Python? и у меня есть еще один вопрос. Что делать, если моя строка что-то вроде: gfgfdAAA1234ZZZsddgAAA4567ZZZuijjk Я хочу извлечь 1234 и 4567 , хранятся ли они в виде списка?

  • Как получить подстроку из строки в python

    У меня есть строка path=’/home/user/Desktop/My_file.xlsx’ . Я хочу извлечь подстроку My_file . Я использую фреймворк Django для python. Я пытался получить его с помощью: re.search(‘/(.+?).xlsx’, path).group(1) но он снова возвращает весь путь. Может кто-нибудь, пожалуйста, помочь.



8

У вас все есть, за исключением «end». Это называется обозначением среза. Ваш пример должен гласить:

new_sub_string = myString[2:]

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

Поделиться bouvard     19 марта 2009 в 17:31



7

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

Если OP примет это, они, возможно, захотят попробовать в экспериментальном порядке,

myString[2:][:999999]

Это работает — ошибка не возникает, и по умолчанию ‘string padding’ не возникает.

Поделиться CopyPasteIt     17 февраля 2019 в 13:01



6

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

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

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

Поделиться ostrokach     31 августа 2016 в 04:28



6

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

Поделиться Edson Horacio Junior     29 апреля 2020 в 18:31



3

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

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

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

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

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

 >>>myString[:end]
 'Hello' 

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

 >>>myString[end]
 ' '

Поделиться Rudi Uhl     18 марта 2015 в 12:01



2

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

Чтобы избежать этого, 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

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

Поделиться levi     31 августа 2016 в 04:50




0

a="Helloo"
print(a[:-1])

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

OUTPUT :

>>> Hello

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

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

OUTPUT:

>>> Am Siva

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

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

Поделиться Code Carbonate     03 июля 2020 в 14:26


Похожие вопросы:


Как получить подстроку строки в свойстве ANT

У меня есть требование, чтобы получить подстроку из строки в собственность ant . Пример строки: 1=tibunit-1.4.2.projlib\= Я хочу извлечь часть до .projlib\= и после первого = . Результат должен…


Удалить подстроку из строки в python

У меня есть файл в python с именами файлов. Я хочу удалить некоторые строки и некоторые подстановки имени файла с помощью кода python. Мой формат файла выше: img/1.jpg img/10.jpg img/100.jpg 0 143…


Как найти подстроку с кавычкой внутри строки в Python?

Я хочу найти подстроку can’t внутри строки в Python. Вот код: astring = I cant figure this out if can\’t in astring: print found it else: print did not find it Выше должно быть напечатано did not…


Как получить подстроку из форматированной строки

Я хотел бы получить подстроку 403162 из данной строки Praveen(403162) в sql?


как получить подстроку внутри строки в ruby?

привет, как получить подстроку внутри строки в ruby? у меня есть такая струна : a = hai my name is tardjo b = this is tardjo как получить подстроку tardjo внутри строк a и b таким же образом?…


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

Я имею в виду вопрос, как извлечь подстроку из строки в Python? и у меня есть еще один вопрос. Что делать, если моя строка что-то вроде: gfgfdAAA1234ZZZsddgAAA4567ZZZuijjk Я хочу извлечь 1234 и 4567…


Как получить подстроку из строки в python

У меня есть строка path=’/home/user/Desktop/My_file.xlsx’ . Я хочу извлечь подстроку My_file . Я использую фреймворк Django для python. Я пытался получить его с помощью: re.search(‘/(.+?).xlsx’,…


Как получить подстроку из строки

Мне нужно получить подстроку даты из следующей строки: DEV_ACID_C179456_2016-11-05_0009_Build


Получить любую подстроку из строки

Я хотел бы получить определенный тип подстроки из строки. Например, я хочу иметь возможность получить подстроку Computer Science из строки String text = I studied Computer Science; . Другой…


Получить подстроку из строки с индексом символов

Я пытаюсь получить информацию из файла .txt: function1(par1, par2) function2(par1) function3(par1, par2, par3) Я хотел бы получить, например, для первой строки function1 как строку, par1 и par2 как…

Подстрока

Python — Как разрезать строку

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

Пример строки: «встречаемся в пятницу в 08:00 ». И вы можете получить доступ к определенным частям строки, обычно известным как подстроки.

Мы можем определить подстроку как последовательность символов внутри строки. В предыдущем примере подстроками Python могут быть, например, «Friday», «at» и «meet».

Как сгенерировать подстроку в Python

Python предоставляет различные способы и методы для создания подстроки, проверки наличия подстроки, получения индекса подстроки и т. Д.

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

строка [начало: стоп: шаг]

  • start — Начальный индекс подстроки.
  • stop — Конечный индекс подстроки.
  • step — Число, определяющее шаг нарезки. Значение по умолчанию — 1.

Индексы могут быть положительными или отрицательными числами. Положительные индексы начинаются с начала и идут до конца строки, а отрицательные индексы начинаются с конца и идут в начало строки.

Из этой статьи вы узнаете, как выполнять различные операции, связанные с подстроками в Python.

Как получить первые n символов строки в Python

В этом примере показано, как вырезать первые 5 символов строки.

  строка = "привет, мир"
печать (строка [: 5])
  

Здесь вы определяете индекс остановки, равный 5. Начальный индекс по умолчанию равен 0.

Результатом будет «привет» .

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

Этот пример покажет вам, как вырезать символы из индекса 3 в индекс 5 из строки.

  строка = "привет, мир"
print (строка [3: 5])
  

На выходе получается 'lo' .

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

Чтобы получить последний символ, используйте индекс -1 (отрицательный индекс). Посмотрите на следующий пример:

  string = "freecodecamp"
печать (строка [-1])
  

На выходе будет ‘p’ .

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

В этом примере вы разрежете последние 4 символа строки. Здесь вы используете отрицательный индекс, чтобы начать разрезание с конца строки.

  строка = "freecodecamp"
print (строка [-4:])
  

На выходе будет «лагерь» .

Как разрезать строку с помощью шагов через подстроки Python

Вы можете разрезать строку с шагами после указания начального индекса и конечного индекса. По умолчанию шаг равен 1, но в следующем примере размер шага равен 2.

  string = "добро пожаловать в freecodecamp"
печать (строка [:: 2])
  

На выходе будет ‘wloet fecdcm’ .

Как проверить, присутствует ли подстрока в строке в Python

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

  substring = "code"
string = "добро пожаловать в freecodecamp"
print (подстрока в строке)
  

Если присутствует, вернет True, в противном случае — False.

Здесь на выходе будет True .

Другой способ проверить, присутствует ли подстрока Python в строке

Вы можете использовать метод find () , чтобы проверить, присутствует ли подстрока в строке.

Давайте проверим следующий пример:

  substring = "zz"
строка = "привет, мир"
print (string.find (подстрока))
  

Если он доступен, он возвращает крайний левый индекс подстроки, в противном случае он возвращает -1 (что означает, что он недоступен).

Здесь выводится -1 , что означает, что «zz» не присутствует в «hello world».

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

Вы можете выбрать разделение определенного символа в соответствии с его номером индекса.

  строка = "привет, мир"
печать (строка [4])
  

Будет выведено ‘O’ .

Как создать список подстрок из строки в Python

Вы можете использовать метод split () для создания списка подстрок. Давайте посмотрим на следующий пример:

  string = "добро пожаловать на платформу freecodecamp"
печать (строка.split ())
  

Результатом будет ['welcome', 'to', 'freecodecamp', 'platform']

Как перевернуть строку в Python с отрицательными шагами

Чтобы перевернуть строку, шаг должен быть отрицательное значение, например -1.

  string = "добро пожаловать в freecodecamp"
print (строка [:: - 1])
  

Результат: ‘pmacedoceerf ot emoclew’ .

Как подсчитать, сколько раз подстрока присутствует в строке в Python

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

  string = "сегодня днем ​​у нас будет быстрый урок кодирования"
print (string.count ('полдень'))
  

Выход 1.

Последние мысли о подстроках Python

Поздравляем 👏👏, вы дочитали эту статью до конца! Надеюсь, вы узнали что-то новое о подстроках Python.

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

Вы также можете найти меня в Twitter @Davis_McDavid.

И вы можете прочитать больше подобных статей здесь

Проверить, содержит ли строка подстроку

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

в Оператор

Самый простой способ проверить, содержит ли строка Python подстроку, — использовать оператор in .

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

  fullstring = "StackAbuse"
substring = "закрепка"

если подстрока в полной строке:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

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

  TypeError: аргумент типа NoneType не повторяется
  

Чтобы этого избежать, сначала нужно проверить, указывает ли он на Нет или нет:

  fullstring = Нет
substring = "закрепка"

если полная строка! = Нет и подстрока в полной строке:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

Строка

.index () Метод

Тип String в Python имеет метод index () , который можно использовать для поиска начального индекса первого вхождения подстроки в строку.

Если подстрока не найдена, генерируется исключение ValueError , которое можно обработать с помощью блока try-except-else:

  fullstring = "StackAbuse"
substring = "закрепка"

пытаться:
    fullstring.index (подстрока)
кроме ValueError:
    print ("Не найдено!")
еще:
    print ("Найдено!")
  

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

Метод String.find ()

Тип String имеет другой метод, называемый find , который удобнее использовать, чем index () , потому что нам не нужно беспокоиться об обработке каких-либо исключений.

Если find () не находит совпадения, он возвращает -1, в противном случае он возвращает крайний левый индекс подстроки в большей строке.

  fullstring = "StackAbuse"
substring = "закрепка"

если fullstring.find (подстрока)! = -1:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

Ознакомьтесь с нашим практическим практическим руководством по изучению Git, содержащим лучшие практики, принятые в отрасли стандарты и прилагаемую шпаргалку.Прекратите гуглить команды Git и на самом деле выучите его!

Если вы предпочитаете избегать необходимости отлавливать ошибки, то этому методу следует отдать предпочтение, а не index () .

Регулярные выражения (RegEx)

Регулярные выражения предоставляют более гибкий (хотя и более сложный) способ проверки строк на соответствие шаблону. Python поставляется со встроенным модулем для регулярных выражений, который называется re . Модуль re содержит функцию под названием search () , которую мы можем использовать для сопоставления с шаблоном подстроки:

  из поиска re import

fullstring = "StackAbuse"
substring = "закрепка"

при поиске (подстрока, полная строка):
    печать "Найдено!"
еще:
    печать "Не найдено!"
  

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

Об авторе

Эта статья была написана Якобом Стопаком, консультантом по программному обеспечению и разработчиком, страстно желающим помогать другим улучшить свою жизнь с помощью кода. Джейкоб является создателем Initial Commit — сайта, посвященного тому, чтобы помочь любознательным разработчикам узнать, как написаны их любимые программы. Его избранный проект помогает людям изучать Git на уровне кода.

Проверить, содержит ли строка подстроку

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

в Оператор

Самый простой способ проверить, содержит ли строка Python подстроку, — использовать оператор in .

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

  fullstring = "StackAbuse"
substring = "закрепка"

если подстрока в полной строке:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

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

  TypeError: аргумент типа NoneType не повторяется
  

Чтобы этого избежать, сначала нужно проверить, указывает ли он на Нет или нет:

  fullstring = Нет
substring = "закрепка"

если полная строка! = Нет и подстрока в полной строке:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

Строка

.index () Метод

Тип String в Python имеет метод index () , который можно использовать для поиска начального индекса первого вхождения подстроки в строку.

Если подстрока не найдена, генерируется исключение ValueError , которое можно обработать с помощью блока try-except-else:

  fullstring = "StackAbuse"
substring = "закрепка"

пытаться:
    fullstring.index (подстрока)
кроме ValueError:
    print ("Не найдено!")
еще:
    print ("Найдено!")
  

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

Метод String.find ()

Тип String имеет другой метод, называемый find , который удобнее использовать, чем index () , потому что нам не нужно беспокоиться об обработке каких-либо исключений.

Если find () не находит совпадения, он возвращает -1, в противном случае он возвращает крайний левый индекс подстроки в большей строке.

  fullstring = "StackAbuse"
substring = "закрепка"

если fullstring.find (подстрока)! = -1:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

Ознакомьтесь с нашим практическим практическим руководством по изучению Git, содержащим лучшие практики, принятые в отрасли стандарты и прилагаемую шпаргалку.Прекратите гуглить команды Git и на самом деле выучите его!

Если вы предпочитаете избегать необходимости отлавливать ошибки, то этому методу следует отдать предпочтение, а не index () .

Регулярные выражения (RegEx)

Регулярные выражения предоставляют более гибкий (хотя и более сложный) способ проверки строк на соответствие шаблону. Python поставляется со встроенным модулем для регулярных выражений, который называется re . Модуль re содержит функцию под названием search () , которую мы можем использовать для сопоставления с шаблоном подстроки:

  из поиска re import

fullstring = "StackAbuse"
substring = "закрепка"

при поиске (подстрока, полная строка):
    печать "Найдено!"
еще:
    печать "Не найдено!"
  

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

Об авторе

Эта статья была написана Якобом Стопаком, консультантом по программному обеспечению и разработчиком, страстно желающим помогать другим улучшить свою жизнь с помощью кода. Джейкоб является создателем Initial Commit — сайта, посвященного тому, чтобы помочь любознательным разработчикам узнать, как написаны их любимые программы. Его избранный проект помогает людям изучать Git на уровне кода.

Проверить, содержит ли строка подстроку

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

в Оператор

Самый простой способ проверить, содержит ли строка Python подстроку, — использовать оператор in .

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

  fullstring = "StackAbuse"
substring = "закрепка"

если подстрока в полной строке:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

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

  TypeError: аргумент типа NoneType не повторяется
  

Чтобы этого избежать, сначала нужно проверить, указывает ли он на Нет или нет:

  fullstring = Нет
substring = "закрепка"

если полная строка! = Нет и подстрока в полной строке:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

Строка

.index () Метод

Тип String в Python имеет метод index () , который можно использовать для поиска начального индекса первого вхождения подстроки в строку.

Если подстрока не найдена, генерируется исключение ValueError , которое можно обработать с помощью блока try-except-else:

  fullstring = "StackAbuse"
substring = "закрепка"

пытаться:
    fullstring.index (подстрока)
кроме ValueError:
    print ("Не найдено!")
еще:
    print ("Найдено!")
  

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

Метод String.find ()

Тип String имеет другой метод, называемый find , который удобнее использовать, чем index () , потому что нам не нужно беспокоиться об обработке каких-либо исключений.

Если find () не находит совпадения, он возвращает -1, в противном случае он возвращает крайний левый индекс подстроки в большей строке.

  fullstring = "StackAbuse"
substring = "закрепка"

если fullstring.find (подстрока)! = -1:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

Ознакомьтесь с нашим практическим практическим руководством по изучению Git, содержащим лучшие практики, принятые в отрасли стандарты и прилагаемую шпаргалку.Прекратите гуглить команды Git и на самом деле выучите его!

Если вы предпочитаете избегать необходимости отлавливать ошибки, то этому методу следует отдать предпочтение, а не index () .

Регулярные выражения (RegEx)

Регулярные выражения предоставляют более гибкий (хотя и более сложный) способ проверки строк на соответствие шаблону. Python поставляется со встроенным модулем для регулярных выражений, который называется re . Модуль re содержит функцию под названием search () , которую мы можем использовать для сопоставления с шаблоном подстроки:

  из поиска re import

fullstring = "StackAbuse"
substring = "закрепка"

при поиске (подстрока, полная строка):
    печать "Найдено!"
еще:
    печать "Не найдено!"
  

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

Об авторе

Эта статья была написана Якобом Стопаком, консультантом по программному обеспечению и разработчиком, страстно желающим помогать другим улучшить свою жизнь с помощью кода. Джейкоб является создателем Initial Commit — сайта, посвященного тому, чтобы помочь любознательным разработчикам узнать, как написаны их любимые программы. Его избранный проект помогает людям изучать Git на уровне кода.

Проверить, содержит ли строка подстроку

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

в Оператор

Самый простой способ проверить, содержит ли строка Python подстроку, — использовать оператор in .

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

  fullstring = "StackAbuse"
substring = "закрепка"

если подстрока в полной строке:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

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

  TypeError: аргумент типа NoneType не повторяется
  

Чтобы этого избежать, сначала нужно проверить, указывает ли он на Нет или нет:

  fullstring = Нет
substring = "закрепка"

если полная строка! = Нет и подстрока в полной строке:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

Строка

.index () Метод

Тип String в Python имеет метод index () , который можно использовать для поиска начального индекса первого вхождения подстроки в строку.

Если подстрока не найдена, генерируется исключение ValueError , которое можно обработать с помощью блока try-except-else:

  fullstring = "StackAbuse"
substring = "закрепка"

пытаться:
    fullstring.index (подстрока)
кроме ValueError:
    print ("Не найдено!")
еще:
    print ("Найдено!")
  

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

Метод String.find ()

Тип String имеет другой метод, называемый find , который удобнее использовать, чем index () , потому что нам не нужно беспокоиться об обработке каких-либо исключений.

Если find () не находит совпадения, он возвращает -1, в противном случае он возвращает крайний левый индекс подстроки в большей строке.

  fullstring = "StackAbuse"
substring = "закрепка"

если fullstring.find (подстрока)! = -1:
    print ("Найдено!")
еще:
    print ("Не найдено!")
  

Ознакомьтесь с нашим практическим практическим руководством по изучению Git, содержащим лучшие практики, принятые в отрасли стандарты и прилагаемую шпаргалку.Прекратите гуглить команды Git и на самом деле выучите его!

Если вы предпочитаете избегать необходимости отлавливать ошибки, то этому методу следует отдать предпочтение, а не index () .

Регулярные выражения (RegEx)

Регулярные выражения предоставляют более гибкий (хотя и более сложный) способ проверки строк на соответствие шаблону. Python поставляется со встроенным модулем для регулярных выражений, который называется re . Модуль re содержит функцию под названием search () , которую мы можем использовать для сопоставления с шаблоном подстроки:

  из поиска re import

fullstring = "StackAbuse"
substring = "закрепка"

при поиске (подстрока, полная строка):
    печать "Найдено!"
еще:
    печать "Не найдено!"
  

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

Об авторе

Эта статья была написана Якобом Стопаком, консультантом по программному обеспечению и разработчиком, страстно желающим помогать другим улучшить свою жизнь с помощью кода. Джейкоб является создателем Initial Commit — сайта, посвященного тому, чтобы помочь любознательным разработчикам узнать, как написаны их любимые программы. Его избранный проект помогает людям изучать Git на уровне кода.

Есть ли в Python строковый метод подстроки?

Есть ли у Python строка, содержащая метод подстроки?

99% вариантов использования будут охвачены с помощью ключевого слова в , которое возвращает True или False :

  'подстрока' в any_string
  

Для получения индекса используйте str.найти (который возвращает -1 в случае неудачи и имеет необязательные позиционные аргументы):

  начало = 0
stop = len (любая_строка)
any_string.find ('подстрока', начало, остановка)
  

или str.index (например, находит , но вызывает ValueError при сбое):

  начало = 100
конец = 1000
any_string.index ('подстрока', начало, конец)
  

Пояснение

Используйте в операторе сравнения , потому что

  1. язык предполагает его использование, а
  2. другие программисты Python будут ожидать, что вы его воспользуетесь.
  >>> 'foo' в '** foo **'
Правда
  

Противоположное (дополнение), которое задано в исходном вопросе, это , а не :

.
  >>> 'foo' not in '** foo **' # возвращает False
Ложь
  

Это семантически то же самое, что not 'foo' в '** foo **' , но гораздо более читабельно и явно предусмотрено в языке как улучшение читаемости.

Избегайте использования

__contains__

Метод «содержит» реализует поведение для в .В этом примере

  str .__ содержит __ ('** foo **', 'foo')
  

возвращает True . Вы также можете вызвать эту функцию из экземпляра суперстроки:

  '** foo **' .__ содержит __ ('foo')
  

Но не надо. Методы, начинающиеся с подчеркивания, считаются семантически закрытыми. Единственная причина использовать это — при реализации или расширении в и не в функциональности (например, при создании подкласса str ):

  класс NoisyString (str):
    def __contains __ (self, other):
        print (f'testing if "{other}" in "{self}" ')
        вернуть super (NoisyString, self).__contains __ (другое)

ns = NoisyString ('строка с подстрокой внутри')
  

и сейчас:

  >>> 'подстрока' в нс
проверка, если "подстрока" в "строке с подстрокой внутри"
Правда
  

Не используйте

найдите и индекс для проверки «содержит»

Не используйте следующие строковые методы для проверки «содержит»:

  >>> '** foo **'. Index ('foo')
2
>>> '** фу **'. найти ('фу')
2

>>> '** оо **'.найти ('фу')
-1
>>> '** oo **'. index ('фу')

Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    '** оо **'. index ('фу')
ValueError: подстрока не найдена
  

Другие языки могут не иметь методов для непосредственного тестирования подстрок, поэтому вам придется использовать эти типы методов, но с Python гораздо эффективнее использовать оператор сравнения in .

Кроме того, они не являются заменой для из .Возможно, вам придется обработать исключение или случаи -1 , и если они вернут 0 (потому что они нашли подстроку в начале), логическая интерпретация будет False вместо True .

Если вы действительно имеете в виду , а не any_string.startswith (substring) , то скажите это.

Сравнение производительности

Мы можем сравнить различные способы достижения одной и той же цели.

  импортное время

def in_ (s, другой):
    вернуть другой в с

def содержит (s, other):
    вернуться с.__contains __ (другое)

def find (s, other):
    вернуть s.find (другое)! = -1

def index (s, other):
    пытаться:
        s.index (другое)
    кроме ValueError:
        вернуть ложь
    еще:
        вернуть True



perf_dict = {
'in: True': min (timeit.repeat (lambda: in _ ('superstring', 'str'))),
'in: False': min (timeit.repeat (lambda: in _ ('superstring', 'not'))),
'__contains __: True': min (timeit.repeat (lambda: contains ('superstring', 'str'))),
'__contains __: False': min (timeit.repeat (lambda: contains ('superstring', 'not'))),
'find: True': min (timeit.повторить (лямбда: найти ('суперстрока', 'str'))),
'find: False': min (timeit.repeat (lambda: find ('superstring', 'not'))),
'index: True': min (timeit.repeat (lambda: index ('superstring', 'str'))),
'index: False': min (timeit.repeat (lambda: index ('superstring', 'not'))),
}
  

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

  >>> perf_dict
{'in: True': 0,16450627865128808,
 'in: False': 0.1609668098178645,
 '__contains __: True': 0.24355481654697542,
 '__contains __: False': 0,24382793854783813,
 'find: True': 0,3067379407923454,
 'find: False': 0,29860888058124146,
 'index: True': 0,29647137792585454,
 index: False: 0.5502287584545229}
  

Как может

в быть быстрее, чем __contains__ , если в использует __contains__ ?

Это прекрасный дополнительный вопрос.

Разберем функции интересующими методами:

  >>> из dis import dis
>>> dis (лямбда: 'а' в 'б')
  1 0 LOAD_CONST 1 ('a')
              2 LOAD_CONST 2 ('b')
              4 COMPARE_OP 6 (дюйм)
              6 RETURN_VALUE
>>> dis (лямбда: 'b'.__содержит __ ('а'))
  1 0 LOAD_CONST 1 ('b')
              2 LOAD_METHOD 0 (__contains__)
              4 LOAD_CONST 2 ('a')
              6 CALL_METHOD 1
              8 RETURN_VALUE
  

, поэтому мы видим, что метод .__ contains__ нужно искать отдельно, а затем вызывать из виртуальной машины Python — это должно адекватно объяснить разницу.

Сложность

— время выполнения подстроки python if в строке

Временная сложность в среднем составляет O (N), в худшем случае O (NM) (N — длина более длинной строки, M — более короткая строка, которую вы ищете).Начиная с Python 3.10, эвристика используется для понижения наихудшего сценария до O (N + M) путем переключения алгоритмов.

Тот же алгоритм используется для str.index () , str.find () , str .__ содержит __ () ( в операторе ) и str.replace () ; это упрощение алгоритма Бойера-Мура с идеями, взятыми из алгоритмов Бойера – Мура – ​​Хорспула и Сандей.

См. Исходный пост обсуждения stringlib , а также быстрый поиск .исходный код h ; до Python 3.10 базовый алгоритм не менялся с момента появления в Python 2.5 (за исключением некоторых оптимизаций на низком уровне и угловых исправлений).

Пост включает в себя схему алгоритма Python-кода:

  def найти (s, p):
    # найти первое вхождение p в s
    n = len (s)
    m = len (p)
    skip = delta1 (p) [p [m-1]]
    я = 0
    в то время как я <= n-m:
        если s [i + m-1] == p [m-1]: # (Бойер-Мур)
            # потенциальное совпадение
            если s [i: i + m-1] == p [: m-1]:
                вернуться я
            если s [i + m] не входит в p:
                i = i + m + 1 # (воскресенье)
            еще:
                я = я + пропустить # (закуска)
        еще:
            # пропускать
            если s [i + m] не входит в p:
                i = i + m + 1 # (воскресенье)
            еще:
                я = я + 1
    return -1 # не найдено
  

, а также сравнение скоростей.

В Python 3.10 алгоритм был обновлен, чтобы использовать расширенную версию алгоритма двустороннего поиска Крокемора и Перрина для более крупных задач (с p и s длиннее 100 и 2100 символов, соответственно, с s по крайней мере в 6 раз длиннее, чем p ), в ответ на патологический крайний случай, о котором кто-то сообщил.

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

Добавить комментарий

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

© 2019 Штирлиц Сеть печатных салонов в Перми

Цифровая печать, цветное и черно-белое копирование документов, сканирование документов, ризография в Перми.