Sprawdź, czy element listy Python zawiera łańcuch wewnątrz innego łańcucha

Mam listę:

my_list = ['abc-123', 'def-456', 'ghi-789', 'abc-456']

i chcesz wyszukać elementy zawierające ciąg 'abc'. Jak mogę to zrobić?

if 'abc' in my_list:

by sprawdzić, czy 'abc'istnieje na liście, ale to jest częścią 'abc-123'i 'abc-456', 'abc'nie istnieje na własną rękę. Jak mogę zdobyć wszystkie przedmioty, które zawierają 'abc'?

Jeśli chcesz tylko sprawdzić obecność abcdowolnego ciągu na liście, możesz spróbować

some_list = ['abc-123', 'def-456', 'ghi-789', 'abc-456']
if any("abc" in s for s in some_list):
    # whatever

Jeśli naprawdę chcesz uzyskać wszystkie elementy zawierające abc, użyj

matching = [s for s in some_list if "abc" in s]

Po prostu to wyrzucamy: jeśli na przykład musisz dopasować więcej niż jeden ciąg abc i defmożesz połączyć dwa wyrażenia w następujący sposób:

matchers = ['abc','def']
matching = [s for s in my_list if any(xs in s for xs in matchers)]

Wynik:

['abc-123', 'def-456', 'abc-456']

Użyj, filteraby dostać się do elementów, które mają abc.

>>> lst = ['abc-123', 'def-456', 'ghi-789', 'abc-456']
>>> print filter(lambda x: 'abc' in x, lst)
['abc-123', 'abc-456']

Możesz także użyć listy.

>>> [x for x in lst if 'abc' in x]

Nawiasem mówiąc, nie używaj tego słowa listjako nazwy zmiennej, ponieważ jest ono już używane dla tego listtypu.

Jeśli potrzebujesz tylko wiedzieć, czy „abc” jest w jednym z elementów, jest to najkrótsza droga:

if 'abc' in str(my_list):

To dość stare pytanie, ale oferuję tę odpowiedź, ponieważ poprzednie odpowiedzi nie dotyczą elementów na liście, które nie są łańcuchami (lub jakimś obiektem iterowalnym). Takie pozycje spowodowałyby niepowodzenie pełnego zrozumienia listy z wyjątkiem.

Aby z wdziękiem radzić sobie z takimi elementami na liście, pomijając elementy, które nie są iterowalne, użyj następujących czynności:

[el for el in lst if isinstance(el, collections.Iterable) and (st in el)]

następnie z taką listą:

lst = [None, 'abc-123', 'def-456', 'ghi-789', 'abc-456', 123]
st = 'abc'

nadal otrzymasz pasujące przedmioty (['abc-123', 'abc-456'] )

Test iterowalności może nie być najlepszy. Mam to stąd: w Pythonie, jak ustalić, czy obiekt jest iterowalny?

x = 'aaa'
L = ['aaa-12', 'bbbaaa', 'cccaa']
res = [y for y in L if x in y]

for item in my_list:
    if item.find("abc") != -1:
        print item

any('abc' in item for item in mylist)

Użyj __contains__()metody klasy łańcuchowej Python:

a = ['abc-123', 'def-456', 'ghi-789', 'abc-456']
for i in a:
    if i.__contains__("abc") :
        print(i, " is containing")

Jestem nowy w Pythonie. Poniższy kod działał i ułatwiłem zrozumienie:

my_list = ['abc-123', 'def-456', 'ghi-789', 'abc-456']
for str in my_list:
    if 'abc' in str:
       print(str)

my_list = ['abc-123', 'def-456', 'ghi-789', 'abc-456']

for item in my_list:
    if (item.find('abc')) != -1:
        print ('Found at ', item)

mylist=['abc','def','ghi','abc']

pattern=re.compile(r'abc') 

pattern.findall(mylist)

Przeprowadziłem wyszukiwanie, które wymaga wprowadzenia określonej wartości, a następnie wyszuka wartość z listy zawierającej dane wejściowe:

my_list = ['abc-123',
        'def-456',
        'ghi-789',
        'abc-456'
        ]

imp = raw_input('Search item: ')

for items in my_list:
    val = items
    if any(imp in val for items in my_list):
        print(items)

Spróbuj wyszukać „abc”.

def find_dog(new_ls):
    splt = new_ls.split()
    if 'dog' in splt:
        print("True")
    else:
        print('False')


find_dog("Is there a dog here?")

Potrzebowałem indeksów listy, które odpowiadają dopasowaniu w następujący sposób:

lst=['abc-123', 'def-456', 'ghi-789', 'abc-456']

[n for n, x in enumerate(lst) if 'abc' in x]

wynik

[0, 3]

Pytanie: Podaj informacje abc

    a = ['abc-123', 'def-456', 'ghi-789', 'abc-456']


    aa = [ string for string in a if  "abc" in string]
    print(aa)

Output =>  ['abc-123', 'abc-456']

Z mojej wiedzy stwierdzenie „za” zawsze pochłania czas.

Gdy długość listy rośnie, czas wykonania również rośnie.

Myślę, że wyszukiwanie podłańcucha w łańcuchu za pomocą instrukcji „is” jest nieco szybsze.

In [1]: t = ["abc_%s" % number for number in range(10000)]

In [2]: %timeit any("9999" in string for string in t)
1000 loops, best of 3: 420 µs per loop

In [3]: %timeit "9999" in ",".join(t)
10000 loops, best of 3: 103 µs per loop

Ale zgadzam się, że anyoświadczenie jest bardziej czytelne.