python - দুটি তালিকা মধ্যে পার্থক্য পান




performance list (17)

Diffist উপাদান সাজানো এবং সেট করা হয়, তাহলে আপনি একটি naive পদ্ধতি ব্যবহার করতে পারে।

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

পাইথনে দুটি তালিকা আছে, এরকম:

temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two']

প্রথম তালিকার আইটেমগুলির সাথে তৃতীয় তালিকা তৈরির জন্য আমাকে তৃতীয় তালিকা তৈরি করতে হবে। উদাহরণ থেকে আমাকে পেতে হবে:

temp3 = ['Three', 'Four']

চক্র ছাড়া এবং চেকিং কোন দ্রুত উপায় আছে?


Python XOR অপারেটর ব্যবহার করে সম্পন্ন করা যেতে পারে।

  • এটি প্রতিটি তালিকায় ডুপ্লিকেটগুলি সরিয়ে দেবে
  • এটি temp1 থেকে temp1 এবং temp1 থেকে temp2 এর পার্থক্য দেখাবে।
set(temp1) ^ set(temp2)

আপনি সত্যিই কর্মক্ষমতা খুঁজছেন, তারপর numpy ব্যবহার করুন!

এখানে তালিকা, numpy, এবং pandas মধ্যে তুলনা সঙ্গে github উপর একটি gist হিসাবে পূর্ণ নোটবুক।

https://gist.github.com/denfromufa/2821ff59b02e9482be15d27f2bbd4451


আমরা তালিকার বিচ্ছিন্নতা বিয়োগ ইউনিয়ন গণনা করতে পারেন:

temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two', 'Five']

set(temp1+temp2)-(set(temp1)&set(temp2))

Out: set(['Four', 'Five', 'Three']) 

আমি এমন কিছু চেয়েছিলাম যা দুইটি তালিকা নেবে এবং diff কী diff করতে পারে। যেহেতু আপনি এই প্রশ্নটি প্রথমে পপ আপ করেন তখন আপনি "পাইথন ডিসফের দুটি তালিকা" অনুসন্ধান করেন এবং খুব নির্দিষ্ট নয়, আমি যা পোস্ট করেছি তা পোস্ট করব।

difflib থেকে 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]

আমি টস করব কারণ বর্তমান সমাধানগুলির মধ্যে কোনটি একটি টুপল উত্পন্ন করে না:

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))

এই দিকের অন্যান্য নন-টিপল ফলপ্রসূ উত্তরগুলির মতো, এটি ক্রমানুসারে সংরক্ষণ করে


এখানে দুটি তালিকা (যা কিছু রয়েছে) পার্থক্য করার একটি সহজ উপায়, নীচে দেখানো ফলাফলটি আপনি পেতে পারেন:

>>> 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])

এই সহায়ক হবে আশা করি।


এখানে সহজতম মামলার জন্য একটি জবাব উত্তর।

এটি উপরের দিকের তুলনায় ছোট, যা দ্বি-প্রান্তের দ্বিধান্বিত কারণ এটি কেবলমাত্র প্রশ্নটি ঠিক করে দেয়: প্রথম তালিকায় যা রয়েছে তার তালিকা তৈরি করুন কিন্তু দ্বিতীয় নয়।

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(...) কলটি মুছে ফেলতে ভুলবেন।

এই সমাধান কাউন্টার ব্যবহার করে কারণ এটি অনেক সেট-ভিত্তিক উত্তরগুলি বনাম পরিমাণগুলি সঠিকভাবে পরিচালনা করে। উদাহরণস্বরূপ এই ইনপুট:

lst1 = ['One', 'Two', 'Two', 'Two', 'Three', 'Three', 'Four']
lst2 = ['One', 'Two']

আউটপুট হয়:

['Two', 'Two', 'Three', 'Three', 'Four']

এটা চেষ্টা কর:

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

দুটি তালিকাগুলির মধ্যে (পার্থক্য তালিকা 1 এবং 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'] । আপনাকে তালিকার ক্রম সম্পর্কে কোনও চিন্তা করতে হবে না বা কোন তালিকাটি প্রথমে দেওয়া উচিত।

পাইথন ডক রেফারেন্স


বিদ্যমান সমাধান সব এক বা অন্য অফার:

  • হে (এন * মি) কর্মক্ষমতা চেয়ে দ্রুত।
  • ইনপুট তালিকা আদেশ সংরক্ষণ করুন।

কিন্তু এ পর্যন্ত কোন সমাধান উভয় আছে। যদি আপনি উভয় চান, এই চেষ্টা করুন:

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

যদি আপনি একটি পরিবর্তনশীল মত আরো কিছু চাই ... কাউন্টার ব্যবহার করতে পারে

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"

যদি আপনি পার্থক্যটি পুনরাবৃত্তি করতে চান তবে আমি পাইথনের জন্য একটি প্যাকেজ লিখেছি: 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]']}

নামযুক্ত Tuples:

>>> 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}}}

Arulmr সমাধান একক লাইন সংস্করণ

def diff(listA, listB):
    return set(listA) - set(listB) | set(listA) -set(listB)

temp3 = [item for item in temp1 if item not in temp2]

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, 3]) করতে চান তবে আপনাকে set([1, 3]) ব্যবহার করতে হবে set([1, 2]).symmetric_difference(set([2, 3]))





set-difference