Ich suche eine string.containsoder string.indexofMethode in Python.

Ich will das tun:

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

Sie können den inOperator verwenden :

if "blah" not in somestring: 
    continue

Wenn es sich nur um eine Teilstringsuche handelt, können Sie diese verwenden string.find("substring").

Sie haben mit ein wenig vorsichtig sein find, indexund inwenn es , wie sie Suchen werden String. Mit anderen Worten:

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

Es würde Found 'is' in the string.ähnlich drucken , if "is" in s:würde auswerten True. Dies kann sein oder nicht, was Sie wollen.

Hat Python eine Zeichenfolge, die eine Teilzeichenfolgenmethode enthält?

Ja, aber Python verfügt über einen Vergleichsoperator, den Sie stattdessen verwenden sollten, da die Sprache ihre Verwendung beabsichtigt und andere Programmierer von Ihnen erwarten, dass Sie ihn verwenden. Das Schlüsselwort lautet in, das als Vergleichsoperator verwendet wird:

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

Das Gegenteil (Ergänzung), nach dem die ursprüngliche Frage fragt, ist not in:

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

Dies ist semantisch dasselbe wie, not 'foo' in '**foo**'aber es ist viel besser lesbar und in der Sprache explizit als Verbesserung der Lesbarkeit vorgesehen.

Vermeiden Sie __contains__, findundindex

Wie versprochen, hier ist die containsMethode:

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

kehrt zurück True. Sie können diese Funktion auch von der Instanz des Superstrings aus aufrufen:

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

Aber nicht. Methoden, die mit Unterstrichen beginnen, werden als semantisch privat betrachtet. Der einzige Grund, dies zu verwenden, ist die Erweiterung der inund not in-Funktionalität (z. B. bei Unterklassen 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')

und nun:

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

Vermeiden Sie außerdem die folgenden Zeichenfolgenmethoden:

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

In anderen Sprachen gibt es möglicherweise keine Methoden zum direkten Testen auf Teilzeichenfolgen. Daher müssten Sie diese Arten von Methoden verwenden. Mit Python ist es jedoch wesentlich effizienter, den inVergleichsoperator zu verwenden .

Leistungsvergleiche

Wir können verschiedene Wege vergleichen, um dasselbe Ziel zu erreichen.

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'))),
}

Und jetzt sehen wir, dass die Verwendung inviel schneller ist als die anderen. Weniger Zeit für eine gleichwertige Operation ist besser:

>>> 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:ist die normale Verwendung, wie @Michael sagt - sie basiert auf dem inOperator, ist lesbarer und schneller als ein Methodenaufruf.

Wenn Sie wirklich eine Methode anstelle eines Operators benötigen (z. B. um etwas Seltsames key=für eine sehr eigenartige Art zu tun ...?), Wäre dies der Fall 'haystack'.__contains__. Aber da dein Beispiel für die Verwendung in einem ist if, meinst du wohl nicht wirklich, was du sagst ;-). Es ist keine gute Form (weder lesbar noch effizient), spezielle Methoden direkt zu verwenden - sie sollen stattdessen über die Operatoren und integrierten Funktionen verwendet werden, die an sie delegieren.

in Python-Zeichenfolgen und -Listen

Hier einige nützliche Beispiele, die für die inMethode sprechen :

"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]

Vorbehalt. Listen sind iterable und die inMethode wirkt auf iterables, nicht nur auf Strings.

Wenn Sie zufrieden sind, "blah" in somestringaber möchten, dass es sich um einen Funktions- / Methodenaufruf handelt, können Sie dies wahrscheinlich tun

import operator

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

Alle Operatoren in Python befinden sich mehr oder weniger im Operatormodul einschließlich in.

Anscheinend gibt es nichts Vergleichbares für den vektorweisen Vergleich. Ein naheliegender Python-Weg wäre:

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

Sie können verwenden y.count().

Es wird der ganzzahlige Wert zurückgegeben, wie oft eine Unterzeichenfolge in einer Zeichenfolge angezeigt wird.

Zum Beispiel:

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

Hier ist deine Antwort:

if "insert_char_or_string_here" in "insert_string_to_search_here":
    #DOSTUFF

Um zu überprüfen, ob es falsch ist:

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

ODER:

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

Sie können reguläre Ausdrücke verwenden, um die Vorkommen abzurufen:

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