উত্তর:
setআপনি আইটেম ক্রম বা পুনরাবৃত্তি সম্পর্কে যত্ন না থাকলে ব্যবহার করুন । আপনি যদি তালিকা বোধগম্যতা ব্যবহার করেন :
>>> def diff(first, second):
second = set(second)
return [item for item in first if item not in second]
>>> diff(A, B)
[1, 3, 4]
>>> diff(B, A)
[5]
>>>
setতবে বি তে আবেদন করা নিরীহ নয়, তবে এটি প্রয়োগ Aএবং মূলটির পরিবর্তে ফলাফলটি ব্যবহার Aকরা নয়।
যদি অর্ডারটি কোনও বিষয় না দেয় তবে আপনি কেবল সেট পার্থক্যটি গণনা করতে পারেন:
>>> set([1,2,3,4]) - set([2,5])
set([1, 4, 3])
>>> set([2,5]) - set([1,2,3,4])
set([5])
আপনি একটি করতে পারেন
list(set(A)-set(B))এবং
list(set(B)-set(A))এক রৈখিক:
diff = lambda l1,l2: [x for x in l1 if x not in l2]
diff(A,B)
diff(B,A)
বা:
diff = lambda l1,l2: filter(lambda x: x not in l2, l1)
diff(A,B)
diff(B,A)
উপরের উদাহরণগুলি পার্থক্য গণনার সমস্যাটিকে তুচ্ছ করে তোলে। অনুমান বাছাই বা ডি-সদৃশকরণ স্পষ্টভাবে পার্থক্যটি গণনা করা সহজ করে তোলে, তবে আপনার তুলনা যদি এই অনুমানগুলি বহন করতে না পারে তবে আপনার একটি পৃথক অ্যালগরিদমের একটি অ-তুচ্ছ বাস্তবায়ন প্রয়োজন। পাইথন স্ট্যান্ডার্ড লাইব্রেরিতে ডিফ্লিব দেখুন।
from difflib import SequenceMatcher
squeeze=SequenceMatcher( None, A, B )
print "A - B = [%s]"%( reduce( lambda p,q: p+q,
map( lambda t: squeeze.a[t[1]:t[2]],
filter(lambda x:x[0]!='equal',
squeeze.get_opcodes() ) ) ) )
এ - বি = [[১, ৩, ৪]]
printএকটি কমান্ড থেকে কোনও ফাংশনে পরিবর্তিত হয়েছে এবং reduce, filterএবং mapঅযৌক্তিক ঘোষিত হয়েছে। (এবং আমি মনে করি গাইডো সঠিক হতে পারে - আমি যা বুঝতে পারি তাও বুঝতে পারি না reduce))
পাইথন 2.7.3 (ডিফল্ট, ফেব্রুয়ারী 27 2014, 19:58:35) - আইপিথন 1.1.0 - সময়কাল: ( গিথুব গিস্ট )
def diff(a, b):
b = set(b)
return [aa for aa in a if aa not in b]
def set_diff(a, b):
return list(set(a) - set(b))
diff_lamb_hension = lambda l1,l2: [x for x in l1 if x not in l2]
diff_lamb_filter = lambda l1,l2: filter(lambda x: x not in l2, l1)
from difflib import SequenceMatcher
def squeezer(a, b):
squeeze = SequenceMatcher(None, a, b)
return reduce(lambda p,q: p+q, map(
lambda t: squeeze.a[t[1]:t[2]],
filter(lambda x:x[0]!='equal',
squeeze.get_opcodes())))
ফলাফল:
# Small
a = range(10)
b = range(10/2)
timeit[diff(a, b)]
100000 loops, best of 3: 1.97 µs per loop
timeit[set_diff(a, b)]
100000 loops, best of 3: 2.71 µs per loop
timeit[diff_lamb_hension(a, b)]
100000 loops, best of 3: 2.1 µs per loop
timeit[diff_lamb_filter(a, b)]
100000 loops, best of 3: 3.58 µs per loop
timeit[squeezer(a, b)]
10000 loops, best of 3: 36 µs per loop
# Medium
a = range(10**4)
b = range(10**4/2)
timeit[diff(a, b)]
1000 loops, best of 3: 1.17 ms per loop
timeit[set_diff(a, b)]
1000 loops, best of 3: 1.27 ms per loop
timeit[diff_lamb_hension(a, b)]
1 loops, best of 3: 736 ms per loop
timeit[diff_lamb_filter(a, b)]
1 loops, best of 3: 732 ms per loop
timeit[squeezer(a, b)]
100 loops, best of 3: 12.8 ms per loop
# Big
a = xrange(10**7)
b = xrange(10**7/2)
timeit[diff(a, b)]
1 loops, best of 3: 1.74 s per loop
timeit[set_diff(a, b)]
1 loops, best of 3: 2.57 s per loop
timeit[diff_lamb_filter(a, b)]
# too long to wait for
timeit[diff_lamb_filter(a, b)]
# too long to wait for
timeit[diff_lamb_filter(a, b)]
# TypeError: sequence index must be integer, not 'slice'
@ রোমান-বোদনারুকুক তালিকা অনুধাবন ফাংশন ডিফ ডিফ (এ, খ) আরও দ্রুত বলে মনে হচ্ছে।
A = [1,2,3,4]
B = [2,5]
#A - B
x = list(set(A) - set(B))
#B - A
y = list(set(B) - set(A))
print x
print y
আপনি একটি এর setপরিবর্তে একটি ব্যবহার করতে চান list।
আপনি যদি নিজের তালিকার আইটেমগুলিতে পুনরাবৃত্তভাবে গভীর পার্থক্যটি দেখতে চান তবে অজগরটির জন্য আমি একটি প্যাকেজ লিখেছি: https://github.com/erasmose/DPdiff
পিপিআই থেকে ইনস্টল করুন:
pip install deepdiffআপনি পাইথন 3 হলে আপনাকে ইনস্টল করতে হবে:
pip install future six>>> from deepdiff import DeepDiff
>>> from pprint import pprint
>>> from __future__ import print_functionএকই জিনিস খালি ফিরে
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = t1
>>> ddiff = DeepDiff(t1, t2)
>>> print (ddiff.changes)
{}কোনও আইটেমের ধরণ বদলেছে
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:"2", 3:3}
>>> ddiff = DeepDiff(t1, t2)
>>> print (ddiff.changes)
{'type_changes': ["root[2]: 2=<type 'int'> vs. 2=<type 'str'>"]}একটি আইটেমের মান পরিবর্তন হয়েছে
>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:4, 3:3}
>>> ddiff = DeepDiff(t1, t2)
>>> print (ddiff.changes)
{'values_changed': ['root[2]: 2 ====>> 4']}আইটেম যুক্ত এবং / অথবা সরানো হয়েছে
>>> 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.changes)
{'dic_item_added': ['root[5, 6]'],
'dic_item_removed': ['root[4]'],
'values_changed': ['root[2]: 2 ====>> 4']}স্ট্রিং পার্থক্য
>>> 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.changes, indent = 2)
{ 'values_changed': [ 'root[2]: 2 ====>> 4',
"root[4]['b']:\n--- \n+++ \n@@ -1 +1 @@\n-world\n+world!"]}
>>>
>>> print (ddiff.changes['values_changed'][1])
root[4]['b']:
---
+++
@@ -1 +1 @@
-world
+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.changes, indent = 2)
{ 'values_changed': [ "root[4]['b']:\n--- \n+++ \n@@ -1,5 +1,4 @@\n-world!\n-Goodbye!\n+world\n 1\n 2\n End"]}
>>>
>>> print (ddiff.changes['values_changed'][0])
root[4]['b']:
---
+++
@@ -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.changes, indent = 2)
{ 'type_changes': [ "root[4]['b']: [1, 2, 3]=<type 'list'> vs. world\n\n\nEnd=<type 'str'>"]}তালিকার পার্থক্য
>>> 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, 2]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff.changes, indent = 2)
{ 'list_removed': ["root[4]['b']: [3]"]}তালিকার পার্থক্য 2: দ্রষ্টব্য যে এটি অর্ডারটিকে বিবেচনায় নেয় না
>>> # Note that it DOES NOT take order into account
... 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]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff.changes, indent = 2)
{ }অভিধান রয়েছে এমন তালিকা:
>>> 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.changes, indent = 2)
{ 'dic_item_removed': ["root[4]['b'][2][2]"],
'values_changed': ["root[4]['b'][2][1]: 1 ====>> 3"]}সবচেয়ে সহজ উপায়,
ব্যবহার সেট ()। পার্থক্য (সেট ())
list_a = [1,2,3]
list_b = [2,3]
print set(list_a).difference(set(list_b))উত্তর হল set([1])
অভিধানের তালিকার ক্ষেত্রে, setসমাধান উত্থাপনের সময় সম্পূর্ণ তালিকা বোঝার সমাধান কাজ করে
TypeError: unhashable type: 'dict'def diff(a, b):
return [aa for aa in a if aa not in b]
d1 = {"a":1, "b":1}
d2 = {"a":2, "b":2}
d3 = {"a":3, "b":3}
>>> diff([d1, d2, d3], [d2, d3])
[{'a': 1, 'b': 1}]
>>> diff([d1, d2, d3], [d1])
[{'a': 2, 'b': 2}, {'a': 3, 'b': 3}]ইন-অপারেটরের টাইম কমপ্লিটটি একবার দেখার জন্য, সবচেয়ে খারাপ ক্ষেত্রে এটি ও (এন) এর সাথে কাজ করে। এমনকি সেট জন্য।
সুতরাং দুটি অ্যারের তুলনা করার সময় আমাদের কাছে সবচেয়ে ভাল ক্ষেত্রে ও (এন) এবং ও (এন ity 2) এর টাইম কমপ্লিট হবে।
একটি বিকল্প (তবে দুর্ভাগ্যক্রমে আরও জটিল) সমাধান যা ও (এন) এর সাথে সবচেয়ে ভাল এবং সবচেয়ে খারাপ ক্ষেত্রে কাজ করে তা হ'ল:
# Compares the difference of list a and b
# uses a callback function to compare items
def diff(a, b, callback):
a_missing_in_b = []
ai = 0
bi = 0
a = sorted(a, callback)
b = sorted(b, callback)
while (ai < len(a)) and (bi < len(b)):
cmp = callback(a[ai], b[bi])
if cmp < 0:
a_missing_in_b.append(a[ai])
ai += 1
elif cmp > 0:
# Item b is missing in a
bi += 1
else:
# a and b intersecting on this item
ai += 1
bi += 1
# if a and b are not of same length, we need to add the remaining items
for ai in xrange(ai, len(a)):
a_missing_in_b.append(a[ai])
return a_missing_in_bযেমন
>>> a=[1,2,3]
>>> b=[2,4,6]
>>> diff(a, b, cmp)
[1, 3]
set(b)থেটার (এন ensure 2) এর পরিবর্তে অ্যালগরিদমকে ও (এনলগন) হয় তা নিশ্চিত করার জন্য ব্যবহারের কথা বিবেচনা করুন