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


809

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

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

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

temp3 = ['Three', 'Four']

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


14
গ্যারান্টেড উপাদানগুলি কি অনন্য? যদি আপনার থাকে temp1 = ['One', 'One', 'One']এবং temp2 = ['One'], আপনি কি ['One', 'One']ফিরে চান , বা []?
মাইকেল মরোজেক

@ মাইকেল-মরোজেক তারা অনন্য।
ম্যাক্স ফ্রেই

12
আপনি কি উপাদানগুলির ক্রম সংরক্ষণ করতে চান?
মার্ক বাইয়ার্স

উত্তর:


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


27
@ দ্রুদ্দিন: তালিকাগুলি "-" অপরেন্ডকে সমর্থন করে না। আপনি যদি ঘনিষ্ঠভাবে দেখেন তবে সেটগুলি করুন, যা করুন এবং উপরে কি প্রদর্শিত হয়।
গডস্মিথ

1
ধন্যবাদ, আমি সেট (লিস্টিএ) ব্যবহার করে শেষ করেছি। symmetric_differences (listB)
ড্রিউডিন

43
প্রতিসম পার্থক্যটি এগুলি দিয়ে লেখা যেতে পারে: ^ (set1 ^ set2)
বাস্তিয়ান

10
দয়া করে, আপনি নিজের উত্তরটি সম্পাদনা করতে পারেন এবং এটি উল্লেখ করতে পারেন যে এটি কেবলমাত্র টেম 1-টেম্প 2 প্রদান করে? .. অন্যরা যেমন বলেছে যে সমস্ত পার্থক্য ফিরিয়ে আনতে আপনাকে সিমেট্রিক পার্থক্যটি ব্যবহার করতে হবে: তালিকা (সেট (টেম্প 1) ^ সেট (টেম্প 2))
কেচাচ

আমি TypeError: 'str' object is not callableযখন এই অপারেশনটি করি a = [1,2,2,2,3]এবং কেন আমি পাইb = [2]
d8aninja

475

বিদ্যমান সমাধানগুলি যে কোনও একটি বা অন্যটি সরবরাহ করে:

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

তবে এখনও পর্যন্ত কোনও সমাধানের দুটিই নেই। যদি আপনি উভয়ই চান তবে এটি ব্যবহার করে দেখুন:

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

2
এই উত্তরের অতিরিক্ত সমর্থন: এমন একটি ব্যবহারের ক্ষেত্রে ছড়িয়ে গেল যেখানে কার্য সম্পাদনের জন্য তালিকার অর্ডার সংরক্ষণ করা গুরুত্বপূর্ণ ছিল। তারিনফো বা জিপিনফো অবজেক্টের সাথে কাজ করার সময় আমি সেট বিয়োগফল ব্যবহার করছিলাম। সংরক্ষণাগার থেকে নির্দিষ্ট ট্যারিনফো বস্তুকে নিষ্কাশন করা থেকে বাদ দিতে। এক্সট্রাকশন চলাকালীন নতুন তালিকা তৈরি করা দ্রুত তবে সুপার ধীর ছিল। কারণটি প্রথমে আমাকে এড়িয়ে গেল। টারিনফো বস্তু তালিকাকে পুনরায় অর্ডার করে তোলা এক বিশাল কর্মক্ষমতা জরিমানার কারণ। তালিকার বোধগম্য পদ্ধতিতে স্যুইচ করা দিনটি সংরক্ষণ করেছিল।
রে থম্পসন

@ মার্কবায়ার্স - সম্ভবত এটির জন্য আমার সম্পূর্ণ নতুন প্রশ্ন লেখা উচিত। তবে কীভাবে এই কাজটি ব্যর্থতায় কাজ করবে? উদাহরণস্বরূপ, যদি আমার টেম 1 এবং টেম্প 2 পরিবর্তন করে চলেছে .. এবং আমি টেম 3 এ নতুন তথ্য যুক্ত করতে চাই?
আসন

@ মার্কবায়ার্স - ভাল লাগছে। আমি এটি সম্পর্কে কিছুটা ভাবতে থাকব। তবে দুর্দান্ত সমাধানের জন্য +1।
আসন

আমি @ ডিজেল >>> টেমপ 1 = ['এক', 'দুই', 'তিন', 'চার'] >>> টেম্পো = = ['এক', 'দু', 'ছয়'] >>> এস = এর সাথে সম্মত সেট করুন (টেম্পি 2) >>> টেম্পো = = [টেমপুটিতে এক্স এর জন্য এক্স যদি এক্সটি এস না হয়] >>> টেম্প3 ['তিন', 'চার']
এয়ারলোনারেল

3
@ হ্যাকস কারণ একটি তালিকার সদস্যতা যাচাই করা একটি ও (এন) অপারেশন (পুরো তালিকার উপরে পুনরাবৃত্তি), তবে একটি সেটের সদস্যতা পরীক্ষা করা ও (1)।
মার্ক বাইয়ার্স

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

15
বাঁক temp2আগে একটি সেট এই আরও কার্যকর বিট করতে হবে।
চন্দ্রালাই

3
সত্য, নির্ভর করে যদি ওকোনাল নকলগুলি সম্পর্কে চিন্তা করে বা না (মূল প্রশ্নটি বলে না)
ম্যাট বি

2
মন্তব্য বলেছে (তালিকাগুলি | টিপলস) এর সদৃশ নেই।

1
আমি আপনার উত্তরটিকে অগ্রাহ্য করেছি কারণ আমি ভেবেছিলাম আপনি প্রথমে নকল সম্পর্কে সঠিক about তবে item not in temp2এবং item not in set(temp2)সেখানে সদৃশ থাকুক বা না থাকুক না কেন সর্বদা একই ফলাফল ফিরিয়ে দেবে temp2
arekolek

5
তালিকার আইটেমগুলি হ্যাশেবল না হওয়ার জন্য ভোট দিন।
ব্রেন্ট

23

দুটি সহজ তালিকার মধ্যে পার্থক্য (বলুন তালিকা 1 এবং তালিকা 2) নিম্নলিখিত সাধারণ ফাংশনটি ব্যবহার করে পাওয়া যাবে।

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']। আপনাকে তালিকাটির ক্রম বা প্রথমে কোন তালিকাটি দেওয়া হবে তা নিয়ে চিন্তা করার দরকার নেই।

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


7
কেন সেট করা হয়নি (list1)? Symmetric_differences (set (list2))?
সোহেল্টি

20

আপনি যদি পুনরাবৃত্তভাবে পার্থক্যটি চান তবে আমি অজগরটির জন্য একটি প্যাকেজ লিখেছি: https://github.com/seperman/DPdiff

স্থাপন

পিপিআই থেকে ইনস্টল করুন:

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

20

পাইথন এক্সওআর অপারেটর ব্যবহার করে করা যেতে পারে।

  • এটি প্রতিটি তালিকার সদৃশগুলি সরিয়ে ফেলবে
  • এটি টেম 2 থেকে টেম 1 এবং টেম 1 থেকে টেম 2 এর পার্থক্য দেখায়।

set(temp1) ^ set(temp2)

কাজ করে, তবে কেন?
জাকএস


কি উত্তর! এত অজগর !!!! আশ্চর্যজনক
toing_toing

18

সবচেয়ে সহজ উপায়,

ব্যবহার সেট ()। পার্থক্য (সেট ())

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

14

আপনি যদি সত্যিই পারফরম্যান্সের দিকে তাকাচ্ছেন, তবে অসাড় ব্যবহার করুন!

তালিকা, নকল এবং পান্ডের মধ্যে তুলনা করার সাথে গিথুবটিতে একটি টুকরো হিসাবে এখানে সম্পূর্ণ নোটবুক।

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

এখানে চিত্র বর্ণনা লিখুন


আমি লিঙ্কটিতে নোটবুক এবং স্ক্রিনশট আপডেট করেছি। আশ্চর্যজনকভাবে অভ্যন্তরীণভাবে হ্যাশটেবলে স্যুইচ করার পরেও পান্ডাস আরামের চেয়ে ধীর। আংশিক এটি int64 এ আপকাস্টিংয়ের কারণে সম্ভবত।
denfromufa

13

আমি টস করবো যেহেতু বর্তমানের সমাধানগুলির মধ্যে কোনওটিই টুপল ফলন করে না:

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

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


11

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

আপনার 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]


10

এটি মার্কের তালিকা বোধগমের চেয়ে আরও দ্রুততর হতে পারে:

list(itertools.filterfalse(set(temp2).__contains__, temp1))

7
from itertools import filterfalseবিটটি এখানে অন্তর্ভুক্ত করতে পারে । এছাড়াও মনে রাখবেন যে এটি অন্যের মতো ক্রম ফেরায় না, এটি একটি পুনরাবৃত্তিকে ফেরত দেয়।
ম্যাট লুঙ্গো

7

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(...)যদি কলটি স্রেফ পুনরাবৃত্তি করে থাকেন তবে আপনি কলটি সরাতে পারবেন ।

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

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

আউটপুটটি হ'ল:

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

5

ডিফ্লিস্টের উপাদানগুলি সাজানো এবং সেট করা থাকলে আপনি একটি নিষ্পাপ পদ্ধতি ব্যবহার করতে পারেন।

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


5

আমি এর জন্য খেলায় কিছুটা দেরি করেছি তবে আপনি উল্লিখিত কোডগুলির সাথে এর সাথে পারফরম্যান্সের তুলনা করতে পারেন, দুটি দ্রুত প্রতিযোগী হলেন,

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

5

দুটি স্ট্রিংয়ের তালিকা পৃথক করার কয়েকটি সহজ, অর্ডার-সংরক্ষণের উপায় are

কোড

ব্যবহার করে একটি অস্বাভাবিক পদ্ধতি 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']

এটি ধরে নেওয়া হয় যে উভয় তালিকায় সমান সূচনা সহ স্ট্রিং রয়েছে। আরও বিশদ জন্য ডক্স দেখুন । দ্রষ্টব্য, সেট অপারেশনের তুলনায় এটি বিশেষত দ্রুত নয়।


একটি সরাসরি-ফরওয়ার্ড বাস্তবায়ন ব্যবহার করে itertools.zip_longest:

import itertools as it


[x for x, y in it.zip_longest(temp1, temp2) if x != y]
# ['Three', 'Four']

1
Itertools সমাধান শুধুমাত্র যখন উপাদান কাজ করে temp1এবং temp2লাইন আপ ভাল। আপনি যদি উদাহরণস্বরূপ, এর শুরুতে উপাদানগুলি ঘুরিয়ে temp2বা অন্য কোনও মান সন্নিবেশ করান temp2, তবে তালিকাচম্পত ঠিক একই উপাদানগুলি ফিরিয়ে দেবেtemp1
কেনএইচবিএস

হ্যাঁ, এটি এই পদ্ধতির বৈশিষ্ট্য। উল্লিখিত হিসাবে, এই সমাধানগুলি অর্ডার সংরক্ষণের হয় - তারা তালিকার মধ্যে কিছু আপেক্ষিক ক্রম ধরে নেয়। একটি সীমাহীন সমাধান দুটি সেট পৃথক করা হবে।
পাইং 5

4

এটি অন্য একটি সমাধান:

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

4

আপনি যদি চালনা করেন তবে TypeError: unhashable type: 'list'আপনাকে তালিকাগুলি বা সেটগুলিকে টুপলগুলিতে পরিণত করতে হবে, যেমন

set(map(tuple, list_of_lists1)).symmetric_difference(set(map(tuple, list_of_lists2)))

আরও দেখুন পাইথন মধ্যে তালিকা / সেট একটি তালিকা তুলনা কিভাবে?


4

ধরা যাক আমাদের দুটি তালিকা রয়েছে

list1 = [1, 3, 5, 7, 9]
list2 = [1, 2, 3, 4, 5]

আমরা উপরের দুটি তালিকা থেকে দেখতে পাচ্ছি যে 1, 3, 5 আইটেম তালিকার 2 এবং আইটেম 7, 9 এর মধ্যে নেই। অন্যদিকে, তালিকা 1 এ আইটেম 1, 3, 5 উপস্থিত রয়েছে এবং আইটেম 2, 4 নেই।

আইটেম 7, 9 এবং 2, 4 যুক্ত একটি নতুন তালিকা ফিরিয়ে দেওয়ার সর্বোত্তম সমাধান কী?

উপরের সমস্ত উত্তর সমাধানটি সন্ধান করতে পারে, এখন সর্বাধিক অনুকূল কী?

def difference(list1, list2):
    new_list = []
    for i in list1:
        if i not in list2:
            new_list.append(i)

    for j in list2:
        if j not in list1:
            new_list.append(j)
    return new_list

বনাম

def sym_diff(list1, list2):
    return list(set(list1).symmetric_difference(set(list2)))

টাইমিট ব্যবহার করে আমরা ফলাফলগুলি দেখতে পারি

t1 = timeit.Timer("difference(list1, list2)", "from __main__ import difference, 
list1, list2")
t2 = timeit.Timer("sym_diff(list1, list2)", "from __main__ import sym_diff, 
list1, list2")

print('Using two for loops', t1.timeit(number=100000), 'Milliseconds')
print('Using two for loops', t2.timeit(number=100000), 'Milliseconds')

আয়

[7, 9, 2, 4]
Using two for loops 0.11572412995155901 Milliseconds
Using symmetric_difference 0.11285737506113946 Milliseconds

Process finished with exit code 0


3

আপনি যদি চানসেটের মতো আরও কিছু চান ... কাউন্টার ব্যবহার করতে পারেন

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"

2

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

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

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

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

2

এটি এক লাইনের সাথে সমাধান করা যেতে পারে। প্রশ্নটি দুটি তালিকাগুলি দেওয়া হয়েছে (টেম্প 1 এবং টেম্প 2) তৃতীয় তালিকায় তাদের পার্থক্য ফিরিয়ে দেয় (টেম্প3)।

temp3 = list(set(temp1).difference(set(temp2)))

1

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

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

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


0

আমি সেটগুলিতে রূপান্তর করা এবং তারপরে "পার্থক্য ()" ফাংশনটি ব্যবহার করতে পছন্দ করি। সম্পূর্ণ কোডটি হ'ল:

temp1 = ['One', 'Two', 'Three', 'Four'  ]                   
temp2 = ['One', 'Two']
set1 = set(temp1)
set2 = set(temp2)
set3 = set1.difference(set2)
temp3 = list(set3)
print(temp3)

আউটপুট:

>>>print(temp3)
['Three', 'Four']

এটি আন্ডারন্ড্যান্ড করা সবচেয়ে সহজ এবং ভবিষ্যতে মুরওভার যদি আপনি বড় ডেটা নিয়ে কাজ করেন তবে সেটগুলিতে রূপান্তর করা যদি নকলের প্রয়োজন না হয় তবে সদৃশগুলি সরিয়ে ফেলবে। আশা করি এটা সাহায্য করবে ;-)


-1
(list(set(a)-set(b))+list(set(b)-set(a)))

3
উত্তর সরবরাহ করার পাশাপাশি, আপনি কীভাবে এই নির্দিষ্ট ইস্যুতে এটি কাজ করে / প্রযোজ্য তা সম্পর্কে একটি ব্যাখ্যা দিতে পারেন? উত্তর এবং সমাধান দুর্দান্ত, তবে বিস্তারিত গাইড এবং ব্যাখ্যাগুলি অসীমভাবে আরও ভাল।
বুশে

-1
def diffList(list1, list2):     # returns the difference between two lists.
    if len(list1) > len(list2):
        return (list(set(list1) - set(list2)))
    else:
        return (list(set(list2) - set(list1)))

উদাহরণস্বরূপ যদি list1 = [10, 15, 20, 25, 30, 35, 40]এবং list2 = [25, 40, 35]তারপরে ফিরে আসা তালিকাটি থাকেoutput = [10, 20, 30, 15]


পার্থক্য অপারেশনের জন্য আপনি এটি পছন্দ করতে পারবেন না। এমনকি পূর্ণসংখ্যার ক্ষেত্রেও যদি আপনি কোনও ফাংশন 'a - b' সম্পাদন করতে বলেন তবে এটি 'বি' কে কেবল 'এ' থেকে বিয়োগ করবে বলে মনে করা হচ্ছে, 'বি' 'এ' এর চেয়ে বড় বা অন্যথায় কিছু নয়। অনুরূপ তালিকা এবং সেট ক্ষেত্রে। A - B এবং B - A এবং B এর দৈর্ঘ্য নির্বিশেষে উভয়ই বৈধ অপারেশন হতে পারে, আপনাকে A - B সম্পাদন করতে খ থেকে বি এর বিষয়বস্তু বাদ দিতে হবে
আবু তালহা ড্যানিশ ডেনিশ
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.