Поскольку вы выходите из контекста PHP в собственную оболочку, у вас будет много отладочных проблем.
Самый лучший и самый надежный, который я использовал в прошлом, - это запись вывода скрипта в файл журнала и его хвост во время выполнения PHP.
<?php
shell_exec("filename > ~/debug.log 2>&1");
Затем в отдельной оболочке:
tail -200f ~/debug.log
Когда вы выполняете свой PHP-скрипт, ваши ошибки и вывод из вашего вызова оболочки будет отображаться в вашем файле debug.log
.
In [5]: list(set(temp1) - set(temp2))
Out[5]: ['Four', 'Three']
Остерегайтесь
In [5]: set([1, 2]) - set([2, 3])
Out[5]: set([1])
, где вы можете ожидать / хотите, чтобы он был равен set([1, 3])
. Если вы хотите, чтобы в качестве ответа вы set([1, 3])
, вам нужно использовать set([1, 2]).symmetric_difference(set([2, 3]))
.
я буду бросать, так как ни одно из настоящих решений не дает кортеж:
temp3 = tuple(set(temp1) - set(temp2))
альтернативно:
#edited using @Mark Byers idea. If you accept this one as answer, just accept his instead.
temp3 = tuple(x for x in temp1 if x not in set(temp2))
Как и другие неподдерживаемые ответы в этом направлении, он сохраняет порядок
Я слишком поздно в игре для этого, но вы можете сделать сравнение производительности некоторых из вышеупомянутого кода с этим, два из самых быстрых соперников:
list(set(x).symmetric_difference(set(y)))
list(set(x) ^ set(y))
Извиняюсь для элементарного уровня кодирования.
import time
import random
from itertools import filterfalse
# 1 - performance (time taken)
# 2 - correctness (answer - 1,4,5,6)
# set performance
performance = 1
numberoftests = 7
def answer(x,y,z):
if z == 0:
start = time.clock()
lists = (str(list(set(x)-set(y))+list(set(y)-set(y))))
times = ("1 = " + str(time.clock() - start))
return (lists,times)
elif z == 1:
start = time.clock()
lists = (str(list(set(x).symmetric_difference(set(y)))))
times = ("2 = " + str(time.clock() - start))
return (lists,times)
elif z == 2:
start = time.clock()
lists = (str(list(set(x) ^ set(y))))
times = ("3 = " + str(time.clock() - start))
return (lists,times)
elif z == 3:
start = time.clock()
lists = (filterfalse(set(y).__contains__, x))
times = ("4 = " + str(time.clock() - start))
return (lists,times)
elif z == 4:
start = time.clock()
lists = (tuple(set(x) - set(y)))
times = ("5 = " + str(time.clock() - start))
return (lists,times)
elif z == 5:
start = time.clock()
lists = ([tt for tt in x if tt not in y])
times = ("6 = " + str(time.clock() - start))
return (lists,times)
else:
start = time.clock()
Xarray = [iDa for iDa in x if iDa not in y]
Yarray = [iDb for iDb in y if iDb not in x]
lists = (str(Xarray + Yarray))
times = ("7 = " + str(time.clock() - start))
return (lists,times)
n = numberoftests
if performance == 2:
a = [1,2,3,4,5]
b = [3,2,6]
for c in range(0,n):
d = answer(a,b,c)
print(d[0])
elif performance == 1:
for tests in range(0,10):
print("Test Number" + str(tests + 1))
a = random.sample(range(1, 900000), 9999)
b = random.sample(range(1, 900000), 9999)
for c in range(0,n):
#if c not in (1,4,5,6):
d = answer(a,b,c)
print(d[1])
Мне нужно что-то, что займет два списка и может сделать то, что diff
в bash
. Поскольку этот вопрос появляется сначала, когда вы ищете «python diff two lists» и не очень специфичен, я опубликую то, что я придумал.
Используя SequenceMather
из difflib
вы можете сравнить два списка, например diff
. Ни один из других ответов не скажет вам, где эта разница, но это делает. Некоторые ответы дают разницу только в одном направлении. Некоторые переупорядочивают элементы. Некоторые не обрабатывают дубликаты. Но это решение дает вам истинную разницу между двумя списками:
a = 'A quick fox jumps the lazy dog'.split()
b = 'A quick brown mouse jumps over the dog'.split()
from difflib import SequenceMatcher
for tag, i, j, k, l in SequenceMatcher(None, a, b).get_opcodes():
if tag == 'equal': print('both have', a[i:j])
if tag in ('delete', 'replace'): print(' 1st has', a[i:j])
if tag in ('insert', 'replace'): print(' 2nd has', b[k:l])
Это выдает:
both have ['A', 'quick']
1st has ['fox']
2nd has ['brown', 'mouse']
both have ['jumps']
2nd has ['over']
both have ['the']
1st has ['lazy']
both have ['dog']
Конечно, если ваше приложение делает те же предположения, что и другие ответы, вы выиграете от них больше всего. Но если вы ищете истинную функциональность diff
, то это единственный способ пойти.
Например, ни один из других ответов не может обрабатывать:
a = [1,2,3,4,5]
b = [5,4,3,2,1]
Но это делает:
2nd has [5, 4, 3, 2]
both have [1]
1st has [2, 3, 4, 5]
Различие между двумя списками (например, list1 и list2) можно найти, используя следующую простую функцию.
def diff(list1, list2):
c = set(list1).union(set(list2)) # or c = set(list1) | set(list2)
d = set(list1).intersection(set(list2)) # or d = set(list1) & set(list2)
return list(c - d)
или
def diff(list1, list2):
return list(set(list1).symmetric_difference(set(list2))) # or return list(set(list1) ^ set(list2))
Используя эту функцию, разницу можно найти с помощью diff(temp2, temp1)
или diff(temp1, temp2)
. Оба дадут результат ['Four', 'Three']
. Вам не нужно беспокоиться о порядке списка или списке, который должен быть указан первым.
Если вы столкнулись с TypeError: unhashable type: 'list'
, вам нужно повернуть списки или наборы в кортежи, например
set(map(tuple, list_of_lists1)).symmetric_difference(set(map(tuple, list_of_lists2)))
Если вы действительно смотрите на производительность, то используйте numpy!
Вот полный блокнот как сущность на github со сравнением между списком, numpy и pandas.
https://gist.github.com/denfromufa/2821ff59b02e9482be15d27f2bbd4451
Это можно решить одной строкой. Вопрос задан двумя списками (temp1 и temp2), возвращающими их разницу в третьем списке (temp3).
temp3 = list(set(temp1).difference(set(temp2)))
Попробуйте следующее:
temp3 = set(temp1) - set(temp2)
Это еще одно решение:
def diff(a, b):
xa = [i for i in set(a) if i not in b]
xb = [i for i in set(b) if i not in a]
return xa + xb
Существующие решения предлагают либо одну, либо другую:
Но пока ни одно решение не имеет. Если вы хотите обоим, попробуйте следующее:
s = set(temp2)
temp3 = [x for x in temp1 if x not in s]
Тест производительности
import timeit
init = 'temp1 = list(range(100)); temp2 = [i * 2 for i in range(50)]'
print timeit.timeit('list(set(temp1) - set(temp2))', init, number = 100000)
print timeit.timeit('s = set(temp2);[x for x in temp1 if x not in s]', init, number = 100000)
print timeit.timeit('[item for item in temp1 if item not in temp2]', init, number = 100000)
Результаты:
4.34620224079 # ars' answer
4.2770634955 # This answer
30.7715615392 # matt b's answer
Метод, который я представил, а также сохранение порядок также (немного) быстрее, чем заданное вычитание, потому что он не требует построения ненужного набора. Разница в производительности будет более заметной, если первый список значительно длиннее второго, и если хеширование дорого. Вот второй тест, демонстрирующий это:
init = '''
temp1 = [str(i) for i in range(100000)]
temp2 = [str(i * 2) for i in range(50)]
'''
Результаты:
11.3836875916 # ars' answer
3.63890368748 # this answer (3 times faster!)
37.7445402279 # matt b's answer
temp3 = [item for item in temp1 if item not in temp2]
temp2
в набор раньше сделало бы это немного более эффективным.
– lunaryorn
11 August 2010 в 20:47
item not in temp2
и item not in set(temp2)
всегда будут возвращать одни и те же результаты, независимо от того, есть ли дубликаты или нет в temp2
.
– arekolek
7 March 2016 в 23:42
Мы можем вычислить пересечение минус объединение списков:
temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two', 'Five']
set(temp1+temp2)-(set(temp1)&set(temp2))
Out: set(['Four', 'Five', 'Three'])
самый простой способ,
использовать комплект (). разница (комплект ())
list_a = [1,2,3]
list_b = [2,3]
print set(list_a).difference(set(list_b))
ответ есть set([1])
можно напечатать как список,
print list(set(list_a).difference(set(list_b)))
, если вы хотите что-то более похожее на набор изменений ... можете использовать Counter
from collections import Counter
def diff(a, b):
""" more verbose than needs to be, for clarity """
ca, cb = Counter(a), Counter(b)
to_add = cb - ca
to_remove = ca - cb
changes = Counter(to_add)
changes.subtract(to_remove)
return changes
lista = ['one', 'three', 'four', 'four', 'one']
listb = ['one', 'two', 'three']
In [127]: diff(lista, listb)
Out[127]: Counter({'two': 1, 'one': -1, 'four': -2})
# in order to go from lista to list b, you need to add a "two", remove a "one", and remove two "four"s
In [128]: diff(listb, lista)
Out[128]: Counter({'four': 2, 'one': 1, 'two': -1})
# in order to go from listb to lista, you must add two "four"s, add a "one", and remove a "two"
Вот несколько простых, способов сохранения порядка для разных списков строк.
Код
Необычный подход с использованием pathlib
:
import pathlib
temp1 = ["One", "Two", "Three", "Four"]
temp2 = ["One", "Two"]
p = pathlib.Path(*temp1)
r = p.relative_to(*temp2)
list(r.parts)
# ['Three', 'Four']
Это предполагает, что оба списка содержат строки с эквивалентными началами. Подробнее см. docs . Обратите внимание, что это не особенно быстро по сравнению с заданными операциями.
Прямая реализация с использованием itertools.zip_longest
:
import itertools as it
[x for x, y in it.zip_longest(temp1, temp2) if x != y]
# ['Three', 'Three', 'Four']
from itertools import filterfalse
здесь. Также обратите внимание, что это не возвращает последовательность, как остальные, она возвращает итератор.
– Matt Luongo
17 January 2012 в 18:16
Вот простой способ отличить два списка (независимо от содержимого), вы можете получить результат, как показано ниже:
>>> from sets import Set
>>>
>>> l1 = ['xvda', False, 'xvdbb', 12, 'xvdbc']
>>> l2 = ['xvda', 'xvdbb', 'xvdbc', 'xvdbd', None]
>>>
>>> Set(l1).symmetric_difference(Set(l2))
Set([False, 'xvdbd', None, 12])
Надеюсь, это поможет.
Если вы хотите разницу рекурсивно, я написал пакет для python: https://github.com/seperman/deepdiff
Установить из PyPi:
pip install deepdiff
Импорт
>>> from deepdiff import DeepDiff
>>> from pprint import pprint
>>> from __future__ import print_function # In case running on Python 2
Тот же объект возвращает пустой
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = t1
>>> print(DeepDiff(t1, t2))
{}
Изменен тип элемента
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:"2", 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{ 'type_changes': { 'root[2]': { 'newtype': <class 'str'>,
'newvalue': '2',
'oldtype': <class 'int'>,
'oldvalue': 2}}}
Значение элемента изменилось
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:4, 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}
Добавлен элемент и / или удален
>>> t1 = {1:1, 2:2, 3:3, 4:4}
>>> t2 = {1:1, 2:4, 3:3, 5:5, 6:6}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff)
{'dic_item_added': ['root[5]', 'root[6]'],
'dic_item_removed': ['root[4]'],
'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}
Разность строк
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world"}}
>>> t2 = {1:1, 2:4, 3:3, 4:{"a":"hello", "b":"world!"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'values_changed': { 'root[2]': {'newvalue': 4, 'oldvalue': 2},
"root[4]['b']": { 'newvalue': 'world!',
'oldvalue': 'world'}}}
Разница в строках 2
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world!\nGoodbye!\n1\n2\nEnd"}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n1\n2\nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'values_changed': { "root[4]['b']": { 'diff': '--- \n'
'+++ \n'
'@@ -1,5 +1,4 @@\n'
'-world!\n'
'-Goodbye!\n'
'+world\n'
' 1\n'
' 2\n'
' End',
'newvalue': 'world\n1\n2\nEnd',
'oldvalue': 'world!\n'
'Goodbye!\n'
'1\n'
'2\n'
'End'}}}
>>>
>>> print (ddiff['values_changed']["root[4]['b']"]["diff"])
---
+++
@@ -1,5 +1,4 @@
-world!
-Goodbye!
+world
1
2
End
Изменение типа
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n\n\nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'type_changes': { "root[4]['b']": { 'newtype': <class 'str'>,
'newvalue': 'world\n\n\nEnd',
'oldtype': <class 'list'>,
'oldvalue': [1, 2, 3]}}}
Разница в списке
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3, 4]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{'iterable_item_removed': {"root[4]['b'][2]": 3, "root[4]['b'][3]": 4}}
Переменная списка 2 :
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'iterable_item_added': {"root[4]['b'][3]": 3},
'values_changed': { "root[4]['b'][1]": {'newvalue': 3, 'oldvalue': 2},
"root[4]['b'][2]": {'newvalue': 2, 'oldvalue': 3}}}
Разница в списке игнорирует порядок или дубликаты: (с теми же словарями, что и выше)
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2, ignore_order=True)
>>> print (ddiff)
{}
Список, содержащий словарь:
>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:1, 2:2}]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:3}]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'dic_item_removed': ["root[4]['b'][2][2]"],
'values_changed': {"root[4]['b'][2][1]": {'newvalue': 3, 'oldvalue': 1}}}
Наборы:
>>> t1 = {1, 2, 8}
>>> t2 = {1, 2, 3, 5}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (DeepDiff(t1, t2))
{'set_item_added': ['root[3]', 'root[5]'], 'set_item_removed': ['root[8]']}
Именованные кортежи:
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> t1 = Point(x=11, y=22)
>>> t2 = Point(x=11, y=23)
>>> pprint (DeepDiff(t1, t2))
{'values_changed': {'root.y': {'newvalue': 23, 'oldvalue': 22}}}
Пользовательские объекты:
>>> class ClassA(object):
... a = 1
... def __init__(self, b):
... self.b = b
...
>>> t1 = ClassA(1)
>>> t2 = ClassA(2)
>>>
>>> pprint(DeepDiff(t1, t2))
{'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}
Добавлен атрибут объекта:
>>> t2.c = "new attribute"
>>> pprint(DeepDiff(t1, t2))
{'attribute_added': ['root.c'],
'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}
Вы можете использовать наивный метод, если элементы difflist отсортированы и установлены.
list1=[1,2,3,4,5]
list2=[1,2,3]
print list1[len(list2):]
или с помощью собственных методов набора:
subset=set(list1).difference(list2)
print subset
import timeit
init = 'temp1 = list(range(100)); temp2 = [i * 2 for i in range(50)]'
print "Naive solution: ", timeit.timeit('temp1[len(temp2):]', init, number = 100000)
print "Native set solution: ", timeit.timeit('set(temp1).difference(temp2)', init, number = 100000)
Наивное решение: 0.0787101593292
Нативное решение: 0.998837615564
однолинейная версия решения arulmr
def diff(listA, listB):
return set(listA) - set(listB) | set(listA) -set(listB)
Вот ответ Counter
для простейшего случая.
Это короче, чем выше, чем двухсторонний, потому что он точно выполняет именно то, что задает вопрос: сгенерируйте список того, что находится в первый список, но не второй.
from collections import Counter
lst1 = ['One', 'Two', 'Three', 'Four']
lst2 = ['One', 'Two']
c1 = Counter(lst1)
c2 = Counter(lst2)
diff = list((c1 - c2).elements())
В качестве альтернативы, в зависимости от ваших предпочтений читаемости, он делает достойный однострочный:
diff = list((Counter(lst1) - Counter(lst2)).elements())
Выход:
['Three', 'Four']
Обратите внимание, что вы можете удалить вызов list(...)
, если вы просто выполняете итерацию по нему.
Поскольку это решение использует счетчики, оно обрабатывает величины должным образом vs многие ответы на основе набора. Например, на этом входе:
lst1 = ['One', 'Two', 'Two', 'Two', 'Three', 'Three', 'Four']
lst2 = ['One', 'Two']
Выход:
['Two', 'Two', 'Three', 'Three', 'Four']
Может быть выполнено с помощью оператора python XOR.
set(temp1) ^ set(temp2)
temp1 = ['1','2','3'], temp2 =['2','3','4'] , answer : ['3','2']
почему?
– JessieB
13 June 2017 в 06:01
это может быть даже быстрее, чем понимание списка Маркса:
list(itertools.filterfalse(set(temp2).__contains__, temp1))
from itertools import filterfalse
здесь. Также обратите внимание, что это не возвращает последовательность, как остальные, она возвращает итератор.
– Matt Luongo
17 January 2012 в 18:16