Как удалить повторяющиеся элементы в списке python

Удалить дубликаты элементов из списка в Python

В этой статье мы посмотрим, как мы можем удалить дубликаты элементов из списка в Python. Есть несколько способов приближения этой проблемы, и мы покажем

Удалить дубликаты элементов из списка в Python

В этой статье мы посмотрим, как мы можем удалить дубликаты элементов из списка в Python. Есть несколько способов приближения этой проблемы, и мы покажем вам некоторые из них.

Методы удаления дубликатов элементов из списка – Python

1. Использование итерации

Чтобы удалить дубликаты элементов из списка в Python, мы можем вручную повторить через список и добавить элемент в новый список, если оно нет. В противном случае мы пропускаем этот элемент.

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

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

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

2. Использование набора ()

Простой и быстрый подход для удаления дубликатов элементов из списка в Python будет использовать встроенный Python Установить () Способ преобразования элементов списка в уникальный набор, следующий, который мы можем преобразовать его в список, теперь удаляемую все его дубликаты элементов.

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

3. Консервирующий заказ: используйте заказ

Если вы хотите сохранить заказ, пока вы удаляете дубликаты элементов из списка в Python, вы можете использовать ЗаказДикт класс от Коллекции модуль.

Более конкретно, мы можем использовать Underduddict.Fromkeys (Список) Для получения словаря, имеющего дублирующие элементы удалены, пока все еще поддерживая порядок. Затем мы можем легко легко Преобразовать его в список используя Список () метод.

Примечание : Если у вас есть Python 3.7 Или позже мы можем использовать встроенные Dict.Fromkeys (список) вместо. Это также гарантирует заказ.

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

4. Использование list.Count ()

list.Count () Метод возвращает количество вхождений значения. Мы можем использовать его вместе с Удалить () Способ устранения любых дубликатов элементов. Но опять же, это делает не сохранить заказ.

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

Все кажется хорошо, не так ли?

Но есть небольшая проблема с вышеуказанным кодом.

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

Выход :

Вы можете видеть, что цикл для цикла выполняется всего в четыре раза, и он пропускает 3, следующий элемент после вызова удаления (). Если вы проходите список ввода в виде [1, 1, 1, 1], окончательный список будет [1, 1].

Итак, есть ли обходной путь?

Конечно, есть обходной путь. Используйте копию списка в LOOP, но удалите элементы из основного списка. Простой способ создания копии списка – нарезка. Вот код обновления, который будет работать нормально во всех случаях.

Способы удаления дубликатов из списка в Python

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

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

# Код демонстрирует удаление дубликатов
# из списка наивным методом

# инициализация списка
my_list = [1, 3, 5, 6, 3, 5, 6, 1]
print («Оригинальный список : » + str(my_list))

# используем наивный метод
# чтобы убрать дубликаты
# из списка
li = []
for i in my_list:
if i not in li:
li.append(i)

# список после удаления дубликатов
print («список после удаления дубликатов : » + str(li))

Оригинальный список : [1, 3, 5, 6, 3, 5, 6, 1]
список после удаления дубликатов : [1, 3, 5, 6]

Использование генератора списков.

Данный метод аналогичен предыдущему, но использует запись в виде одной строки, с использованием генератора списков.

# Код демонстрирует удаление дубликатов
# из списка с помощью генератора списков

# инициализация списка
my_list = [1, 3, 5, 6, 3, 5, 6, 1]
print («Оригинальный список : » + str(my_list))

# используем генератор списка
# чтобы удалить дубликаты

li = []
[li.append(x) for x in my_list if x not in li]

# вывод списка после удаления элементов
print («Список после удаления дубликатов : » + str(li))

Оригинальный список : [1, 3, 5, 6, 3, 5, 6, 1]
список после удаления дубликатов : [1, 3, 5, 6]

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

# Код Python3 показывает как
# удалять дубликаты из списка методом set()

# инициализация списка
my_list = [1, 5, 3, 6, 3, 5, 6, 1]
print («Оригинальный список : » + str(my_list))

# используем set()
# чтобы удалить дубликаты из списка
my_list = list(set(my_list))

# вывод списка после удаления элементов
# не сохраняет порядок
print («Список после удаления дубликатов: » + str(my_list))

Оригинальный список : [1, 5, 3, 6, 3, 5, 6, 1]
Список после удаления дубликатов: [1, 3, 5, 6]

Генератор списка + enumarate().

Генератор списка в сочетании с функцией перечисления также может решить эту задачу. Он ищет уже существующие элементы и пропускает их добавление. Также сохраняет порядок списка.

# Код Python3 показывает как удалять дубликаты из списка
# используя генератор списков(list comprehension) + enumerate()

# инициализация списка
my_list = [1, 5, 3, 6, 3, 5, 6, 1]
print («Оригинальный список : » + str(my_list))

# используем list comprehension + enumerate()
# чтобы удалить дубликаты из списка

li = [i for n, i in enumerate(my_list) if i not in my_list[:n]]

# вывод списка после удаления элементов
print («Список после удаления дубликатов: » + str(li))

Оригинальный список : [1, 5, 3, 6, 3, 5, 6, 1]
Список после удаления дубликатов: [1, 5, 3, 6]

Это самый быстрый метод для достижения конкретной задачи. Сначала он удаляет дубликаты и возвращает словарь, который необходимо преобразовать в список. Он также хорошо работает и в случае строк.

# Код Python3 показывает как удалять дубликаты из списка
# с помощью collections.OrderedDict.fromkeys()

from collections import OrderedDict

# инициализация списка
my_list = [1, 5, 3, 6, 3, 5, 6, 1]
print («Оригинальный список : » + str(my_list))

# используем модуль collections.OrderedDict.fromkeys()
# чтобы удалить дубликаты из списка

# вывод списка после удаления элементов
print («Список после удаления дубликатов: » + str(li))

Оригинальный список : [1, 5, 3, 6, 3, 5, 6, 1]
Список после удаления дубликатов: [1, 5, 3, 6]

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

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Комментарии ( 0 ):

Для добавления комментариев надо войти в систему.
Если Вы ещё не зарегистрированы на сайте, то сначала зарегистрируйтесь.

Copyright © 2010-2022 Русаков Михаил Юрьевич. Все права защищены.

Узнать, как удалить дубликаты из списка в Python.

Пример

Удалите все дубликаты из списка:

Объяснение примера

Сначала у нас есть список, который содержит дубликаты:

Список с дубликатами

Создайте словарь, используя элементы списка в качестве ключей. Это автоматически удалит все дубликаты, поскольку словари не могут иметь дубликатов ключей.

Создать словарь

Затем преобразуйте словарь обратно в список:

Преобразовать в список

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

Распечатайте список, чтобы продемонстрировать результат

Распечатать список

Создание функции

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

Пример

def my_function(x):
return list(dict.fromkeys(x))

mylist = my_function([«a», «b», «a», «c», «c»])

Объяснение примера

Создайте функцию, которая принимает список в качестве аргумента.

Создать функцию

def my_function(x):
return list(dict.fromkeys(x))

mylist = my_function([«a», «b», «a», «c», «c»])

Создайте словарь, используя элементы этого списка в качестве ключей.

Создать словарь

def my_function(x):
return list( dict.fromkeys(x) )

mylist = my_function([«a», «b», «a», «c», «c»])

Преобразовать словарь в список.

Преобразовать в список

def my_function(x):
return list( dict.fromkeys(x) )

mylist = my_function([«a», «b», «a», «c», «c»])

Возврат списка

def my_function(x):
return list(dict.fromkeys(x))

mylist = my_function([«a», «b», «a», «c», «c»])

Вызовите функцию со списком в качестве параметра:

Вызов функции

def my_function(x):
return list(dict.fromkeys(x))

mylist = my_function([«a», «b», «a», «c», «c»])

Вывод результата

def my_function(x):
return list(dict.fromkeys(x))

mylist = my_function([«a», «b», «a», «c», «c»])

Упражнения

Тесты

КАК СДЕЛАТЬ

ПОДЕЛИТЬСЯ

СЕРТИФИКАТЫ

Сообщить об ошибке

Если вы хотите сообщить об ошибке или сделать предложение, не стесняйтесь, присылайте нам электронное письмо:

Ваше предложение:

Спасибо, за вашу помощь!

Ваше сообщение было отправлено в SchoolsW3.

Топ Учебники

Топ Справочники

Топ Примеры

Веб Сертификаты

Удаление дубликатов из связного списка в Python

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

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

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

Вернемся к спискам. Списки в Python — не настоящие массивы, а реализация динамических массивов. Их производительность отличается и от связных списков, и от массивов (больше информации здесь). Но связными списками проще манипулировать, по крайней мере по сравнению со старыми массивами. Чтобы добавить новый узел, вам не нужно создавать новый список: можно просто создать сам узел и изменить указатели от других узлов.

Давайте разберем задачу:

Напишите код для удаления дубликатов из несортированного связного списка.

Прежде всего нам понадобится класс Node из прошлой статьи. С его помощью мы сможем создать сам связный список, прежде чем начать что-то менять в нем. Вот код:

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

Теперь нам нужно сделать итератор для обхода списка. В предыдущей статье мы делали отдельный узел, указывающий на каждый узел в списке, «обходя» его. Благодаря этому список оставался нетронутым. Ниже вы видите полезную гифку от GeeksForGeeks, где указатель обходит связный список и удаляет последний узел.

Допустим, у нас такой список:

Вот и все! Наш метод целиком:

Проверяем наш метод

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

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

Этот код выведет 1, 2, 3, 3, 1, 4.

Если все пройдет гладко, то при следующем выводе списка у нас уже не будет лишних 1 и 3, то есть в выводе мы получим 1, 2, 3, 4.

Возможно, вам по-прежнему непонятно, зачем это учить. Связные списки — это своего рода пережиток традиционной информатики. Но если вы хотите разобраться в более сложных структурах, таких как двоичные деревья, связные списки — хорошее подспорье. А если вы умеете реализовывать собственные связные списки, вы можете модифицировать их, чтобы получить кастомные методы для специфических нужд. Например, связный список можно использовать для реализации простого блокчейна. Да, вы не ослышались! Блокчейн — это, по сути, очень усложненный связный список.

Английский для программистов

Наш телеграм канал с тестами по английскому языку для программистов. Английский это часть карьеры программиста. Поэтому полезно заняться им уже сейчас

Удаление дубликатов из списка Python

Структура данных списка довольно популярна среди программистов и пользователей Python. Иногда пользователи сталкиваются с повторяющимися значениями в списке и не могут их удалить. Если да, то это руководство предназначено для вас. В этом руководстве мы обсудим несколько методов удаления повторяющихся значений из структуры данных списка. Давайте посмотрим по-новому.

Метод 1: Naïve

Начните с открытия оболочки терминала с помощью «Ctrl + Alt + T». Создайте новый файл Python с инструкцией «touch». Файл «dup.py» будет открыт с помощью команды редактора «GNU Nano»:

После открытия файла в редакторе Nano добавьте поддержку Python в его начало. Список целочисленных типов инициализирован, и некоторые его значения повторяются. Оператор печати отображает список путем преобразования его значения в строковый тип. Еще один пустой список, «Arr», был инициализирован. Цикл «for» будет использоваться для того, чтобы просто поместить первое вхождение значения списка и добавить его в новый список «Arr» с помощью функции «append». Вновь составленный список будет распечатан:

Print ( “ The list after update: “ + str ( Arr ) )

После запуска файла Python на терминале отобразился исходный список и новый список без дубликатов:

Метод 2: понимание списка

Метод понимания списка очень похож на наивный метод. Единственное изменение — это позиция использования в нем метода добавления, цикла «for» и оператора «if». Откройте тот же файл «dup.py», чтобы обновить его код. Метод понимания списка показан как сочетание цикла for и оператора if с функцией append (). В остальном код такой же:

Print ( “ The list before update: “ + str ( List ) )

[ Arr. append ( ) for i in List if i not in Arr ] :

Print ( “ The list after update: “ + str ( Arr ) )

После выполнения файла Python мы получили ожидаемый результат, то есть исходный список и обновили новый список:

Метод 3: перечисление с пониманием списка

Вы можете использовать функцию перечисления в понимании списка, чтобы избежать дублирования в списке. Просто откройте файл «dup.py» и добавьте метод перечисления в строку понимания списка между циклами «for». И старый список, и обновленный список без дубликатов будут отображаться в оболочке с использованием оператора print в коде:

Print ( “ The list before update: “ + str ( List ) )

Print ( “ The list after update: “ + str ( Arr ) )

Файл был выполнен, и в результате сначала был отображен исходный список, а затем обновленный новый список, не имеющий повторяющихся значений. Функция enumerate также упорядочила список:

Пример 4: Функция Set ()

Известно, что функция set () удаляет дубликаты из списка. Он удаляет дубликаты, но самостоятельно меняет порядок списка. Итак, открываем файл dup.py и добавляем инициализацию списка. Исходный список распечатан. Затем мы использовали метод «set ()» в «List», чтобы удалить дубликаты и снова преобразовать оставшиеся в список. Результирующий список обновлен и снова отображается в оболочке:

Print ( “ The list before update: “ + str ( List ) )

List = list ( set ( List ) )

Print ( “ The list after update: “ + str ( List ) )

После запуска файла Python отображается исходный список, а затем обновленный.

Метод 5: Collections.OrderedDict

Для этой цели также можно использовать коллекции модулей. Просто импортируйте пакет OrderedDict из библиотеки «collections». Инициализируйте список и распечатайте его. Новая переменная «Arr» используется для получения списка, созданного методом «Ordered.Dict.fromkeys ()», и обхода исходного списка в нем. Будет отображена вновь созданная переменная списка:

From collections import OrderedDict

Print ( “ The list before update: “ + str ( List ) )

Arr = list ( OrderedDict. fromkeys ( List ) )

Print ( “ The list after update: “ + str ( Arr ) )

Выполнение показывает ожидаемый результат. Первый список является исходным, а второй — обновленным списком без дубликатов:

Как удалить дубликаты из списка списков Python?

https://youtu.be/jzuXwIVRT1s Какой лучший способ удалить дубликаты из списка списков Python? Это популярный опрос кодирующего интервью в Google, Facebook и Amazon. В этой статье я покажу вам, как (а почему) это работает — так продолжай читать! Как удалить все дубликаты данного значения в списке? Метод 1: наивный метод … Как удалить дубликаты из списка списков Python? Подробнее “

Автор оригинала: Chris.

Какой лучший способ удалить дубликаты из списка списков Python? Это популярный опрос кодирующего интервью в Google, Facebook и Amazon. В этой статье я покажу вам, как (и почему) это работает – так что держите чтение!

Как удалить все дубликаты данного значения в списке?

Метод 1: наивный метод

Алгоритм : Перейдите на каждый элемент и проверьте, существует ли этот элемент в списке. Если это так, удалите его. Проблема в том, что этот метод имеет квадратичный Сложность времени Потому что вам нужно проверить каждый элемент, если он существует в списке (что это n * O (n) для N элементы).

Метод 2: Временное преобразование словаря

Алгоритм: Более эффективный способ с точки зрения сложности времени состоит в том, чтобы создать словарь из элементов в списке, чтобы удалить все дубликаты и преобразовывать словарь обратно в список. Это сохраняет порядок исходных элементов списка.

Все следующие четыре метода Sub являются операциями в линейном времени. Следовательно, алгоритм имеет линейную сложность времени выполнения и более эффективно, чем наивный подход (метод 1).

Каждый список элементов списка) становится кортежом, который становится новым ключом к словарю. Например, список [[1, 1], [0, 1], [0, 1]] становится списком [(1, 1), (0, 1), (0, 1)] Словарь <(1, 1): нет, (0, 1) : Нет>Отказ Все элементы, которые происходят несколько раз, будут присвоены к тому же ключу. Таким образом, словарь содержит только уникальные ключевые ключи – не могут быть несколько равных клавиш.

В качестве значений словаря вы принимаете фиктивные значения (по умолчанию).

Затем вы преобразуете словарь обратно в список списков, выбрасывающих данные значения.

Связанные статьи в блоге:

Словари Python сохраняют упорядочение ключа?

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

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

Вы видите, что порядок элементов сохраняется так при преобразовании его обратно, исходное упорядочение элементов списка все еще сохраняется:

Однако вы не можете полагаться на него, потому что любая реализация Python может, теоретически решать не сохранять порядок (обратите внимание, что «может» вот 100% теоретический и не распространяется на реализацию CPYPHON.

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

Метод 3: установить преобразование

Учитывая список списков, цель состоит в том, чтобы удалить все элементы, которые существуют более одного раза в списке.

Наборы в Python позволяют только один экземпляр элемента. Поэтому, преобразуя список на набор, все дубликаты удаляются. В отличие от наивного подхода (проверка всех пар элементов, если они являются дубликатами), что имеет квадратичную сложность времени, этот метод имеет линейную сложность времени выполнения. Почему? Поскольку сложность выполнения создания набора является линейной в количестве установленных элементов. Теперь вы преобразуете установку обратно в список, и Voilà, дубликаты удаляются.

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

Но мы можем найти простой обходной путь к обеим проблемам, как вы увидите в следующем способе.

Метод линейного времени выполнения с установленным для удаления дубликатов из списка списков

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

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

Куда пойти отсюда?

Достаточно теории, давайте познакомимся!

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

Практические проекты – это то, как вы обостряете вашу пилу в кодировке!

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

Затем станьте питоном независимым разработчиком! Это лучший способ приближения к задаче улучшения ваших навыков Python – даже если вы являетесь полным новичком.

Присоединяйтесь к моему бесплатным вебинаре «Как создать свой навык высокого дохода Python» и посмотреть, как я вырос на моем кодированном бизнесе в Интернете и как вы можете, слишком от комфорта вашего собственного дома.

Присоединяйтесь к свободному вебинару сейчас!

Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.

Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python одноклассники (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.

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

Как вы удаляете дубликаты из списка, сохраняя порядок?

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

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

25 ответов

Если вы планируете многократно использовать эту функцию в одном и том же наборе данных, возможно, вам лучше использовать упорядоченный набор: http://code.activestate.com/recipes/528878/

O (1) вставка, удаление и проверка членов для каждой операции.

В Python 2.7 новый способ удаления дубликатов из итерируемого при сохранении его в исходном порядке:

В Python 3.5 OrderedDict имеет реализацию на языке Си. Мои данные показывают, что сейчас это самый быстрый и самый короткий из различных подходов для Python 3.5.

В Python 3.6 обычный dict стал упорядоченным и компактным. (Эта функция поддерживается для CPython и PyPy, но может отсутствовать в других реализациях). Это дает нам новый самый быстрый способ дедупликации при сохранении порядка:

В Python 3.7 регулярный dict гарантированно упорядочен во всех реализациях. Итак, самое короткое и быстрое решение:

Для типов без хэширования (например, списков), основанных на MizardX:

Относительно эффективный подход с _sorted_ массивами numpy :

В 5 раз быстрее уменьшите вариант, но сложнее

Это сохранит порядок и будет выполняться за O (n) раз. в основном идея состоит в том, чтобы создать дыру там, где найден дубликат, и опустить его на дно. использует указатель чтения и записи. всякий раз, когда обнаруживается дубликат, только указатель чтения перемещается, а указатель записи остается в записи дубликата, чтобы перезаписать его.

Метод на месте

Этот метод является квадратичным, потому что у нас есть линейный поиск в списке для каждого элемента списка (к этому мы должны добавить стоимость переупорядочения списка из-за del s).

Тем не менее, можно работать на месте, если мы начнем с конца списка и перейдем к источнику, удаляя каждый термин, который присутствует в подсписке слева

Эта идея в коде просто

Простой тест реализации

Простое рекурсивное решение:

Заимствование рекурсивной идеи, используемой при определении функции nub Haskell для списков, это будет рекурсивный подход:

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

Я также думаю, что интересно, что это может быть легко обобщено другими операциями. Как это:

Например, вы можете передать функцию, которая использует понятие округления до того же целого числа, как если бы оно было «равенством» в целях уникальности, например так:

Тогда unique (some_list, test_round) предоставит уникальные элементы списка, где уникальность больше не означает традиционное равенство (что подразумевается при использовании любого вида подхода к этой проблеме на основе множеств или диктов), а вместо этого подразумевает использование только первый элемент, который округляется до K для каждого возможного целого числа K, к которому элементы могут округляться, например:

Исключая дублирующиеся значения в последовательности, но сохраняйте порядок оставшихся элементов. Использование функции генератора общего назначения.

Вы могли бы сделать что-то вроде уродливого взлома понимания списка.

Решение без использования импортированных модулей или наборов:

Редактирование сообщества: это, однако, самый элегантный способ «сжать повторяющиеся последовательные элементы в один элемент».

Если вам нужен один лайнер, то, возможно, это поможет:

. должно работать, но поправьте меня, если я ошибаюсь

Подход zmk использует понимание списка, которое очень быстро, но сохраняет порядок естественным образом. Для применения к чувствительным к регистру строкам его можно легко модифицировать. Это также сохраняет оригинальный случай.

Тесно связанные функции:

Еще один очень поздний ответ на еще один очень старый вопрос:

itertools рецептов имеют функцию, которая делает это, используя << X1>> установить технику, но:

В Python 3.7 и выше словарями являются гарантированно запомнит порядок вставки ключей. Ответ на этот вопрос суммирует текущее состояние дел.

Таким образом, решение OrderedDict устареет, и без каких-либо операторов импорта мы можем просто выдать:

Выражение генератора, которое использует поиск O (1) набора, чтобы определить, следует ли включать элемент в новый список.

Уникальный → [‘1’, ‘2’, ‘3’, ‘6’, ‘4’, ‘5’]

Удаление дубликатов в списках

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

30 ответов

Следующий пример должен охватывать все, что вы пытаетесь сделать:

Поддержание порядка

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

Начиная с Python 3.7, встроенный словарь Также гарантированно поддерживается порядок вставки, поэтому вы также можете использовать его напрямую, если вы используете Python 3.7 или более позднюю версию (или CPython 3.6):

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

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

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

Это даст вам х с удаленными дубликатами, но сохраняя порядок.

Магия Питона Встроенный тип

В python очень легко обрабатывать сложные случаи, подобные этому, и только по встроенному типу python.

Позвольте мне показать вам, как это сделать!

Метод 1: общий случай

Способ ( 1-строчный код ) для удаления дублированного элемента в списке и сохранения порядка сортировки

Вы получите результат

Метод 2: особый случай

Особый случай обработки непредсказуемого ( 3 строчных кода )

Вы получите результат:

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

Если вы не заботитесь о заказе, просто сделайте это:

set гарантированно не будет иметь дубликатов.

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

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

Очень простой способ в Python 3:

Сократить вариант с заказом консервирования:

Предположим, что у нас есть список:

Уменьшить вариант (неэффективно):

В 5 раз быстрее, но сложнее

Попробуйте использовать наборы:

Этот заботится о заказе без особых хлопот (OrderdDict и другие). Вероятно, не самый Pythonic способ, ни кратчайший путь, но делает трюк:

Еще один лучший подход может быть,

И порядок остается сохраненным.

В Python 2.7 новый способ удаления дубликатов из итерируемого при сохранении его в исходном порядке:

В Python 3.5 OrderedDict имеет реализацию на языке Си. Мои данные показывают, что сейчас это самый быстрый и самый короткий из различных подходов для Python 3.5.

В Python 3.6 обычный dict стал упорядоченным и компактным. (Эта функция поддерживается для CPython и PyPy, но может отсутствовать в других реализациях). Это дает нам новый самый быстрый способ дедупликации при сохранении порядка:

В Python 3.7 регулярный dict гарантированно упорядочен во всех реализациях. Итак, самое короткое и быстрое решение:

Вы также можете сделать это:

Причина, по которой работает выше, заключается в том, что метод index возвращает только первый индекс элемента. Повторяющиеся элементы имеют более высокие показатели. См. здесь:

list.index (x [, start [, end]])
Вернуть нулевой индекс в списке первый элемент, значение которого равно х. Вызывает ValueError, если нет такой предмет.

У меня был дикт в моем списке, поэтому я не мог использовать вышеупомянутый подход. Я получил ошибку:

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

Решение панд

Использование функции Pandas unique() :

Numpy решение

Решение не столь элегантно по сравнению с другими, однако, по сравнению с pandas.unique (), numpy.unique () позволяет вам также проверить, являются ли вложенные массивы уникальными вдоль одной выбранной оси.

Создать новый список, сохраняющий порядок первых элементов дубликатов в L

newlist=[ii for n,ii in enumerate(L) if ii not in L[:n]]

Например if L=[1, 2, 2, 3, 4, 2, 4, 3, 5] тогда newlist будет [1,2,3,4,5]

Это проверяет, что каждый новый элемент ранее не появлялся в списке перед его добавлением. Также он не нуждается в импорте.

Это однострочник: list(set(source_list)) сделает свое дело.

Обновление: подход к сохранению порядка состоит из двух строк:

Здесь мы используем тот факт, что OrderedDict запоминает порядок вставки ключей и не изменяет его при обновлении значения для определенного ключа. Мы вставляем True как значения, но мы можем вставить что угодно, значения просто не используются. ( set работает так же, как dict с игнорируемыми значениями.)

Другой способ сделать:

Все подходы к сохранению порядка, которые я видел здесь до сих пор, используют либо наивное сравнение (в лучшем случае с O (n ^ 2) сложностью времени), либо тяжеловесный OrderedDicts / set + <> комбинации, которые ограничены хэшируемыми входами. Вот решение, не зависящее от хеша O (nlogn):

Код ниже прост для удаления дубликатов в списке

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

Это возвращает генератор / итератор, так что вы можете использовать его везде, где вы можете использовать итератор.

Если вы хотите сохранить порядок и не использовать какие-либо внешние модули, вот простой способ сделать это:

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

Но он намного короче и работает быстрее.

Вы можете использовать следующую функцию:

Пример :

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

[‘this’, ‘is’, ‘a’, ‘list’, ‘with’, ‘duplicates’, ‘in’, ‘the’]

Вот результаты измерений

Ну, что произойдет, если набор будет удален из решения?

В этом ответе будут два раздела: два уникальных решения и график скорости для конкретных решений.

Удаление повторяющихся элементов

Я также сделал два решения. Другое решение, которое поддерживает порядок элементов, используя подкласс OrderedDict и Counter, который называется OrderedCounter. Теперь вот функции:

Теперь я также хотел показать сравнение скорости каждого ответа. Итак, я сделаю это сейчас.

Какая функция самая быстрая?

Unordered Hashable был для любого метода, который удалял дубликаты, которые не обязательно должны поддерживать порядок. Это не должно было работать на непоправимые последствия, но могло.

Ordered Hashable был для любого метода, который сохранял порядок элементов в списке, но он не должен был работать для неисчерпаемых, но он мог.

На оси Y указано количество секунд, которое потребовалось.

Мы сгенерировали последовательности для неупорядоченных хэши и упорядоченных хеш-хеллов со следующим пониманием: [list(range(x)) + list(range(x)) for x in range(0, 1000, 10)]

Для заказанных неразрушимых грузов: [[list(range(y)) + list(range(y)) for y in range(x)] for x in range(0, 1000, 10)]

Обратите внимание, что в диапазоне есть «шаг», потому что без него это заняло бы 10x больше времени. Кроме того, потому что, по моему личному мнению, я думал, что это могло бы выглядеть немного легче для чтения.

Как объединить два списка Python и удалить дубликаты во втором списке?

Проблема: Учитывая два списка [1, 2, 2, 4] и [2, 5, 5, 5, 6]. Как вы объединяете эти списки в новый список [1, 2, 2, 4, 5, 6], удалив дубликаты во втором списке? Примечание. Вы хотите удалить все дубликаты во втором списке и элементах во втором … Как объединить два списка Python и удалить дубликаты во втором списке? Подробнее “

Автор оригинала: Chris.

Проблема : Дано два Списки [1, 2, 2, 4] и [2, 5, 5, 5, 6] Отказ Как ты комбинировать Эти списки в новый список [1, 2, 2, 4, 5, 6] по Удаление дубликатов во втором списке?

Примечание : Вы хотите удалить все дубликаты во втором списке и элементы во втором списке, которые уже в первом списке.

Решение : Используйте следующие три шага, чтобы объединить два списка и удалить дубликаты во втором списке:

Попробуйте сами в нашей интерактивной Python Shell:

Упражнение : Можете ли вы переписать это в одной строке кода Python ( Python One-lister )?

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

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

Как удалить дубликаты из списка Python?

Наивный метод : Перейдите на каждый элемент и проверьте, существует ли этот элемент в списке. Если это так, удалите его. Однако это требует нескольких строк кода.

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

Каждый элемент списка становится новым ключом к словарю. Например, список [1, 2, 3] становится словарь <1: нет, 2: 3: нет>Отказ Все элементы, которые происходят несколько раз, будут присвоены к тому же ключу. Таким образом, словарь содержит только уникальные ключевые ключи – не могут быть несколько равных клавиш.

В качестве значений словаря вы принимаете фиктивные значения (по умолчанию).

Затем вы преобразуете словарь обратно в список, выбрасывающие фиктивные значения.

Связанные статьи в блоге:

Куда пойти отсюда?

Достаточно теории, давайте познакомимся!

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

Практические проекты – это то, как вы обостряете вашу пилу в кодировке!

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

Затем станьте питоном независимым разработчиком! Это лучший способ приближения к задаче улучшения ваших навыков Python – даже если вы являетесь полным новичком.

Присоединяйтесь к моему бесплатным вебинаре «Как создать свой навык высокого дохода Python» и посмотреть, как я вырос на моем кодированном бизнесе в Интернете и как вы можете, слишком от комфорта вашего собственного дома.

Присоединяйтесь к свободному вебинару сейчас!

Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.

Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python одноклассники (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.

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

Удалить все экземпляры из списка в Python

Вы играли со многими структурами данных, чтобы добавлять или удалять элементы или данные в них. Список — один из них. Повторяющиеся одинаковые значения называются экземплярами или вхождениями. Вы когда-нибудь пытались удалить некоторые повторяющиеся значения из списка? Если нет, то эта статья предназначена для вас. Поэтому мы обсудим некоторые методы удаления всех одинаковых экземпляров из структуры данных списка в Python. Для этого мы будем использовать инструмент Python Spyder3.

Метод 1: Удалить функцию

Самый первый и самый простой способ удалить все экземпляры из списка — использовать метод remove () в нашем коде Python. Итак, в рамках проекта Spyder3 мы инициализировали список «Список» некоторыми значениями целочисленного типа. Переменная «r» была определена со значением «2». Значение «2» переменной «r» будет использоваться как совпадение. Оператор печати используется для распечатки исходного списка.

Мы использовали в нашем коде оператор «try-except», чтобы удалить одни и те же вхождения. В теле «try» мы использовали «while», чтобы продолжить выполнение до конца списка. Метод remove () удаляет из списка все экземпляры переменной «r», имеющей значение «2». В то время как оператор except используется для продолжения программы в случае возникновения некоторой ошибки значения. После того, как весь список будет извлечен, левые элементы списка будут распечатаны.

У нас есть два списка после выполнения этого кода, то есть до удаления экземпляров и после удаления экземпляров.

Метод 2: понимание списка

Метод «понимания списка» — это следующий и простой метод удаления всех экземпляров из списка — метод «понимания списка». Мы использовали здесь тот же список. Кроме того, мы использовали ту же переменную «r» с тем же значением «2», чтобы использовать ее в качестве экземпляра для удаления. После распечатки исходного списка мы использовали метод понимания списка, то есть использовали цикл for для сопоставления с вхождением. После выполнения условия оставшиеся значения будут сохранены в списке «Список», а совпавшие значения будут проигнорированы. Вновь обновленный список будет выведен на консоль.

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

Метод 3: функция фильтра

Функция filter () очень удобна, когда дело доходит до удаления вхождений одного и того же элемента из списка. Итак, мы объявили список строкового типа с 7 строковыми значениями в нем. После инициализации списка мы объявили строковую переменную с именем «r», имеющую значение «снег». Эта строка будет использоваться в дальнейшем как соответствующий экземпляр. Исходный список строк был распечатан с помощью предложения print. Затем мы применили функцию filter () к списку, используя для проверки переменную «r».

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

Выходные данные этого кода представляют собой исходный список и недавно обновленный и отфильтрованный список.

Заключение

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