string prüfen - Verfügt Python über eine Zeichenfolge, die eine Zeichenfolge enthält?




auf contains (13)

Es gibt also anscheinend nichts Vergleichbares für den vektoriellen Vergleich. Eine naheliegende Python-Methode 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

Ich suche nach einer string.contains oder string.indexof Methode in Python.

Ich will das tun:

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

Grundsätzlich möchten Sie eine Teilzeichenfolge in einer Zeichenfolge in Python suchen. Es gibt zwei Möglichkeiten, in Python nach einem Teilstring in einem String zu suchen.

Methode 1: in Operator

Sie können den in Operator von Python's verwenden, um nach einer Teilzeichenfolge zu suchen. Es ist ganz einfach und intuitiv. Es wird True wenn die Teilzeichenfolge in der Zeichenfolge gefunden wurde, sonst False .

>>> "King" in "King's landing"
True

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

Methode 2: str.find() -Methode

Die zweite Methode ist die Verwendung der str.find() -Methode. Hier rufen wir die .find() -Methode für die Zeichenfolge auf, in der die .find() gefunden werden soll. Wir übergeben den Teilstring an die find () - Methode und prüfen den Rückgabewert. Wenn der Wert nicht -1 ist, wurde die Teilzeichenfolge in der Zeichenfolge gefunden, andernfalls nicht. Der zurückgegebene Wert ist der Index, in dem die Teilzeichenfolge gefunden wurde.

>>> some_string = "valar morghulis"

>>> some_string.find("morghulis")
6

>>> some_string.find("dohaeris")
-1

Ich würde Ihnen empfehlen, die erste Methode zu verwenden, da diese mehr Pythonic und intuitiver ist.


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

if needle in haystack: ist die normale Verwendung, wie @Michael sagt - sie ist auf den in Operator angewiesen, lesbarer und schneller als ein Methodenaufruf.

Wenn Sie wirklich eine Methode anstelle eines Operators benötigen (z. B. um einen seltsamen key= für eine sehr 'haystack'.__contains__ Sortierung zu tun ...?), 'haystack'.__contains__ . Aber da Ihr Beispiel für ein if , meinen Sie wahrscheinlich nicht wirklich, was Sie sagen ;-). Es ist weder in guter Form (noch lesbar noch effizient), spezielle Methoden direkt zu verwenden. Sie werden stattdessen von den Operatoren und eingebauten Funktionen verwendet, die sie an sie delegieren.


Eine andere Möglichkeit, mit dem booleschen Rückgabewert (z. B. True oder `False) zu ermitteln, ob eine Zeichenfolge einige Zeichen enthält oder nicht:

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


Nein, es gibt keine string.contains(str) -Methode, aber es gibt den in Operator:

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

Hier ist ein komplexeres Arbeitsbeispiel:

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

In Python gibt es zwei einfache Möglichkeiten, dies zu erreichen:

Der pythonische Weg: Verwenden von Python's 'in' Keyword-

in nimmt zwei "Argumente", eines links ( Teilstring ) und eines rechts, und gibt " True wenn das linke Argument im Argument "Rightside" enthalten ist. Wenn nicht, wird " False .

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

Ausgabe:

True

Der nicht-pythonische Weg: Pythons str.find verwenden:

Die find Methode gibt die Position der Zeichenfolge innerhalb der Zeichenfolge zurück oder -1, wenn sie nicht gefunden wird. Prüfen Sie einfach, ob die Position nicht -1 ist.

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

Ausgabe:

Substring found!

Ich sehe, dass es bereits Antworten gibt, aber ich möchte auch meine zwei Cents hinzufügen.

In Python gibt es Funktionen, die dies tun, aber die einfachste (und meist bevorzugte) Methode ist die Verwendung des Schlüsselworts in :

"test" in "testtext"
True

"abc" in "abcdefg"
True

"abc" in "Abc"
False

"ABC" in "abc"
False

"abc" in "def"
False

"abc" in ["abc", "def", "ghi"]
True

Es gibt auch einige String-Methoden:

"xxabcxx".find("abc")
2 #returns the index of the first match

"xxabcxx".find("cde")
-1 #returns -1 if the substring 
#could not be found in the string

# and:

"xxabcxx".index("abc")
2

"xxabcxx".index("cde")
ValueError: substring not found
#raises ValueError...

Über die Leistung:

Im Allgemeinen ist es die schnellste Methode, einen Teilstring zu finden ...

find ist etwas schneller als index

Hoffe ich könnte helfen!


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

Ja, aber Python hat einen Vergleichsoperator, den Sie stattdessen verwenden sollten, da die Sprache die Verwendung beabsichtigt, und andere Programmierer erwarten, dass Sie ihn verwenden. Dieses Schlüsselwort ist in und wird als Vergleichsoperator verwendet:

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

Das Gegenteil (Ergänzung), das die ursprüngliche Frage verlangt, lautet not in :

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

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

Vermeiden Sie die Verwendung von __contains__ , find und index

Wie versprochen, ist hier die Methode enthalten:

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

gibt 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 in und not in Funktionalität (z. B. bei der Unterklasse 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 auch die folgenden String-Methoden:

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

Andere Sprachen verfügen möglicherweise über keine Methoden, um direkt auf Teilzeichenfolgen zu testen. Daher müssen Sie diese Arten von Methoden verwenden. Mit Python ist es jedoch viel effizienter, den in Vergleich-Operator zu verwenden.

Leistungsvergleiche

Wir können verschiedene Möglichkeiten 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 viel 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}

Wenn Sie mit "blah" in somestring und einen Funktionsaufruf wünschen, können Sie dies wahrscheinlich tun

import operator

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

Alle Operatoren in Python können mehr oder weniger im Operator-Modul gefunden werden, einschließlich in .


Wenn es sich nur um eine string.find("substring") können Sie string.find("substring") .

Sie müssen ein wenig vorsichtig mit find , index und in , da sie Teilstringsuchen sind. 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. drucken Found 'is' in the string. if "is" in s: würde dies ebenfalls als " True if "is" in s: ausgewertet werden. Dies kann oder nicht das sein, was Sie wollen.


Ja, mit dem staticmethod Dekorateur

class MyClass(object):
    @staticmethod
    def the_static_method(x):
        print x

MyClass.the_static_method(2) # outputs 2

Beachten Sie, dass einige Codes möglicherweise die alte Methode zum Definieren einer statischen Methode verwenden, wobei staticmethod als Funktion und nicht als Dekorator verwendet wird. Dies sollte nur verwendet werden, wenn Sie alte Versionen von Python (2.2 und 2.3) unterstützen müssen

class MyClass(object):
    def the_static_method(x):
        print x
    the_static_method = staticmethod(the_static_method)

MyClass.the_static_method(2) # outputs 2

Dies ist völlig identisch mit dem ersten Beispiel (mit @staticmethod ), nur nicht mit der netten Dekoratorsyntax

Verwenden Sie staticmethod sparsam! Es gibt sehr wenige Situationen, in denen statische Methoden in Python notwendig sind, und ich habe sie oft benutzt, wo eine separate "Top-Level" -Funktion klarer gewesen wäre.

staticmethod :

Eine statische Methode erhält kein implizites erstes Argument. Verwenden Sie dieses Idiom, um eine statische Methode zu deklarieren:

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

Das @ staticmethod-Formular ist ein Funktionsdecorator - Details finden Sie in der Beschreibung der Funktionsdefinitionen in Funktionsdefinitionen .

Es kann entweder für die Klasse (wie Cf() ) oder für eine Instanz (wie C().f() ) aufgerufen werden. Die Instanz wird außer für ihre Klasse ignoriert.

Die statischen Methoden in Python ähneln denen in Java oder C ++. Für ein fortgeschrittenes Konzept, siehe classmethod() .

Weitere Informationen zu statischen Methoden finden Sie in der Dokumentation zur Standardtyphierarchie unter Standardhierarchie .

Neu in Version 2.2.

Geändert in Version 2.4: Syntax der Funktion Decorator hinzugefügt.





python string substring contains