[Python] Python에 문자열 '포함' 하위 문자열 메서드가 있습니까?

Python에서

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

. 이것은 당신이 원하는 것일 수도 있고 아닐 수도 있습니다.

 

Python에 문자열에 하위 문자열 메서드가 포함되어 있습니까?

사용 사례의 99% 는 또는 다음

in

을 반환 하는 키워드를 사용하여 처리됩니다.

True

False

'substring' in any_string

인덱스를 가져오는 사용 사례의 경우 다음을 사용합니다

str.find

(실패 시 -1을 반환하고 선택적 위치 인수가 있음).

start = 0
stop = len(any_string)
any_string.find('substring', start, stop)

또는

str.index

(비슷

find

하지만 실패 시 ValueError 발생):

start = 100 
end = 1000
any_string.index('substring', start, end)

설명

in

비교 연산자 를 사용 하기 때문에

1. 언어는 그 사용을 의도하고,
2. 다른 파이썬 프로그래머는 당신이 그것을 사용하기를 기대합니다.

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

원래 질문이 요구한 반대(보완)는

not in

다음과 같습니다.

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

이것은 의미상으로 동일

not 'foo' in '**foo**'

하지만 훨씬 더 읽기 쉽고 가독성 향상으로 언어에서 명시적으로 제공됩니다.

사용을 피하십시오__contains__

"포함" 메서드는 에 대한 동작을 구현합니다

in

. 이 예는,

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

반환합니다

True

. 슈퍼스트링의 인스턴스에서 이 함수를 호출할 수도 있습니다.

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

하지만 하지마. 밑줄로 시작하는 메서드는 의미상 비공개로 간주됩니다. 이것을 사용하는 유일한 이유는

in

및

not in

기능을 구현하거나 확장할 때입니다(예: 서브클래싱하는 경우

str

).

class NoisyString(str):
    def __contains__(self, other):
        print(f'testing if "{other}" in "{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

"contains"를 테스트하기 위해 findand 를 사용하지 마십시오 .index

다음 문자열 메서드를 사용하여 "포함"을 테스트하지 마세요.

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

비교 연산자를 사용하는 것이 훨씬 더 효율적입니다.또한 에 대한 드롭인 대체품이 아닙니다

in

. 예외 또는

-1

사례를 처리해야 할 수 있으며 반환되는 경우

0

(처음에 하위 문자열을 찾았기 때문에) 부울 해석

False

은

True

.진심

not any_string.startswith(substring)

이라면 말하세요.

성능 비교

우리는 같은 목표를 달성하는 다양한 방법을 비교할 수 있습니다.

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 를 사용하는 것보다 어떻게 in더 빠를 수 있습니까?__contains__in__contains__

이것은 좋은 후속 질문입니다.관심 있는 방법으로 함수를 분해해 보겠습니다.

>>> from dis import dis
>>> dis(lambda: 'a' in 'b')
  1           0 LOAD_CONST               1 ('a')
              2 LOAD_CONST               2 ('b')
              4 COMPARE_OP               6 (in)
              6 RETURN_VALUE
>>> dis(lambda: 'b'.__contains__('a'))
  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 가상 머신에서 호출해야 함을 알 수 있습니다. 이는 차이점을 적절하게 설명해야 합니다.