Python: Найти в списке

Я сталкивался с этим:

item = someSortOfSelection()
if item in myList:
    doMySpecialFunction(item)

но иногда это не работает со всеми моими элементами, как будто они не были распознаны в списке (когда это список строк).

Является ли это наиболее «питоническим» способом поиска элемента в списке if x in l:?

Что касается вашего первого вопроса: этот код прекрасно работает и должен работать, если itemравен одному из элементов внутри myList. Возможно, вы пытаетесь найти строку, которая не совсем соответствует одному из элементов, или, возможно, вы используете значение с плавающей запятой, которое страдает от неточности.

Что касается вашего второго вопроса: на самом деле есть несколько возможных способов «найти» вещи в списках.

Проверка, если что-то внутри

Это пример использования, который вы описываете: Проверка, находится ли что-то внутри списка или нет. Как вы знаете, вы можете использовать inоператор для этого:

3 in [1, 2, 3] # => True

Фильтрация коллекции

То есть поиск всех элементов в последовательности, которые удовлетворяют определенному условию. Для этого вы можете использовать списки или выражения генератора:

matches = [x for x in lst if fulfills_some_condition(x)]
matches = (x for x in lst if x > 6)

Последний вернет генератор, который вы можете представить как некий ленивый список, который будет создан только после того, как вы выполните его итерацию. Кстати, первый точно соответствует

matches = filter(fulfills_some_condition, lst)

в Python 2. Здесь вы можете увидеть функции высшего порядка в работе. В Python 3 filterвозвращает не список, а объект, похожий на генератор.

Нахождение первого вхождения

Если вам нужно только первое, что соответствует условию (но вы еще не знаете, что это такое), можно использовать цикл for (возможно, также с помощью elseпредложения, которое не очень хорошо известно). Вы также можете использовать

next(x for x in lst if ...)

который вернет первое совпадение или поднимет a, StopIterationесли ничего не найдено. Кроме того, вы можете использовать

next((x for x in lst if ...), [default value])

Нахождение местоположения предмета

Для списков есть также indexметод, который иногда может быть полезен, если вы хотите знать, где находится определенный элемент в списке:

[1,2,3].index(2) # => 1
[1,2,3].index(4) # => ValueError

Однако обратите внимание, что если у вас есть дубликаты, .indexвсегда возвращается самый низкий индекс: ......

[1,2,3,2].index(2) # => 1

Если есть дубликаты и вам нужны все индексы, вы можете использовать enumerate()вместо:

[i for i,x in enumerate([1,2,3,2]) if x==2] # => [1, 3]

Если вы хотите найти один элемент или Noneиспользовать по умолчанию next, он не будет вызываться, StopIterationесли элемент не найден в списке:

first_or_default = next((x for x in lst if ...), None)

Хотя ответ от Niklas B. довольно исчерпывающий, когда мы хотим найти элемент в списке, иногда бывает полезно получить его индекс:

next((i for i, x in enumerate(lst) if [condition on x]), [default value])

Нахождение первого вхождения

Есть рецепт для этого в itertools:

def first_true(iterable, default=False, pred=None):
    """Returns the first true value in the iterable.

    If no true value is found, returns *default*

    If *pred* is not None, returns the first item
    for which pred(item) is true.

    """
    # first_true([a,b,c], x) --> a or b or c or x
    # first_true([a,b], x, f) --> a if f(a) else b if f(b) else x
    return next(filter(pred, iterable), default)

Например, следующий код находит первое нечетное число в списке:

>>> first_true([2,3,4,5], None, lambda x: x%2==1)
3  

Другой вариант: вы можете проверить, есть ли элемент в списке if item in list:, но это порядок O (n). Если вы имеете дело с большими списками элементов, и все, что вам нужно знать, это то, является ли что-то членом вашего списка, вы можете сначала преобразовать список в набор и воспользоваться преимуществом поиска набора с постоянным временем :

my_set = set(my_list)
if item in my_set:  # much faster on average than using a list
    # do something

Не будет правильным решением в каждом случае, но в некоторых случаях это может повысить производительность.

Обратите внимание, что создание набора с помощью set(my_list)также является O (n), поэтому, если вам нужно сделать это только один раз, то делать это не быстрее. Если вам необходимо повторно проверять членство, тогда это будет O (1) для каждого поиска после создания этого начального набора.

Вы можете использовать один из двух возможных поисков при работе со списком строк:

1. если элемент списка равен элементу («example» находится в [«one», «example», «two»]):

   if item in your_list: some_function_on_true()

   'ex' в ['one', 'ex', 'two'] => True

   'ex_1' в ['one', 'ex', 'two'] => False

2. если элемент списка похож на элемент ('ex' находится в ['one,' example ',' two '] или' example_1 'находится в [' one ',' example ',' two ']):

   matches = [el for el in your_list if item in el]

   или

   matches = [el for el in your_list if el in item]

   затем просто проверьте len(matches)или прочитайте их, если это необходимо.

Определение и использование

count()метод возвращает количество элементов с заданным значением.

Синтаксис

list.count(value)

пример:

fruits = ['apple', 'banana', 'cherry']

x = fruits.count("cherry")

Пример вопроса:

item = someSortOfSelection()

if myList.count(item) >= 1 :

    doMySpecialFunction(item)

Вместо использования list.index(x)которого возвращает индекс x, если он найден в списке, или возвращает #ValueErrorсообщение, если x не найден, вы можете использовать list.count(x)метод, который возвращает число вхождений x в список (проверка того, что x действительно находится в списке), или его в противном случае возвращает 0 (при отсутствии x). Самое интересное в том, count()что он не нарушает ваш код и не требует от вас исключения, когда x не найден

Если вы собираетесь проверить, существует ли значение в предмете коллекционирования один раз, тогда лучше использовать оператор «in». Однако, если вы собираетесь проверять более одного раза, я рекомендую использовать модуль bisect. Имейте в виду, что при использовании модуля bisect данные должны быть отсортированы. Таким образом, вы сортируете данные один раз, а затем можете использовать bisect. Использование модуля bisect на моей машине примерно в 12 раз быстрее, чем использование оператора «in».

Вот пример кода с использованием синтаксиса Python 3.8 и выше:

import bisect
from timeit import timeit

def bisect_search(container, value):
    return (
      (index := bisect.bisect_left(container, value)) < len(container) 
      and container[index] == value
    )

data = list(range(1000))
# value to search
true_value = 666
false_value = 66666

# times to test
ttt = 1000

print(f"{bisect_search(data, true_value)=} {bisect_search(data, false_value)=}")

t1 = timeit(lambda: true_value in data, number=ttt)
t2 = timeit(lambda: bisect_search(data, true_value), number=ttt)

print("Performance:", f"{t1=:.4f}, {t2=:.4f}, diffs {t1/t2=:.2f}")

Вывод:

bisect_search(data, true_value)=True bisect_search(data, false_value)=False
Performance: t1=0.0220, t2=0.0019, diffs t1/t2=11.71

Убедитесь, что в элементах списка строк нет дополнительных / нежелательных пробелов. Это причина, которая может мешать объяснению предметов не может быть найдено.