Domanda Python ha una stringa "contiene" metodo di sottostringa?


Sto cercando string.contains o string.indexof metodo in Python.

Voglio fare:

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

2868
2017-08-09 02:52


origine


risposte:


Puoi usare il in operatore:

if "blah" not in somestring: 
    continue

4346
2017-08-09 02:56



Se è solo una ricerca di sottostringa, puoi usare string.find("substring").

Devi essere un po 'attento con find, index, e in tuttavia, poiché sono ricerche di sottostringa. In altre parole, questo:

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

Stamperebbe Found 'is' in the string. Allo stesso modo, if "is" in s: valuterà a True. Questo può o non può essere quello che vuoi.


457
2017-08-09 02:55



if needle in haystack: è l'uso normale, come dice @Michael - si basa sul in operatore, più leggibile e più veloce di una chiamata al metodo.

Se hai veramente bisogno di un metodo invece di un operatore (ad esempio per fare qualche strano key= per un tipo molto particolare ...?), sarebbe 'haystack'.__contains__. Ma dal momento che il tuo esempio è per l'uso in un ifImmagino che tu non intenda davvero quello che dici ;-). Non è una buona forma (né leggibile, né efficiente) usare direttamente metodi speciali - sono pensati per essere usati, invece, attraverso gli operatori e i builtin che li delegano.


123
2017-08-09 03:19



Fondamentalmente, vuoi trovare una sottostringa in una stringa in python. Ci sono due modi per cercare una sottostringa in una stringa in Python.

Metodo 1: in operatore

Puoi usare Python in operatore per verificare una sottostringa. È abbastanza semplice e intuitivo. Ritornerà True se la sottostringa è stata trovata nella stringa else False.

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

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

Metodo 2: str.find() metodo

Il secondo metodo è usare il str.find() metodo. Qui, chiamiamo il .find() metodo sulla stringa in cui deve essere trovata la sottostringa. Passiamo la sottostringa al metodo find () e controlliamo il suo valore di ritorno. Se il suo valore è diverso da -1, la sottostringa è stata trovata nella stringa, altrimenti no. Il valore restituito è l'indice in cui è stata trovata la sottostringa.

>>> some_string = "valar morghulis"

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

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

Ti consiglierei di usare il primo metodo perché è più Pythonic e intuitivo.


98
2018-05-26 17:46



Python ha una stringa che contiene il metodo della sottostringa?

Sì, ma Python ha un operatore di confronto che dovresti usare, perché la lingua intende utilizzarlo e altri programmatori si aspettano che tu lo usi. Quella parola chiave è in, che viene utilizzato come operatore di confronto:

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

Il contrario (complemento), che la domanda originale richiede, è not in:

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

Questo è semanticamente lo stesso di not 'foo' in '**foo**' ma è molto più leggibile e esplicitamente previsto nella lingua come miglioramento della leggibilità.

Evitare di utilizzare __contains__, find, e index

Come promesso, ecco il contains metodo:

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

ritorna True. Puoi anche chiamare questa funzione dall'istanza della superstringa:

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

Ma non farlo. I metodi che iniziano con underscore sono considerati semanticamente privati. L'unica ragione per usarlo è quando estendi il file in e not in funzionalità (ad esempio se la sottoclasse 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')

e adesso:

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

Inoltre, evitare i seguenti metodi di stringa:

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

Altre lingue potrebbero non avere metodi per testare direttamente le sottostringhe, e quindi dovresti usare questi tipi di metodi, ma con Python è molto più efficiente usare il inoperatore di confronto.

Confronti delle prestazioni

Possiamo confrontare vari modi per raggiungere lo stesso obiettivo.

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

E ora lo vediamo usando in è molto più veloce degli altri. Meno tempo per fare un'operazione equivalente è meglio:

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

89
2017-11-25 22:33



No, non ce n'è string.contains(str) metodo, ma c'è il in operatore:

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

Ecco un esempio di lavoro più complesso:

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

61
2017-09-30 18:59



in Stringhe ed elenchi Python

Ecco alcuni esempi utili che parlano da soli riguardo al in metodo:

"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

Avvertimento. Le liste sono iterabili e in il metodo agisce su iterables, non solo stringhe.


31
2018-04-28 18:52



Quindi apparentemente non c'è nulla di simile per il confronto vettoriale. Un ovvio modo in Python per farlo sarebbe:

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

21
2017-07-17 13:19