Ich suche nach einer string.contains
- oder string.indexof
-Methode in Python.
Ich will das tun:
if not somestring.contains("blah"):
continue
Sie können den Operator in
verwenden:
if "blah" not in somestring:
continue
Wenn es sich nur um eine Teilzeichenfolge handelt, können Sie string.find("substring")
verwenden.
Sie müssen jedoch mit find
, index
und in
etwas vorsichtig sein, 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.
ausgeben. Ähnlich würde if "is" in s:
zu True
ausgewertet werden. Dies kann oder nicht das sein, was Sie wollen.
if needle in haystack:
ist die übliche Verwendung, wie @Michael sagt - der Operator in
ist lesbarer und schneller als ein Methodenaufruf.
Wenn Sie wirklich eine Methode anstelle eines Operators benötigen (z. B. um seltsame key=
für eine sehr spezielle Sortierung auszuführen ...?), Wäre dies 'haystack'.__contains__
. Da Ihr Beispiel jedoch für eine if
verwendet wird, 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.
Grundsätzlich möchten Sie in Python einen Teilstring in einem String suchen. Es gibt zwei Möglichkeiten, in Python nach einem Teilstring in einem String zu suchen.
Methode 1: in
Operator
Sie können den Operator in
des Pythons verwenden, um nach einer Teilzeichenfolge zu suchen. Es ist ganz einfach und intuitiv. Es wird True
zurückgegeben, wenn die Teilzeichenfolge in der Zeichenfolge else False
gefunden wurde.
>>> "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 den String auf, in dem der Teilstring 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.
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 von Ihnen erwarten, dass Sie ihn verwenden. Dieses Schlüsselwort ist in
, das als Vergleichsoperator verwendet wird:
>>> 'foo' in '**foo**'
True
Das Gegenteil (Komplement), das die ursprüngliche Frage verlangt, ist 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 vorgesehen, um die Lesbarkeit zu verbessern.
__contains__
, find
und index
Wie versprochen, hier ist die contains
-Methode:
str.__contains__('**foo**', 'foo')
gibt True
zurück. 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 Funktionen in
und not in
(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 zum direkten Testen auf Teilzeichenfolgen. Daher müssen Sie diese Arten von Methoden verwenden. Mit Python ist es jedoch viel effizienter, den Vergleichsoperator in
zu verwenden.
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 von in
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}
Nein, es gibt keine string.contains(str)
-Methode, aber es gibt den Operator in
:
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-Strings und -ListenHier einige nützliche Beispiele, die für die in
-Methode 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
Vorbehalt. Listen sind iterierbare Elemente, und die in
-Methode wirkt auf iterierbare Elemente und nicht nur auf Zeichenfolgen.
Es gibt also anscheinend nichts Vergleichbares für den vektoriellen 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
Eine andere Möglichkeit, mit dem booleschen Rückgabewert (z. B. True
oder `False) festzustellen, 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
Sie können y.count()
verwenden
es wird der ganzzahlige Wert der Häufigkeit zurückgegeben, mit der eine Unterzeichenfolge in einer Zeichenfolge angezeigt wird.
Z.B:
string.count("bah") >> 0
string.count("Hello") >> 1
Wenn Sie mit "blah" in somestring
zufrieden sind, aber 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
.
In Python gibt es zwei einfache Möglichkeiten, dies zu erreichen:
Der pythonische Weg: Verwenden von Pythons 'in' Keyword-
in
nimmt zwei "Argumente", eines links (substring) und eines rechts, und gibt True
zurück, wenn das linke Argument im Argument rechtsseitig enthalten ist. Wenn nicht, wird False
zurückgegeben.
example_string = "This is an example string"
substring = "example"
print(substring in example_string)
Ausgabe:
True
Der nicht-pythonische Weg: Verwenden von Pythons str.find:
Die find
-Methode gibt die Position des Strings innerhalb des Strings oder -1 zurück, wenn er 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 das Schlüsselwort 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 in
die schnellste Methode, um einen Teilstring zu finden ...
find
ist etwas schneller als index
.
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
Es gibt vier einfachste Methoden, um herauszufinden, was der Teilstring ist und wo der Teilstring beginnt.
Der erste ist über den Operator Python
in
:
someString = "Polly is drinking Coca-Cola."
"Coca-Cola" in someString
# Result: True
"Pepsi" in someString
# Result: False
Die zweite Möglichkeit ist die Verwendung der Zeichenfolge
find()
.
Im Gegensatz zum Operatorin
, der mit einem boolean -Wert ausgewertet wird, gibt diefind
-Methode eine Integer zurück. Diese Ganzzahl ist der Index des Beginns einer Teilzeichenfolge, falls diese Teilzeichenfolge vorhanden ist. Andernfalls wird -1
zurückgegeben. So funktioniert das:
someString = "Polly is drinking Coca-Cola."
someString.find("is")
# Result: 6
someString.find("Pepsi")
# Result: -1
someString.find("Polly")
# Result: 0
Sie können auch Start- und Endindizes angeben, um Ihre Suche einzuschränken. Zum Beispiel:
someString = "Polly is drinking Coca-Cola."
someString.find("is", 5, 10)
# Result: 6
someString.find("Polly", 15, 20)
# Result: -1
Dritte. Und natürlich können Sie die Anweisung
if...is not
verwenden (dies funktioniert in Python 2.7 und 3.6):
someString = "Polly is drinking Coca-Cola."
substring = "drinking"
if someString.find(substring) is not -1:
print("Cool! Python found the desired substring!")
else:
print("Python didn't find the desired substring!")
# Result: "Cool! Python found the desired substring!"
Vier Verwenden Sie die Methode
index()
. Es ist fast das gleiche wie diefind()
-Methode.
someString = "Polly is drinking Coca-Cola."
x = someString.index("drinking")
print(x)
# Result: 9
Hoffe das hilft.
Wenn Sie nach Groß- und Kleinschreibung suchen, suchen Sie nach ganzen Wörtern und nicht nach einem in einem anderen Wort enthaltenen Teilstring:
import string
s = 'This is my text example'
if 'is' not in (Word.lower()
for split_char in string.punctuation + string.whitespace
for Word in s.split(split_char)):
# do something
Wie bereits erwähnt, können Sie den Operator in
folgendermaßen verwenden:
>>> to_search_in = "String to search in"
>>> to_search = "search"
>>> print(to_search in to_search_in)
True
>>> print(to_search_in.find(to_search))
10
Sie können auch 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', ' ', ' ']
Es gibt viele Antworten.
Die Verwendung von count
kann auch praktisch sein.
Beispiel:
strblah = 'I have blah in me'
if strblah.count('blah') > 0:
print('Yes: substring found')