তালিকাগুলি পাইথনে কোনও আইটেম ভাগ করে নিলে পরীক্ষা করুন

Question

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

In [78]: a = [1, 2, 3, 4, 5]

In [79]: b = [8, 7, 6]

In [80]: c = [8, 7, 6, 5]

In [81]: def lists_overlap(a, b):
   ....:     for i in a:
   ....:         if i in b:
   ....:             return True
   ....:     return False
   ....: 

In [82]: lists_overlap(a, b)
Out[82]: False

In [83]: lists_overlap(a, c)
Out[83]: True

In [84]: def lists_overlap2(a, b):
   ....:     return len(set(a).intersection(set(b))) > 0
   ....: 

Comments

আমি কেবলমাত্র অপ্টিমাইজেশানগুলিই বাদ পড়ছি len(...) > 0কারণ bool(set([]))ফলস ফলস। এবং অবশ্যই যদি আপনি আপনার তালিকাগুলি সেট হিসাবে সেট করে রাখেন তবে আপনি সেট ওভারহেড সেটটি সংরক্ষণ করবেন।

— এমএসডাব্লু

প্রাসঙ্গিক: stackoverflow.com/a/44786707/1959808

— Ioannis Filippidis

নোট আপনি স্বতন্ত্র পারব না যে Trueথেকে 1এবং Falseথেকে 0। not set([1]).isdisjoint([True])পায় True, অন্যান্য সমাধানের সঙ্গে একই।

— ডিমালি

Answer 1

সংক্ষিপ্ত উত্তর : ব্যবহার করুন not set(a).isdisjoint(b), এটি সাধারণত দ্রুততম।

দুটি তালিকা আছে aএবং bকোনও আইটেম ভাগ করে নিলে পরীক্ষার চারটি সাধারণ উপায় রয়েছে । প্রথম বিকল্পটি উভয়কে সেটগুলিতে রূপান্তর করা এবং তাদের ছেদটি পরীক্ষা করা যেমন:

bool(set(a) & set(b))

কারণ সেট অনুসন্ধানের তাদের হয় পাইথন একটি হ্যাশ টেবিল ব্যবহার সংরক্ষণ করা হয়,O(1) (দেখুন এখানে পাইথন মধ্যে অপারেটরদের জটিলতা সম্পর্কে আরও তথ্যের জন্য)। তাত্ত্বিকভাবে, O(n+m)এটি গড়ের জন্য nএবং mতালিকাগুলিতে aএবং অবজেক্টগুলি b। তবে 1) প্রথমে অবশ্যই তালিকাগুলির বাইরে সেট তৈরি করতে হবে, যা একটি অ-নেহাত পরিমাণ গ্রহণ করতে পারে এবং 2) এটি অনুমান করে যে হ্যাশিং সংঘর্ষগুলি আপনার ডেটাগুলির মধ্যে খুব কম।

এটি করার দ্বিতীয় উপায়টি হল জেনারেটর এক্সপ্রেশনটি তালিকাগুলিতে পুনরাবৃত্তি সম্পাদন করা যেমন:

any(i in a for i in b)

এটি স্থানটিতে অনুসন্ধান করতে দেয়, সুতরাং মধ্যবর্তী ভেরিয়েবলগুলির জন্য কোনও নতুন মেমরি বরাদ্দ করা হয় না। এটি প্রথম অনুসন্ধানেও জামিন দেয়। তবে inঅপারেটর সর্বদা O(n)তালিকায় থাকে ( এখানে দেখুন )।

আরেকটি প্রস্তাবিত বিকল্প হ'ল তালিকার একটির মধ্য দিয়ে একটি হাইব্রিড্টো পুনরাবৃত্তি, অন্যটিকে একটি সেটে রূপান্তর করুন এবং এই সেটটিতে সদস্যতার জন্য পরীক্ষা করুন, যেমন:

a = set(a); any(i in a for i in b)

চতুর্থ পন্থা হ'ল isdisjoint()(হিমায়িত) সেটগুলির পদ্ধতির সুবিধা গ্রহণ করা ( এখানে দেখুন ) উদাহরণস্বরূপ:

not set(a).isdisjoint(b)

আপনি যে উপাদানগুলি অনুসন্ধান করেছেন এটি যদি অ্যারের শুরুর কাছাকাছি হয় (যেমন এটি সাজানো থাকে) তবে জেনারেটর এক্সপ্রেশন অনুকূল হয়, কারণ সেট ছেদ পদ্ধতিটি মধ্যবর্তী ভেরিয়েবলগুলির জন্য নতুন মেমরি বরাদ্দ করতে হবে:

from timeit import timeit
>>> timeit('bool(set(a) & set(b))', setup="a=list(range(1000));b=list(range(1000))", number=100000)
26.077727576019242
>>> timeit('any(i in a for i in b)', setup="a=list(range(1000));b=list(range(1000))", number=100000)
0.16220548999262974

তালিকার আকারের কার্যক্ষেত্রে এই উদাহরণটির জন্য কার্যকর করার সময়টির একটি গ্রাফ এখানে দেওয়া হয়েছে:

লক্ষ্য করুন যে উভয় অক্ষ লোগারিথমিক। এটি জেনারেটর এক্সপ্রেশন জন্য সেরা কেস উপস্থাপন করে। যেমন দেখা যায়, isdisjoint()পদ্ধতিটি খুব ছোট তালিকা মাপের জন্য আরও ভাল, অন্যদিকে জেনারেটর এক্সপ্রেশনটি বৃহত্তর তালিকা আকারের জন্য আরও ভাল।

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

>>> timeit('any(i in a for i in b)', setup="a=list(range(1000));b=[x+998 for x in range(999,0,-1)]", number=1000))
13.739536046981812
>>> timeit('bool(set(a) & set(b))', setup="a=list(range(1000));b=[x+998 for x in range(999,0,-1)]", number=1000))
0.08102107048034668

এটি লক্ষণীয় যে জেনারেটরের এক্সপ্রেশন বড় তালিকা আকারের জন্য ধীর। এটি পূর্ববর্তী চিত্রের জন্য 100000 এর পরিবর্তে কেবল 1000 পুনরাবৃত্তির জন্য। যখন কোনও উপাদান ভাগ করা হয় না তখন এই সেটআপটিও খুব ভালভাবে সন্নিবিষ্ট হয় এবং বিভাজন এবং সেট ছেদ করার পদ্ধতির জন্য সেরা কেস।

এখানে এলোমেলো সংখ্যা ব্যবহার করে দুটি বিশ্লেষণ করা হয়েছে (একটি কৌশল বা অন্য কোনও কৌশলটির পক্ষে সেটআপটিকে কারচুপি করার পরিবর্তে):

শেয়ারিং উচ্চ উচ্চ: উপাদান এলোমেলোভাবে থেকে নেয়া হয় [1, 2*len(a)]। ভাগ করার কম সুযোগ: উপাদানগুলি এলোমেলোভাবে নেওয়া হয় [1, 1000*len(a)]।

এখন অবধি, এই বিশ্লেষণটি অনুমান করা হয় যে উভয় তালিকা একই আকারের। বিভিন্ন আকারের দুটি তালিকার ক্ষেত্রে উদাহরণস্বরূপ aঅনেক ছোট, isdisjoint()সর্বদা দ্রুত:

নিশ্চিত হয়ে নিন যে aতালিকাটি আরও ছোট, অন্যথায় কর্মক্ষমতা হ্রাস পাচ্ছে। এই পরীক্ষায় aতালিকার আকারটি স্থির করে রাখা হয়েছিল 5।

সংক্ষেপে:

• যদি তালিকাগুলি খুব ছোট হয় (<10 উপাদান), not set(a).isdisjoint(b)সর্বদা দ্রুত।
• তালিকার উপাদানগুলিকে বাছাই করা হয় বা আপনি যে নিয়মিত কাঠামোটি গ্রহণ করতে পারেন তা নিতে পারেন, তবে জেনারেটর এক্সপ্রেশনটি any(i in a for i in b)বৃহত তালিকার মাপের মধ্যে দ্রুততম;
• এর সাথে সেট ছেদটি পরীক্ষা করুন not set(a).isdisjoint(b)যা সর্বদা এর চেয়ে দ্রুত bool(set(a) & set(b))।
• সংকর "তালিকার মাধ্যমে পুনরাবৃত্তি, সেট অন টেস্ট" a = set(a); any(i in a for i in b)অন্যান্য পদ্ধতির তুলনায় সাধারণত ধীর হয়।
• জেনারেটর এক্সপ্রেশন এবং হাইব্রিড উপাদানগুলি ভাগ না করে তালিকার ক্ষেত্রে অন্য দুটি পদ্ধতির চেয়ে অনেক ধীরে ধীরে।

বেশিরভাগ ক্ষেত্রে, isdisjoint()পদ্ধতিটি ব্যবহার করা সর্বোত্তম পন্থা কারণ জেনারেটর এক্সপ্রেশনটি কার্যকর করতে অনেক বেশি সময় লাগবে, কারণ যখন কোনও উপাদান ভাগ না করা হয় তখন এটি অত্যন্ত অদক্ষ।

Comments

এটি সেখানে কিছু দরকারী ডেটা, দেখায় যে বিগ-ও বিশ্লেষণটি চলমান সময় সম্পর্কে সমস্ত যুক্তিই শেষ করে না।

— স্টিভ অ্যালিসন

সবচেয়ে খারাপ পরিস্থিতি সম্পর্কে কি? anyপ্রথম অ-মিথ্যা মান থেকে প্রস্থান করে। একমাত্র মিলনের মান শেষে রয়েছে এমন একটি তালিকা ব্যবহার করে আমরা এটি পাই: timeit('any(i in a for i in b)', setup="a=list(range(1000));b=[x+998 for x in range(999,-0,-1)]", number=1000) 13.739536046981812 timeit('bool(set(a) & set(b))', setup="a=list(range(1000));b=[x+998 for x in range(999,-0,-1)]", number=1000) 0.08102107048034668 ... এবং এটি কেবল 1000 পুনরাবৃত্তির সাথে।

— রবএম

তথ্যের জন্য @ রবমকে ধন্যবাদ। আমি এটিকে প্রতিফলিত করতে এবং এই থ্রেডে প্রস্তাবিত অন্যান্য কৌশলগুলি আমলে নেওয়ার জন্য আমার উত্তর আপডেট করেছি।

— সোরাভাক্স

not set(a).isdisjoint(b)দুটি তালিকাগুলি কোনও সদস্যকে ভাগ করে দেয় কিনা তা পরীক্ষা করা উচিত । দুটি তালিকা যদি কোনও সদস্য ভাগ না করে তবে set(a).isdisjoint(b)ফিরে আসে । উত্তরটি সম্পাদনা করা উচিত? True

— গিলোকন

শীর্ষস্থানীয়দের জন্য ধন্যবাদ, গুইলোচন, এটি ঠিক আছে।

— সোরাভাক্স

Answer 2

def lists_overlap3(a, b):
    return bool(set(a) & set(b))

দ্রষ্টব্য: উপরেরটি ধরে নেওয়া হয়েছে যে আপনি উত্তর হিসাবে একটি বুলিয়ান চান। আপনার সমস্ত প্রয়োজন যদি ifবিবৃতিতে ব্যবহার করার জন্য একটি অভিব্যক্তি হয় তবে কেবল ব্যবহার করুনif set(a) & set(b):

Comments

এটি সবচেয়ে খারাপ ক্ষেত্রে (ও + এন)। তবে নীচের দিকটি হ'ল এটি একটি নতুন সেট তৈরি করে এবং যখন কোনও সাধারণ উপাদান প্রাথমিক অবস্থায় পাওয়া যায় তখন তা জামিন দেয় না।

— ম্যাথু ফ্ল্যাশেন

আমি কেন আগ্রহী তা জানতে আগ্রহী O(n + m)। আমার ধারণাটি হ্যাশ-টেবিলগুলি ব্যবহার করে সেটগুলি প্রয়োগ করা হয় এবং এভাবে inঅপারেটর O(1)সময়মত কাজ করতে পারে (অবক্ষয়জনিত ক্ষেত্রে বাদে)। এটা কি সঠিক? যদি তাই হয়, যে হ্যাশ টেবিলগুলির সবচেয়ে খারাপ কেস লকিং পারফরম্যান্স রয়েছে O(n), তার অর্থ কি এর বিপরীততর খারাপ ক্ষেত্রে এটির O(n * m)কার্যকারিতা থাকবে?

— fmark

@ ফারমার্ক: তাত্ত্বিকভাবে, আপনি ঠিক বলেছেন। ব্যবহারিকভাবে, কেউ পাত্তা দেয় না; সিপিথন উত্সে অবজেক্টস / ডিক্টোবজেক্ট.এর মন্তব্যগুলি পড়ুন (সেটগুলি কেবল কীগুলির সাথে কেবল সারণি, কোনও মান নেই) এবং দেখুন যে আপনি কীগুলির একটি তালিকা তৈরি করতে পারেন যা ও (এন) দেখার কর্মক্ষমতা তৈরি করবে।

— জন মাচিন

ঠিক আছে, পরিষ্কার করার জন্য ধন্যবাদ, আমি ভাবছিলাম কিছু জাদু চলছে কিনা :)। যদিও আমি একমত যে বাস্তবিকভাবে আমার যত্নের প্রয়োজন নেই, তবুও কীগুলির একটি তালিকা তৈরি করা তুচ্ছ O(n), যা দেখার পারফরম্যান্সের কারণ ঘটবে ;), পেস্টবিন .com/ কেএন 3 কেএডব্লিউ 7 ইউ শুধু লাফের জন্য দেখুন।

— fmark

হ্যাঁ আমি জানি. প্লাস আমি কেবলমাত্র আপনার উত্সটি দেখিয়েছি উত্সটি পড়েছি, যা নন-এলোমেলো হ্যাশ ফাংশনগুলির ক্ষেত্রে আরও বেশি যাদু ডকুমেন্ট করে (যেমন বিল্ট-ইন হিসাবে)। আমি ধরে নিয়েছিলাম এটির জাভা জাতীয় মত এলোমেলোতা দরকার, যার ফলশ্রুতিতে এই স্ট্যাকওভারফ্লো . com/ জিজ্ঞাসা / ২63634690৯০/২ এর মতো বিপর্যয় দেখা দেয় । আমার নিজের মনে করিয়ে দেওয়া দরকার যে পাইথন জাভা নয় (ধন্যবাদ দেবতার!)।

— fmark

Answer 3

def lists_overlap(a, b):
  sb = set(b)
  return any(el in sb for el in a)

এটি অসম্পূর্ণভাবে অনুকূল (সবচেয়ে খারাপ ক্ষেত্রে ও (এন + এম)), এবং anyসংক্ষিপ্ত-সংক্ষিপ্তসার হওয়ার কারণে ছেদ করার পদ্ধতির চেয়ে ভাল হতে পারে ।

উদাহরণ:

lists_overlap([3,4,5], [1,2,3])

এটি যত তাড়াতাড়ি সত্য ফিরে আসবে 3 in sb

সম্পাদনা: আরেকটি প্রকরণ (ডেভ কির্বির সাথে ধন্যবাদ সহ):

def lists_overlap(a, b):
  sb = set(b)
  return any(itertools.imap(sb.__contains__, a))

এটি imapজেনারেটর বোধগম্যতার পরিবর্তে সি-এ প্রয়োগ করা হয় যা এর পুনরাবৃত্তির উপর নির্ভর করে । এটি sb.__contains__ম্যাপিং ফাংশন হিসাবেও ব্যবহার করে। আমি জানি না যে এটি কতটা পারফরম্যান্সের পার্থক্য করে। এটি এখনও শর্ট সার্কিট হবে।

Comments

চৌরাস্তা পদ্ধতির লুপগুলি সমস্ত সি কোডে রয়েছে; আপনার পদ্ধতির একটি লুপ রয়েছে যার মধ্যে পাইথন কোড অন্তর্ভুক্ত রয়েছে। খালি চৌরাস্তাটি সম্ভাবনা বা সম্ভাবনা কিনা তা বড় অজানা।

— জন মাচিন

any(itertools.imap(sb.__contains__, a))লাম্বদা ফাংশনটি ব্যবহার করা এড়ানো থেকে আপনি যেগুলি দ্রুত হওয়া উচিত তা ব্যবহার করতে পারেন ।

— ডেভ কার্বি

ধন্যবাদ, ডেভ :) আমি সম্মত লাম্বদা অপসারণ একটি জয়।

— ম্যাথু ফ্ল্যাশেন

Answer 4

আপনি anyতালিকা বোঝার সাথেও ব্যবহার করতে পারেন :

any([item in a for item in b])

Comments

আপনি পারতেন, তবে সময়টি O (n * m) হয় তবে সেট ছেদ করার পদ্ধতির সময় হল ও (এন + এম)। আপনি তালিকার বোঝাপড়া ছাড়াই এটি করতে পারেন (হারান []) এবং এটি দ্রুত চালিত হবে এবং কম স্মৃতি ব্যবহার করবে, তবে সময়টি এখনও ও (এন * মি) হবে।

— জন মাচিন

আপনার বড় হে বিশ্লেষণটি সত্য হলেও, আমি সন্দেহ করি যে এন এবং এম এর ছোট মানগুলির জন্য অন্তর্নিহিত হ্যাশটবগুলি তৈরি করতে যে সময় লাগে তা কার্যকর হবে। বিগ হে হ্যাশগুলি গণনা করতে সময় নেয় তা উপেক্ষা করে।

— অ্যান্টনি কনারিজ

একটি "হ্যাশটেবিল" তৈরি করা মোড়িত ও (এন)।

— জন মাচিন

আমি এটি পেয়েছি তবে আপনি যে ধ্রুবকটি ফেলে দিচ্ছেন তা বেশ বড়। এটি এন এর বৃহত মানগুলির জন্য কিছু যায় আসে না, তবে এটি ক্ষুদ্রের জন্য হয়।

— অ্যান্টনি কনারিজ

Answer 5

অজগর ২.6 বা তারপরে আপনি এটি করতে পারেন:

return not frozenset(a).isdisjoint(frozenset(b))

Comments

দেখে মনে হচ্ছে প্রথম আর্গুমেন্ট হিসাবে কাউকে কোনও সেট বা হিমায়িত সরবরাহ করতে হবে না। আমি একটি স্ট্রিং দিয়ে চেষ্টা করেছি এবং এটি কাজ করেছে (উদাহরণস্বরূপ: কোনও পুনরাবৃত্ত লোক তা করবে)।

— আকতাউ

Answer 6

আপনি যে কোনও বিল্ট ইন ফাংশন / ডাব্লু জেনারেটর এক্সপ্রেশন ব্যবহার করতে পারেন:

def list_overlap(a,b): 
     return any(i for i in a if i in b)

জন এবং লাই যেমন উল্লেখ করেছে যে এটি দু'টি তালিকার (i) == মিথ্যা দ্বারা ভাগ করে নেওয়া প্রত্যেকের জন্য ভুল ফলাফল দেয়। এটা করা উচিত:

return any(i in b for i in a)

Comments

লাই রাইনের মন্তব্য প্রশস্ত করে: bool(x)মিথ্যা যেখানে ছেদ হয় তাতে যে কোনও আইটেম x এর ভুল ফল দেবে । মিথ্যা রায়ান এর উদাহরণে, এক্স 0. শুধু ফিক্স হয় any(True for i in a if i in b)কোনটা ভাল লেখা আছে যেমন ইতিমধ্যে দেখা any(i in b for i in a)।

— জন মাচিন

কারেকশন: ভুল ফল দেবে যখন সব আইটেম xছেদ এ ধরনের যে bool(x)হয় False।

— জন মাচিন

Answer 7

এই প্রশ্নটি বেশ পুরানো, তবে আমি লক্ষ্য করেছি যে লোকেরা যখন বনাম তালিকার সেটগুলি নিয়ে বিতর্ক চালাচ্ছিল, তারা এগুলি একসাথে ব্যবহার করার কথা কেউ ভাবেনি। সোরাভাক্সের উদাহরণ অনুসরণ করে,

তালিকার জন্য সবচেয়ে খারাপ ক্ষেত্রে:

>>> timeit('bool(set(a) & set(b))',  setup="a=list(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)
100.91506409645081
>>> timeit('any(i in a for i in b)', setup="a=list(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)
19.746716022491455
>>> timeit('any(i in a for i in b)', setup="a= set(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)
0.092626094818115234

এবং তালিকার সেরা ক্ষেত্রে:

>>> timeit('bool(set(a) & set(b))',  setup="a=list(range(10000)); b=list(range(10000))", number=100000)
154.69790101051331
>>> timeit('any(i in a for i in b)', setup="a=list(range(10000)); b=list(range(10000))", number=100000)
0.082653045654296875
>>> timeit('any(i in a for i in b)', setup="a= set(range(10000)); b=list(range(10000))", number=100000)
0.08434605598449707

দুটি তালিকার মধ্য দিয়ে পুনরাবৃত্ত হওয়ার চেয়েও দ্রুত গতিতে পুনরুক্তি করা হচ্ছে যদিও এটি কোনও তালিকায় রয়েছে কিনা তা দেখার জন্য এটি একটি বুদ্ধিমান বোধ করে যে কোনও সংখ্যক সেটে আছে কিনা তা পরীক্ষা করে ধীরে ধীরে সময় লাগে যখন তালিকার মাধ্যমে পুনরুক্তি করে পরীক্ষা করে সময় ব্যয় হয় দৈর্ঘ্যের সাথে আনুপাতিক ক্রমতালিকা.

সুতরাং, আমার উপসংহারটি হ'ল তালিকার মধ্য দিয়ে পুনরাবৃত্তি হবে এবং এটি কোনও সেটে রয়েছে কিনা তা পরীক্ষা করে দেখুন ।

Comments

ব্যবহার isdisjoint(): একটি (হিমায়িত) সেট হিসাবে @Toughy দ্বারা নির্দেশিত উপর পদ্ধতি আরও উত্তম timeit('any(i in a for i in b)', setup="a= set(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)=> 0,00913715362548828

— অকটৌ

Answer 8

ওভারল্যাপিং উপাদানটি কী হতে পারে তা যদি আপনি যত্ন না করেন তবে আপনি কেবল lenসংযুক্ত তালিকার বনাম তালিকা হিসাবে সেটগুলি সংযুক্ত করে পরীক্ষা করতে পারেন । যদি ওভারল্যাপিং উপাদান থাকে তবে সেটটি ছোট হবে:

len(set(a+b+c))==len(a+b+c) সত্য সত্য, যদি কোনও ওভারল্যাপ না থাকে।

Comments

যদি প্রথম মানটি ওভারল্যাপ করে তবে এটি পুরো তালিকাটিকে একটি সেটে রূপান্তরিত করবে, যত বড়ই হোক না কেন।

— পিটার উড

Answer 9

আমি কার্যক্ষম প্রোগ্রামিং শৈলীর সাথে অন্য একজনকে ফেলে দেব:

any(map(lambda x: x in a, b))

ব্যাখ্যা:

map(lambda x: x in a, b)

বুলিয়ানগুলির একটি তালিকা প্রদান করে যেখানে উপাদানগুলি bপাওয়া যায় a। এরপরে সেই তালিকাটি পাস করা হয় anyযা Trueকোনও উপাদান থাকলে কেবল ফিরে আসে True।