Разность элементов массива python

Операция вычитания списка Python

@ezdazuzena это не вычитание. В этом разница между двумя списками. Ваша публикация не является дублированием этого вопроса.

Что должны вернуть [2, 1, 2, 3, 2, 4, 2] — [2, 3, 2] и почему? Должен ли он найти 232 в середине и вернуть 2142? или он должен каждый раз находить первое и возвращать 1242? Или что-то другое? Я говорю о том, что это не очевидные ответы и зависит от необходимости.

9 ответов

Используйте понимание списка:

[item for item in x if item not in y] 

Если вы хотите использовать синтаксис — infix, вы можете просто сделать:

class MyList(list): def __init__(self, *args): super(MyList, self).__init__(args) def __sub__(self, other): return self.__class__(*[item for item in self if item not in other]) 

вы можете использовать его, как:

x = MyList(1, 2, 3, 4) y = MyList(2, 5, 2) z = x - y 

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

@admica, не используйте list для имен переменных, поскольку он скрывает конструктор list . Если вы используете «список», пожалуйста, поставьте перед ним подчеркивание. Кроме того, удалив * , вы сломали мой код .

Если вы сделаете [1,1,2,2] — [1,2] вы получите пустой список. [1,1,2,2] — [2] дает [1,1] Так что это на самом деле не вычитание списка, это больше похоже на «Список из Списка X без элементов из набора Y » .

>>> z = list(set(x) - set(y)) >>> z [0, 8, 2, 4, 6] 

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

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

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

Это операция «вычитания множества». Используйте для этого структуру данных.

list (set ([1,2,3,4,5]) — set ([1,2,3])) = [4, 5], так что сначала перечисляются списки для каждого, а затем вычитаются (или односторонние ) и вернуться к списку.

Если проблемы с дублированием и упорядочением являются проблемой:

[i for i in a if not i in b or b.remove(i)]

a = [1,2,3,3,3,3,4] b = [1,3] result: [2, 3, 3, 3, 4] 

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

ys = set(y) [item for item in x if item not in ys] 

версия aaronasterling выполняет len(y) сравнение элементов для каждого элемента в x , поэтому требуется квадратичное время. Версия quantSoup использует наборы, поэтому для каждого элемента в x используется только один постоянный поиск по времени, но поскольку он преобразует как x , так и y в множества, он теряет порядок ваших элементов.

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

Тем не менее, эта проблема по-прежнему имеет проблему с версией quantSoup: она требует, чтобы ваши элементы были хешируемыми. Это в значительной степени встроено в природу наборов. ** Если вы пытаетесь, например, вычесть список dicts из другого списка dicts, но список для вычитания большой, что вы делаете?

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

ys = [item for item in x if tuple(item.items()) not in ys] 

Если ваши типы немного сложнее (например, часто вы имеете дело с JSON-совместимыми значениями, которые являются хешируемыми или списками или dicts, значения которых рекурсивно одного типа), вы все равно можете использовать это решение. Но некоторые типы просто не могут быть преобразованы во что-нибудь хешируемое.

Если ваши элементы не являются и не могут быть сделаны хешируемыми, но они сопоставимы, вы можете, по крайней мере, получить лог-линейное время ( O(N*log M) , что намного лучше, чем время O(N*M) решение списка, но не так хорошо, как время O(N+M) заданного решения) путем сортировки и использования bisect :

ys = sorted(y) def bisect_contains(seq, item): index = bisect.bisect(seq, item) return index < len(seq) and seq[index] == item [item for item in x if bisect_contains(ys, item)] 

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

_{* Обратите внимание, что вы также можете сделать это, используя пару объектов OrderedSet , для которых вы можете найти рецепты и сторонние модули. Но я думаю, что это проще.}

_{** По умолчанию набор запросов - это постоянное время, так как все, что ему нужно сделать, это хэш-значение и посмотреть, есть ли запись для этого хэша. Если он не может присвоить значение, это не сработает.}

Источник

Узнайте разницу между двумя списками в Python

1. Используйте set.difference() , чтобы найти разницу между двумя списками в Python
2. Используйте set.symmetric_difference() , чтобы найти разницу между двумя списками в Python
3. Используйте ключевое слово in , чтобы найти разницу между двумя списками в Python
4. Используйте библиотеку NumPy , чтобы найти разницу между двумя списками в Python

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

В этом руководстве будет продемонстрировано несколько способов различить два списка в Python.

Используйте set.difference() , чтобы найти разницу между двумя списками в Python

Метод set() помогает пользователю преобразовать любую итерацию в повторяемую последовательность, которая также называется набором. Итерируемые объекты могут быть списком, словарем или кортежем.

Функция set.difference() используется для возврата разницы между двумя наборами. Эта функция в основном устраняет общие элементы в двух наборах.

list_1 = [5, 10, 15, 20, 25, 30] list_2 = [10, 20, 30, 40, 50, 60]  difference_1 = set(list_1).difference(set(list_2)) difference_2 = set(list_2).difference(set(list_1))  list_difference = list(difference_1.union(difference_2)) print(list_difference) 

Для этого метода первым шагом является сохранение двух списков в двух переменных. Функция set() используется для преобразования этих списков в наборы. На этом же шаге функция set.difference() используется для определения разницы между двумя наборами. Обратите внимание, что переменная difference_1 получает элементы из list_1 , а не list_2 .

Переменная difference_2 получает элементы, которые находятся в list_2 , а не в list_1 . После этого функция union используется для получения всех элементов из переменных difference_1 и difference_2 . Кроме того, функция list() используется для повторного преобразования обоих наборов в списки. Наконец, распечатывается результирующий список.

Используйте set.symmetric_difference() , чтобы найти разницу между двумя списками в Python

Здесь метод set() используется для первоначального преобразования обоих списков в наборы.

Метод symmetric_difference() используется для возврата элементов, которые находятся либо в первом наборе, либо во втором наборе. Этот метод не возвращает пересечение, как общие элементы двух наборов.

list_1 = [5, 10, 15, 20, 25, 30] list_2 = [10, 20, 30, 40, 50, 60]  set_difference = set(list_1).symmetric_difference(set(list_2)) list_difference = list(set_difference)  print(list_difference) 

Метод set() также используется для преобразования списков в наборы. После получения разницы функция list() используется для получения и преобразования окончательного набора, как преобразование set_difference обратно в список.

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

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

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

list_1 = [5, 10, 15, 20, 25, 30] list_2 = [10, 20, 30, 40, 50, 60]  list_difference = [] for element in list_1:  if element not in list_2:  list_difference.append(element)  print(list_difference) 

В этом методе мы сначала инициализируем окончательный список, который должен быть напечатан с нулевыми элементами. Затем мы используем цикл for, чтобы начать итерацию с первым списком, которым является list_1 . После этого мы используем ключевое слово not in , чтобы проверить, находится ли элемент во втором списке или нет.

Наконец, мы используем метод append() для добавления элементов, которых нет во втором списке, в исходный список, то есть list_difference . Однако недостатком этого метода является то, что он не возвращает элементы из второго списка.

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

list_1 = [5, 10, 15, 20, 25, 30] list_2 = [10, 20, 30, 40, 50, 60]  list_difference = [element for element in list_1 if element not in list_2]  print(list_difference) 

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

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

В этом методе используются три функции библиотеки NumPy для получения разницы между двумя списками. Этими тремя функциями являются np.array() , np.setdiff1d() и np.concatenate() .

Массив - это основная структура данных библиотеки NumPy . Функция np.array() помогает создавать массивы и помогает в работе с ними.

Функция np.setdiff1d() помогает вам найти установленную разницу между двумя массивами и вернуть значения, которые находятся в первом массиве, а не во втором массиве.

Функция np.concatenate используется для объединения двух или более массивов NumPy вместе. Посмотрите пример ниже:

import numpy as np list_1 = [5, 10, 15, 20, 25, 30] list_2 = [10, 20, 30, 40, 50, 60]  array_1 = np.array(list_1) array_2 = np.array(list_2)  difference_1 = np.setdiff1d(array_1, array_2) difference_2 = np.setdiff1d(array_2, array_1)  list_difference = np.concatenate((difference_1, difference_2)) print(list(list_difference)) 

Lakshay Kapoor is a final year B.Tech Computer Science student at Amity University Noida. He is familiar with programming languages and their real-world applications (Python/R/C++). Deeply interested in the area of Data Sciences and Machine Learning.

Сопутствующая статья - Python List

Источник

numpy.diff#

Calculate the n-th discrete difference along the given axis.

The first difference is given by out[i] = a[i+1] - a[i] along the given axis, higher differences are calculated by using diff recursively.

Parameters : a array_like

n int, optional

The number of times values are differenced. If zero, the input is returned as-is.

axis int, optional

The axis along which the difference is taken, default is the last axis.

prepend, append array_like, optional

Values to prepend or append to a along axis prior to performing the difference. Scalar values are expanded to arrays with length 1 in the direction of axis and the shape of the input array in along all other axes. Otherwise the dimension and shape must match a except along axis.

The n-th differences. The shape of the output is the same as a except along axis where the dimension is smaller by n. The type of the output is the same as the type of the difference between any two elements of a. This is the same as the type of a in most cases. A notable exception is datetime64 , which results in a timedelta64 output array.

Type is preserved for boolean arrays, so the result will contain False when consecutive elements are the same and True when they differ.

For unsigned integer arrays, the results will also be unsigned. This should not be surprising, as the result is consistent with calculating the difference directly:

>>> u8_arr = np.array([1, 0], dtype=np.uint8) >>> np.diff(u8_arr) array([255], dtype=uint8) >>> u8_arr[1,. ] - u8_arr[0,. ] 255 

If this is not desirable, then the array should be cast to a larger integer type first:

>>> i16_arr = u8_arr.astype(np.int16) >>> np.diff(i16_arr) array([-1], dtype=int16) 

>>> x = np.array([1, 2, 4, 7, 0]) >>> np.diff(x) array([ 1, 2, 3, -7]) >>> np.diff(x, n=2) array([ 1, 1, -10]) 

>>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]]) >>> np.diff(x) array([[2, 3, 4], [5, 1, 2]]) >>> np.diff(x, axis=0) array([[-1, 2, 0, -2]]) 

>>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64) >>> np.diff(x) array([1, 1], dtype='timedelta64[D]') 

Источник