파이썬에서 string.contains또는 string.indexof메소드를 찾고 있습니다.

나하고 싶어:

if not somestring.contains("blah"):
   continue

in연산자 를 사용할 수 있습니다 .

if "blah" not in somestring: 
    continue

하위 문자열 검색 인 경우을 사용할 수 있습니다 string.find("substring").

하위 문자열 검색 find이므로 index,에 약간주의해야합니다 in. 다시 말해, 이것은 :

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. 이것은 당신이 원하는 것일 수도 아닐 수도 있습니다.

파이썬에 문자열에 하위 문자열 방법이 있습니까?

그렇습니다.하지만 파이썬에는 언어를 사용하려고 의도하는 다른 연산자가 있습니다. 다른 프로그래머는 그 언어를 사용할 것으로 기대하기 때문입니다. 해당 키워드는 in비교 연산자로 사용됩니다.

>>> 'foo' in '**foo**'
True

원래 질문에서 요구하는 반대 (보완)는 not in다음과 같습니다.

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

이것은 의미 적으로 동일 not 'foo' in '**foo**'하지만 가독성 향상으로 언어에서 훨씬 더 읽기 쉽고 명확하게 제공됩니다.

사용하지 마십시오 __contains__, find그리고index

약속 한대로 contains방법은 다음과 같습니다.

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

을 반환합니다 True. 수퍼 스트링 인스턴스에서이 함수를 호출 할 수도 있습니다.

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

그러나하지 마십시오. 밑줄로 시작하는 메소드는 의미 상 개인용으로 간주됩니다. 이것을 사용하는 유일한 이유는 inand 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에서는 in비교 연산자 를 사용하는 것이 훨씬 효율적 입니다.

성능 비교

동일한 목표를 달성하는 다양한 방법을 비교할 수 있습니다.

import timeit

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



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.repeat(lambda: find('superstring', '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'))),
}

그리고 이제 우리 in는 다른 것보다 사용 속도가 훨씬 빠릅니다. 동등한 작업을 수행하는 데 걸리는 시간이 짧을수록 좋습니다.

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

if needle in haystack:@Michael이 말한 것처럼 일반적인 사용법입니다- in메소드 호출보다 더 읽기 쉽고 빠릅니다.

연산자 대신 메소드가 정말로 필요하다면 (예를 들어 key=매우 특이한 종류의 경우 이상한 것을 원한다면 ...?), 그럴 것입니다 'haystack'.__contains__. 그러나 귀하의 예는에서 사용하기 if때문에 실제로 당신이 말하는 것을 의미하지는 않습니다 ;-). 특수한 메소드를 직접 사용하는 것은 좋은 형태 (읽기 어렵거나 효율적이지 않음)가 아닙니다. 대신에 메소드를 위임하는 연산자와 내장을 통해 사용되어야합니다.

in 파이썬 문자열과리스트

다음은이 in방법과 관련하여 유용한 몇 가지 유용한 예입니다 .

"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

["foo" in a for a in ["fo", "o", "foobar"]]
[False, False, True]

경고. 리스트는 반복 가능하며, in메소드는 문자열뿐만 아니라 반복 가능에 작용합니다.

당신이 만족 "blah" in somestring하지만 그것이 함수 / 메소드 호출이기를 원한다면, 아마도 이것을 할 수 있습니다.

import operator

if not operator.contains(somestring, "blah"):
    continue

파이썬의 모든 연산자는를 포함 하여 연산자 모듈 에서 다소 찾을 수 있습니다 in.

따라서 벡터와 비교하기에는 비슷한 것이 없습니다. 그렇게하는 명백한 파이썬 방법은 다음과 같습니다.

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

사용할 수 있습니다 y.count().

하위 문자열이 문자열에 나타나는 횟수의 정수 값을 반환합니다.

예를 들면 다음과 같습니다.

string.count("bah") >> 0
string.count("Hello") >> 1

답은 다음과 같습니다.

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

정규식을 사용하여 어커런스를 얻을 수 있습니다.

>>> import re
>>> print(re.findall(r'( |t)', to_search_in)) # searches for t or space
['t', ' ', 't', ' ', ' ']