Элегантный способ удалить элементы из последовательности в Python?

Два простых способа выполнить только фильтрацию:

1. Использование filter:

   names = filter(lambda name: name[-5:] != "Smith", names)

2. Использование списков:

   names = [name for name in names if name[-5:] != "Smith"]

Обратите внимание, что в обоих случаях сохраняются значения, для которых функция предиката оценивает True, поэтому вам нужно изменить логику (т.е. вы говорите «оставить людей, у которых нет фамилии Смит» вместо «удалить людей, у которых есть последние имя Смит ").

Редактировать Забавно ... два человека по отдельности опубликовали оба ответа, которые я предложил, когда я публиковал свой.

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

for name in reversed(names):
    if name[-5:] == 'Smith':
        names.remove(name)

Это имеет то преимущество, что он не создает новый список (например, filter или понимание списка) и использует итератор вместо копии списка (например, [:]).

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

Очевидный ответ - тот, который дал Джон и еще пара человек, а именно:

>>> names = [name for name in names if name[-5:] != "Smith"]       # <-- slower

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

>>> names[:] = (name for name in names if name[-5:] != "Smith")    # <-- faster

Назначение "names [:]" в основном означает "заменить содержимое списка имен следующим значением". Это отличается от простого присвоения имен тем, что не создает новый объект списка. Правая часть присваивания - это выражение генератора (обратите внимание на использование круглых скобок, а не квадратных скобок). Это заставит Python перебирать список.

Некоторое быстрое профилирование предполагает, что это примерно на 30% быстрее, чем подход с пониманием списка, и примерно на 40% быстрее, чем подход с фильтром.

Предостережение: хотя это решение быстрее, чем очевидное решение, оно более непонятно и основано на более продвинутых методах Python. Если вы все-таки используете, я рекомендую сопровождать его комментарием. Вероятно, его стоит использовать только в тех случаях, когда вы действительно заботитесь о производительности этой конкретной операции (что довольно быстро, несмотря ни на что). (В случае, когда я использовал это, я выполнял поиск луча A * и использовал его для удаления точек поиска из луча поиска.)

Использование понимания списка

list = [x for x in list if x[-5:] != "smith"]

Бывают случаи, когда фильтрация (с использованием фильтра или понимания списка) не работает. Это происходит, когда какой-либо другой объект содержит ссылку на список, который вы изменяете, и вам нужно изменить список на месте.

for name in names[:]:
    if name[-5:] == 'Smith':
        names.remove(name)

Единственное отличие от исходного кода - это использование names[:] вместо names в цикле for. Таким образом, код выполняет итерацию по (неглубокой) копии списка, и удаления работают, как ожидалось. Поскольку копирование списка неглубокое, оно довольно быстрое.

filter было бы здорово для этого. Простой пример:

names = ['mike', 'dave', 'jim']
filter(lambda x: x != 'mike', names)
['dave', 'jim']

Изменить: понимание списка Кори тоже потрясающее.

Оба решения, фильтр и понимание, требуют создания нового списка. Я недостаточно знаю внутреннее устройство Python, чтобы быть уверенным, но я думаю, что более традиционный (но менее элегантный) подход мог бы быть более эффективным:

names = ['Jones', 'Vai', 'Smith', 'Perez']

item = 0
while item <> len(names):
    name = names [item]
    if name=='Smith':
        names.remove(name)
    else:
        item += 1

print names

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

Чтобы ответить на ваш вопрос о работе со словарями, обратите внимание, что Python 3.0 будет включать понимание словаря:

>>> {i : chr(65+i) for i in range(4)}

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

>>> dict([(i, chr(65+i)) for i in range(4)])

Или как более прямой ответ:

dict([(key, name) for key, name in some_dictionary.iteritems if name[-5:] != 'Smith'])

Если список должен быть отфильтрован на месте, а размер списка довольно велик, то алгоритмы, упомянутые в предыдущих ответах, основанные на list.remove (), могут быть неподходящими, поскольку их вычислительная сложность составляет O (n ^ 2) . В этом случае вы можете использовать следующую не очень питоническую функцию:

def filter_inplace(func, original_list):
  """ Filters the original_list in-place.

  Removes elements from the original_list for which func() returns False.

  Algrithm's computational complexity is O(N), where N is the size
  of the original_list.
  """

  # Compact the list in-place.
  new_list_size = 0
  for item in original_list:
    if func(item):
      original_list[new_list_size] = item
      new_list_size += 1

  # Remove trailing items from the list.
  tail_size = len(original_list) - new_list_size
  while tail_size:
    original_list.pop()
    tail_size -= 1


a = [1, 2, 3, 4, 5, 6, 7]

# Remove even numbers from a in-place.
filter_inplace(lambda x: x & 1, a)

# Prints [1, 3, 5, 7]
print a

Изменить: на самом деле решение на https://stackoverflow.com/a/4639748/274937 превосходит мое решение. Он более питонический и работает быстрее. Итак, вот новая реализация filter_inplace ():

def filter_inplace(func, original_list):
  """ Filters the original_list inplace.

  Removes elements from the original_list for which function returns False.

  Algrithm's computational complexity is O(N), where N is the size
  of the original_list.
  """
  original_list[:] = [item for item in original_list if func(item)]

Понимание фильтров и списков подходит для вашего примера, но у них есть пара проблем:

• Они делают копию вашего списка и возвращают новый, и это будет неэффективно, если исходный список действительно большой.
• Они могут быть очень громоздкими, когда критерии выбора предметов (в вашем случае, если name [-5:] == 'Smith') более сложны или имеют несколько условий.

Ваше исходное решение на самом деле более эффективно для очень больших списков, даже если мы можем согласиться, что оно уродливее. Но если вы беспокоитесь, что у вас может быть несколько 'John Smith', это можно исправить, удалив на основе позиции, а не значения:

names = ['Jones', 'Vai', 'Smith', 'Perez', 'Smith']

toremove = []
for pos, name in enumerate(names):
    if name[-5:] == 'Smith':
        toremove.append(pos)
for pos in sorted(toremove, reverse=True):
    del(names[pos])

print names

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

В случае набора.

toRemove = set([])  
for item in mySet:  
    if item is unwelcome:  
        toRemove.add(item)  
mySets = mySet - toRemove 

Вот моя filter_inplace реализация, которую можно использовать для фильтрации элементов из списка на месте. Я придумал это самостоятельно, до того, как нашел эту страницу. Это тот же алгоритм, что и опубликованный PabloG, только более общий, чтобы вы могли использовать его для фильтрации списков на месте, он также может удалять из списка на основе comparisonFunc, если установлено обратное True; своего рода обратный фильтр, если хотите.

def filter_inplace(conditionFunc, list, reversed=False):
    index = 0
    while index < len(list):
        item = list[index]

        shouldRemove = not conditionFunc(item)
        if reversed: shouldRemove = not shouldRemove

        if shouldRemove:
            list.remove(item)
        else:
            index += 1

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

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

edit: понимаешь, что он просил «эффективности» ... все эти предложенные методы просто перебирают список, что совпадает с тем, что он предложил.