389

আমার নিম্নলিখিত ফাংশনটি প্রয়োজন:

ইনপুট : কlist

আউটপুট :

True যদি ইনপুট তালিকার সমস্ত উপাদান মান সমতা অপারেটরটি ব্যবহার করে একে অপরের সমান হিসাবে মূল্যায়ন করে;
False অন্যথায়।

পারফরম্যান্স : অবশ্যই, আমি কোনও অপ্রয়োজনীয় ওভারহেড ব্যয় করতে পছন্দ করি না।

আমি মনে করি এটি সবচেয়ে ভাল হবে:

তালিকা মাধ্যমে পুনরাবৃত্তি
সংলগ্ন উপাদানগুলির তুলনা করুন
এবং ANDসমস্ত ফলস্বরূপ বুলিয়ান মান

তবে আমি নিশ্চিত নই যে এটি করার সর্বাধিক পাইথোনিক উপায়।

সংক্ষিপ্ত-সার্কিট বৈশিষ্ট্যের অভাব কেবলমাত্র দীর্ঘ ইনপুট (50 ডলারের বেশি উপাদান) -এর উপর ব্যাথা দেয় যা প্রথমদিকে অসম উপাদান রয়েছে। যদি এটি প্রায়শই পর্যাপ্ত পরিমাণে ঘটে থাকে (কতক্ষণ তালিকাগুলি হতে পারে তার উপর কতক্ষণ নির্ভর করে), শর্ট সার্কিটের প্রয়োজন। সেরা শর্ট সার্কিট অ্যালগরিদমটি @ কেনিটিএম বলে মনে হচ্ছে checkEqual1। এটি প্রদান করে তবে এর জন্য একটি উল্লেখযোগ্য ব্যয়:

প্রায়-অভিন্ন তালিকাতে 20x পর্যন্ত কার্য সম্পাদন
সংক্ষিপ্ত তালিকায় কর্মক্ষমতা 2.5x পর্যন্ত in

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

python algorithm comparison

— সর্বোচ্চ
সূত্র

3

হিসাবে সমান a == bবা হিসাবে অভিন্ন a is b?

— কেনেটিএম

1

সমাধান খালি তালিকা পরিচালনা করা উচিত? তা হলে কী ফিরিয়ে দেওয়া উচিত?

— ডগ

1

A == খ এর সমান। খালি তালিকা হ্যান্ডেল করা উচিত, এবং সত্য ফিরে আসা উচিত।

— সর্বাধিক

2

যদিও আমি জানি যে এটি অন্যান্য কয়েকটি প্রস্তাবনার চেয়ে ধীর, তবুও আমি অবাক হওয়ার functools.reduce(operator.eq, a)মতো পরামর্শ দেওয়া হয়নি।

— ব্যবহারকারী 2846495

420

সাধারণ পদ্ধতি:

def checkEqual1(iterator):
    iterator = iter(iterator)
    try:
        first = next(iterator)
    except StopIteration:
        return True
    return all(first == rest for rest in iterator)

এক রৈখিক:

def checkEqual2(iterator):
   return len(set(iterator)) <= 1

ওয়ান-লাইনার:

def checkEqual3(lst):
   return lst[1:] == lst[:-1]

3 সংস্করণের মধ্যে পার্থক্য হ'ল:

ইন checkEqual2বিষয়বস্তু hashable হতে হবে।
checkEqual1এবং যে কোনও পুনরাবৃত্তকারী checkEqual2ব্যবহার করতে পারে তবে checkEqual3অবশ্যই একটি সিকোয়েন্স ইনপুট নিতে হবে, সাধারণত কংক্রিটের পাত্রে যেমন একটি তালিকা বা টিপল।
checkEqual1 পার্থক্য পাওয়া মাত্রই থামে।
যেহেতু checkEqual1পাইথন কোড বেশি রয়েছে তাই শুরুতে অনেকগুলি আইটেম সমান হলে এটি কম দক্ষ হয়।
যেহেতু checkEqual2এবং checkEqual3সর্বদা ও (এন) অনুলিপি অপারেশনগুলি সম্পাদন করে, আপনার বেশিরভাগ ইনপুট মিথ্যা ফেরত দিলে তারা বেশি সময় নিতে পারে।
জন্য checkEqual2এবং checkEqual3তা থেকে তুলনা মানিয়ে কঠিন a == bথেকে a is b।

timeit ফলাফল, পাইথন ২.7 এর জন্য (কেবল এস 1, এস 4, এস 7, এস 9 এর সত্য প্রত্যাবর্তন করা উচিত)

s1 = [1] * 5000
s2 = [1] * 4999 + [2]
s3 = [2] + [1]*4999
s4 = [set([9])] * 5000
s5 = [set([9])] * 4999 + [set([10])]
s6 = [set([10])] + [set([9])] * 4999
s7 = [1,1]
s8 = [1,2]
s9 = []

আমরা পেতে

      | checkEqual1 | checkEqual2 | checkEqual3  | checkEqualIvo | checkEqual6502 |
|-----|-------------|-------------|--------------|---------------|----------------|
| s1  | 1.19   msec | 348    usec | 183     usec | 51.6    usec  | 121     usec   |
| s2  | 1.17   msec | 376    usec | 185     usec | 50.9    usec  | 118     usec   |
| s3  | 4.17   usec | 348    usec | 120     usec | 264     usec  | 61.3    usec   |
|     |             |             |              |               |                |
| s4  | 1.73   msec |             | 182     usec | 50.5    usec  | 121     usec   |
| s5  | 1.71   msec |             | 181     usec | 50.6    usec  | 125     usec   |
| s6  | 4.29   usec |             | 122     usec | 423     usec  | 61.1    usec   |
|     |             |             |              |               |                |
| s7  | 3.1    usec | 1.4    usec | 1.24    usec | 0.932   usec  | 1.92    usec   |
| s8  | 4.07   usec | 1.54   usec | 1.28    usec | 0.997   usec  | 1.79    usec   |
| s9  | 5.91   usec | 1.25   usec | 0.749   usec | 0.407   usec  | 0.386   usec   |

বিঃদ্রঃ:

# http://stackoverflow.com/q/3844948/
def checkEqualIvo(lst):
    return not lst or lst.count(lst[0]) == len(lst)

# http://stackoverflow.com/q/3844931/
def checkEqual6502(lst):
    return not lst or [lst[0]]*len(lst) == lst

— kennytm
সূত্র

1

ধন্যবাদ, এটি বিকল্পগুলির একটি সত্যই সহায়ক ব্যাখ্যা। আপনি কি দয়া করে আপনার পারফরম্যান্স টেবিলটি দুটিবার যাচাই করতে পারেন - এটি কি সমস্ত এমসিতে রয়েছে এবং সঠিক কোষগুলিতে কি সংখ্যা রয়েছে?

— সর্বোচ্চ

7

@ ম্যাক্স: হ্যাঁ নোট করুন যে 1 ম্যাসি = 1000 ইউজেক।

— কেনেটিএম

1

খুব বড় অ্যারেগুলির জন্য মেমরি ব্যবহার বিশ্লেষণটি ভুলে যাবেন না, এমন একটি নেটিভ সমাধান যা obj.__eq__কখন কলগুলিকে lhs is rhsঅপ্টিমাইজ করে এবং শর্ট সার্কিটগুলি বাছাই করা তালিকাগুলি আরও দ্রুত সঞ্চার করার জন্য আউট অফ-অর্ডার অপ্টিমাইজেশান।

— গ্লেন মেইনার্ড 8

3

আইভো ভ্যান ডের উইজকের সিকোয়েন্সগুলির জন্য আরও ভাল সমাধান রয়েছে যা মেমরিতে সেট এবং ও (1) এর চেয়ে প্রায় 5 গুণ বেশি দ্রুত।

— অ্যারোনস্টার্লিং

2

একটি itertoolsরেসিপিও রয়েছে যা আমি উত্তর হিসাবে যুক্ত করেছি। এটি আপনার টাইমিং ম্যাট্রিক্স :-) এ ছুঁড়ে ফেলার উপযুক্ত হতে পারে।

— মিগিলসন 21

298

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

x.count(x[0]) == len(x)

কিছু সাধারণ মানদণ্ড:

>>> timeit.timeit('len(set(s1))<=1', 's1=[1]*5000', number=10000)
1.4383411407470703
>>> timeit.timeit('len(set(s1))<=1', 's1=[1]*4999+[2]', number=10000)
1.4765670299530029
>>> timeit.timeit('s1.count(s1[0])==len(s1)', 's1=[1]*5000', number=10000)
0.26274609565734863
>>> timeit.timeit('s1.count(s1[0])==len(s1)', 's1=[1]*4999+[2]', number=10000)
0.25654196739196777

— আইভো ভ্যান ডের উইজক
সূত্র

5

ওএমজি, এটি সেট সমাধানের চেয়ে 6 গুণ দ্রুত! (আমার ল্যাপটপে 28 মিলিয়ন উপাদান / সেকেন্ড বনাম 45 মিলিয়ন উপাদান / সেকেন্ড)। কেন ??? এবং এটিকে সংশোধন করার কোনও উপায় আছে যাতে এটি শর্ট সার্কিট (আমার ধারণা হয় না ...)

— সর্বোচ্চ

1

আমার ধারণা, তালিকা কোডের একটি অত্যন্ত অনুকূল সি বাস্তবায়ন রয়েছে এবং তালিকার দৈর্ঘ্য অভ্যন্তরীণভাবে সংরক্ষণ করা হয়, সুতরাং লেন ()ও সস্তা। শর্ট-সার্কিট গণনা করার কোনও উপায় নেই () যেহেতু সঠিক গণনা করার জন্য আপনাকে অবশ্যই সমস্ত উপাদান পরীক্ষা করতে হবে।

— আইভো ভ্যান ডের উইজক

আমি কি এটিকে পরিবর্তন করতে পারি: x.count(next(x)) == len(x)যাতে এটি কোনও ধারক এক্স এর জন্য কাজ করে? আহ .. এনএম, কেবল দেখেছি যে হিসাবটি কেবল সিকোয়েন্সের জন্য উপলব্ধ .. কেন এটি অন্যান্য বিল্টিন পাত্রে প্রয়োগ করা হয় না? কোনও অভিধানের মধ্যে গণনা কী অন্তর্নিহিতভাবে অর্থের তুলনায় কোনও তালিকার চেয়ে কম অর্থবহ?

— সর্বাধিক

4

একটি পুনরাবৃত্তির দৈর্ঘ্য নাও থাকতে পারে। যেমন এটি অসীম বা কেবল গতিশীলভাবে উত্পন্ন হতে পারে। আপনি কেবলমাত্র একটি তালিকায় রূপান্তর করে এটির দৈর্ঘ্যটি খুঁজে পেতে পারেন যা বেশিরভাগ পুনরাবৃত্তির সুবিধা নিয়ে যায়

— Ivo van der Wijk

দুঃখিত, আমি যা বোঝাতে চেয়েছিলাম তা কেন পুনরুক্তিযোগ্যদের জন্য countপ্রয়োগ করা হয়নি, কেন lenপুনরুক্তিকারীদের জন্য উপলব্ধ নয়। উত্তর সম্ভবত এটি কেবল একটি পর্যবেক্ষণ। তবে এটি আমাদের জন্য অপ্রাসঙ্গিক কারণ .count()সিকোয়েন্সগুলির জন্য ডিফল্টটি খুব ধীর (খাঁটি পাইথন)। আপনার সমাধানটি এত দ্রুত হওয়ার কারণ হ'ল এটি countসরবরাহিত সি-প্রয়োগ করা উপর নির্ভর করে list। সুতরাং আমি অনুমান করি যে countসিতে পদ্ধতি বাস্তবায়নের ক্ষেত্রে যা ঘটতে পারে তা আপনার পদ্ধতির দ্বারা উপকৃত হবে।

— সর্বাধিক

163

সহজ এবং সবচেয়ে মার্জিত উপায় নীচে:

all(x==myList[0] for x in myList)

(হ্যাঁ, এটি খালি তালিকার সাথেও কাজ করে! এটি অজস্র অলস শব্দার্থবিজ্ঞান রয়েছে এমন কয়েকটি ক্ষেত্রে এটি একটি)

পারফরম্যান্স সম্পর্কে, এটি যত তাড়াতাড়ি সম্ভব ব্যর্থ হবে, সুতরাং এটি asympototically অনুকূল।

— ninjagecko
সূত্র

এই কাজ, কিন্তু এটি একটি বিট (1.5x) @KennyTM তুলনায় ধীর এর checkEqual1। আমি নিশ্চিত না কেন।

— সর্বাধিক

4

সর্বাধিক: সম্ভবত কারণ আমি অপ্টিমাইজেশন সম্পাদন করতে বিরক্ত করিনি first=myList[0] all(x==first for x in myList), সম্ভবত

— ninjagecko

আমি মনে করি যে প্রতিটি লিখনের সাথে মাইলিস্ট [0] মূল্যায়ন করা হয়। >>> টাইমিট.টাইমাইট ('সব ([y == x [0] এক্স এর জন্য y]])', 'x = [1] * 4000', সংখ্যা = 10000) >>70 সময়সীমার সময়কাল ('x0 = x [0]; সব ([y == x0 x এর জন্য x]) ',' x = [1] * 4000 ', সংখ্যা = 10000) 2.0908854261426484

— ম্যাট লিবার্টি

1

আমার অবশ্যই স্পষ্ট করে বলা উচিত যে অপ্টিমাইজেশনটি একটি খালি তালিকায় first=myList[0]ফেলে দেবে IndexError, সুতরাং যে মন্তব্যকারীরা আমি উল্লেখ করেছেন সেই অপ্টিমাইজেশনের কথা বলছেন তাদের একটি খালি তালিকার প্রান্ত-কেস নিয়ে কাজ করতে হবে। তবে মূল জরিমানা ( x==myList[0]মধ্যে জরিমানা allকরা হয়েছে কারণ এটি মূল্যায়ন করা হয় না যদি তালিকাটি খালি থাকে)।

— নিনজাগেকো

1

এটি পরিষ্কারভাবে এটি সঠিক উপায়। আপনি যদি প্রতিটি ক্ষেত্রে গতি চান, তবে নমপির মতো কিছু ব্যবহার করুন।

— হেনরি গোমারসাল

45

একটি সেট তুলনা কাজ:

len(set(the_list)) == 1

ব্যবহার করে setসমস্ত সদৃশ উপাদান সরানো হয়।

— cbalawat
সূত্র

26

আপনি তালিকাটি সেটটিতে রূপান্তর করতে পারেন। একটি সেট সদৃশ থাকতে পারে না। সুতরাং যদি মূল তালিকার সমস্ত উপাদান অভিন্ন হয় তবে সেটটিতে কেবলমাত্র একটি উপাদান থাকবে।

if len(sets.Set(input_list)) == 1
// input_list has all identical elements.

— codaddict
সূত্র

এটি দুর্দান্ত তবে এটি শর্ট সার্কিট নয় এবং আপনাকে ফলাফলের তালিকার দৈর্ঘ্য গণনা করতে হবে।

— অ্যারোনস্টার্লিং

15

শুধু না কেন len(set(input_list)) == 1?

— নিক ডানডোলাকিস

2

@codaddict। এর অর্থ হ'ল প্রথম দুটি উপাদান পৃথক হলেও এটি এখনও পুরো অনুসন্ধান সম্পূর্ণ করবে। এটি ও (কে) অতিরিক্ত স্থানও ব্যবহার করে যেখানে কে তালিকার পৃথক উপাদানের সংখ্যা।

— অ্যারোনস্টার্লিং

1

@max। কারণ সেটটি তৈরি করা সি-তে ঘটে এবং আপনার একটি খারাপ বাস্তবায়ন হয়েছে। আপনার জেনারেটর এক্সপ্রেশনে কমপক্ষে এটি করা উচিত। কোনও সেট ব্যবহার না করে কীভাবে এটি সঠিকভাবে করা যায় তার জন্য কেনিটিএম এর উত্তর দেখুন।

— অ্যারোনস্টার্লিং

1

সেটস.সেটটি "সংস্করণ ২.২ থেকে অবনতিযুক্ত: অন্তর্নির্মিত সেট / হিমায়িত প্রকারগুলি এই মডিউলটি প্রতিস্থাপন করে।" ( ডকস.পিথন.আর. / ২ / লাইব্রেরি / সেটস html থেকে )

— মোবার্গ

21

এটি মূল্যবান জন্য, এটি সম্প্রতি পাইথন-আইডিয়া মেলিং তালিকায় উঠে আসে । দেখা যাচ্ছে যে ইতিমধ্যে এটি করার জন্য একটি ইটারটোল রেসিপি রয়েছে : ¹

def all_equal(iterable):
    "Returns True if all the elements are equal to each other"
    g = groupby(iterable)
    return next(g, True) and not next(g, False)

মনে হয় এটি খুব সুন্দরভাবে সম্পাদন করে এবং কয়েকটি চমৎকার বৈশিষ্ট্য রয়েছে।

শর্ট সার্কিট: এটি প্রথম অ-সমতুল্য আইটেমটি খুঁজে পাওয়ার সাথে সাথে এটি পুনরাবৃত্ত হতে আইটেম গ্রহণ বন্ধ করবে।
আইটেমগুলি হ্যাশেবল হওয়ার দরকার নেই।
এটি অলস এবং চেকটি করতে কেবল ও (1) অতিরিক্ত মেমরির প্রয়োজন।

^{¹ অন্য কথায়, আমি সমাধানটি সামনে আসার কৃতিত্ব নিতে পারি না - এমনকি এটি সন্ধান করার জন্যও আমি কৃতিত্ব নিতে পারি না।}

— mgilson
সূত্র

3

সবচেয়ে খারাপ ক্ষেত্রে এখানে তালিকাবদ্ধ দ্রুততম উত্তরের চেয়ে অনেক দ্রুত

— চেইমজি

return next(g, f := next(g, g)) == f(অবশ্যই py3.8 থেকে)

— Chris_Rands

17

এটি করার দুটি সহজ উপায় এখানে

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

তালিকায় কোনও সেটে রূপান্তর করার সময় সদৃশ উপাদানগুলি সরানো হয়। সুতরাং রূপান্তরিত সেটটির দৈর্ঘ্য যদি 1 হয়, তবে এর থেকে বোঝা যায় যে সমস্ত উপাদান একই।

len(set(input_list))==1

এখানে একটি উদাহরণ

>>> a = ['not', 'the', 'same']
>>> b = ['same', 'same', 'same']
>>> len(set(a))==1  # == 3
False
>>> len(set(b))==1  # == 1
True

সমস্ত ব্যবহার করে ()

এটি ইনপুট তালিকার প্রথম উপাদানটিকে তালিকার প্রতিটি অন্যান্য উপাদানের সাথে তুলনা করবে (সমতা)। সমস্ত যদি সমতুল্য হয় সত্যটি ফিরে আসবে, অন্যথায় মিথ্যা ফিরিয়ে দেওয়া হবে।

all(element==input_list[0] for element in input_list)

এখানে একটি উদাহরণ

>>> a = [1, 2, 3, 4, 5]
>>> b = [1, 1, 1, 1, 1]
>>> all(number==a[0] for number in a)
False
>>> all(number==b[0] for number in b)
True

PS আপনি যদি পুরো তালিকাটি একটি নির্দিষ্ট মানের সমান কিনা তা পরীক্ষা করে দেখছেন, আপনি ইনপুট_লিস্ট [0] এর জন্য মানটি suibstitue করতে পারেন।

— ক্রিস্টোফার নুসিও
সূত্র

1

রানটাইমের প্রতি আগ্রহী ব্যক্তিদের জন্য, len(set(a))10,000,000 উপাদানের তালিকার উপর সম্পাদনা করতে 0.09 সেকেন্ড সময় allলেগেছিল যদিও সম্পাদনাটি 0.9 s (10 গুণ বেশি সময়) নেয়।

— এলিপটিকা

2

@ এলিপটিকার দ্বারা উল্লিখিত পারফরম্যান্স স্কোর ছাড়াও

— নিকব্রুনেজেল

11

এটি len(set(x))==1দীর্ঘ বিকল্পের চেয়ে দ্রুততর বিকল্প (শর্ট সার্কিট ব্যবহার করে)

def constantList(x):
    return x and [x[0]]*len(x) == x

— 6502
সূত্র

এটি শর্ট সার্কিট উপেক্ষা করে আমার কম্পিউটারে সেট সমাধানের চেয়ে 3 গুণ ধীর। সুতরাং তালিকার প্রথম তৃতীয়টিতে যদি অসম উপাদানটি গড়ে পাওয়া যায়, তবে এটি গড়ে দ্রুত হয়।

— সর্বোচ্চ

9

এটি করার একটি সহজ উপায়:

result = mylist and all(mylist[0] == elem for elem in mylist)

এটি কিছুটা জটিল, এতে কল ওভারহেড ফাংশন আসে, তবে শব্দার্থবিজ্ঞানগুলি আরও স্পষ্টভাবে বানানযুক্ত:

def all_identical(seq):
    if not seq:
        # empty list is False.
        return False
    first = seq[0]
    return all(first == elem for elem in seq)

— Jerub
সূত্র

আপনি এখানে ব্যবহার করে একটি অপ্রয়োজনীয় তুলনা এড়াতে পারেন for elem in mylist[1:]। সন্দেহ এটি গতি অনেক উন্নত যদিও আমি অনুমান করি elem[0] is elem[0]যে কারণে অনুবাদক সম্ভবত খুব দ্রুত এই তুলনা করতে পারে।

— ব্রেন্ডন

5

সমস্ত উপাদান প্রথমটির সমান কিনা তা পরীক্ষা করে দেখুন।

np.allclose(array, array[0])

— গুসেভ স্লাভা
সূত্র

তৃতীয় পক্ষের মডিউল প্রয়োজন।

— বাচ্চাউ

4

সন্দেহ এটি "সর্বাধিক পাইথোনিক" তবে এর মতো কিছু:

>>> falseList = [1,2,3,4]
>>> trueList = [1, 1, 1]
>>> 
>>> def testList(list):
...   for item in list[1:]:
...     if item != list[0]:
...       return False
...   return True
... 
>>> testList(falseList)
False
>>> testList(trueList)
True

কৌতুক করবে।

— machineghost
সূত্র

1

আপনার forলুপটিকে আরও if any(item != list[0] for item in list[1:]): return Falseএকই শব্দার্থক দ্বারা আরও পাইথোনিক তৈরি করা যেতে পারে ।

— 18:58

4

আপনি যদি কিছুটা বেশি পঠনযোগ্য কিছুতে আগ্রহী হন (তবে অবশ্যই তেমন দক্ষ নয়) আপনি চেষ্টা করতে পারেন:

def compare_lists(list1, list2):
    if len(list1) != len(list2): # Weed out unequal length lists.
        return False
    for item in list1:
        if item not in list2:
            return False
    return True

a_list_1 = ['apple', 'orange', 'grape', 'pear']
a_list_2 = ['pear', 'orange', 'grape', 'apple']

b_list_1 = ['apple', 'orange', 'grape', 'pear']
b_list_2 = ['apple', 'orange', 'banana', 'pear']

c_list_1 = ['apple', 'orange', 'grape']
c_list_2 = ['grape', 'orange']

print compare_lists(a_list_1, a_list_2) # Returns True
print compare_lists(b_list_1, b_list_2) # Returns False
print compare_lists(c_list_1, c_list_2) # Returns False

— জোশুয়া বার্নস
সূত্র

আমি আসলে চেষ্টা করছি যে একটি তালিকার সমস্ত উপাদান অভিন্ন কিনা; দুটি পৃথক তালিকা একরকম না হলে নয়।

— সর্বাধিক

4

তালিকাটিকে সেটে রূপান্তর করুন এবং তারপরে সেটে উপাদানগুলির সংখ্যা সন্ধান করুন। যদি ফলাফলটি 1 হয় তবে এর অভিন্ন উপাদান রয়েছে এবং যদি তা না হয় তবে তালিকার উপাদানগুলি অভিন্ন নয়।

list1 = [1,1,1]
len(set(list1)) 
>1

list1 = [1,2,3]
len(set(list1)
>3

— ডেপ
সূত্র

4

reduce()সাথে ব্যবহার সম্পর্কে lambda। এখানে একটি কার্যকারী কোড যা আমি ব্যক্তিগতভাবে অন্য উত্তরগুলির চেয়ে বেশ ভাল মনে করি।

reduce(lambda x, y: (x[1]==y, y), [2, 2, 2], (True, 2))

এমন একটি টুপল ফেরত দেয় যেখানে সমস্ত মান একই হয় বা না থাকলে প্রথম মান বুলিয়ান।

— মার্কাস লিন্ড
সূত্র

লিখিত (চেষ্টা করুন [1, 2, 2]) হিসাবে কোডটিতে একটি ছোট্ট ভুল রয়েছে : এটি পূর্বের বুলিয়ান মানটিকে বিবেচনায় নেয় না। এটি প্রতিস্থাপনের x[1] == yমাধ্যমে স্থির করা যেতে পারে x[0] and x[1] == y।

— স্কচট

3

আমি করতাম:

not any((x[i] != x[i+1] for i in range(0, len(x)-1)))

যেহেতু anyএটির Trueশর্তটি পাওয়া মাত্র পুনরাবৃত্তিযোগ্যদের অনুসন্ধান করা বন্ধ করে দেয় ।

— রবার্ট রসনি
সূত্র

জেনারেটর এক্সপ্রেশনটির চারপাশে আপনার অতিরিক্ত বন্ধনী প্রয়োজন হবে না যদি এটি একমাত্র যুক্তি।

— নিনজাগেকো

তাই না all(), কেন ব্যবহার all(x == seq[0] for x in seq)করবেন না ? আরো অজগর দেখায় এবং একই সম্পাদন করা উচিত

— চেন এ।

2

>>> a = [1, 2, 3, 4, 5, 6]
>>> z = [(a[x], a[x+1]) for x in range(0, len(a)-1)]
>>> z
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
# Replacing it with the test
>>> z = [(a[x] == a[x+1]) for x in range(0, len(a)-1)]
>>> z
[False, False, False, False, False]
>>> if False in z : Print "All elements are not equal"

— pyfunc
সূত্র

2

def allTheSame(i):
    j = itertools.groupby(i)
    for k in j: break
    for k in j: return False
    return True

পাইথন ২.৪-এ কাজ করে, যার "সমস্ত" নেই।

— itertool
সূত্র

1

for k in j: breakসমতূল্য next(j)। আপনি def allTheSame(x): return len(list(itertools.groupby(x))<2)দক্ষতার যত্ন না নিলে আপনিও করতে পারতেন ।

— নিনজাগেকো

2

মানচিত্র এবং ল্যাম্বদা ব্যবহার করতে পারেন

lst = [1,1,1,1,1,1,1,1,1]

print all(map(lambda x: x == lst[0], lst[1:]))

— SuperNova
সূত্র

2

বা diffনমির পদ্ধতি ব্যবহার করুন :

import numpy as np
def allthesame(l):
    return np.all(np.diff(l)==0)

এবং কল করতে:

print(allthesame([1,1,1]))

আউটপুট:

True

— U10 এগিয়ে
সূত্র

আমি মনে করি not np.any(np.diff(l))কিছুটা দ্রুত হতে পারে।

— GZ0

2

বা নমপির বিভিন্ন পদ্ধতি ব্যবহার করুন:

import numpy as np
def allthesame(l):
    return np.unique(l).shape[0]<=1

এবং কল করতে:

print(allthesame([1,1,1]))

আউটপুট:

সত্য

— লুইস বি
সূত্র

এই উত্তরটি গত বছর থেকে ইউ 9-ফরওয়ার্ডের উত্তরের মতো।

— mhwombat

শুভ চোখ! আমি একই কাঠামো / এপিআই ব্যবহার করেছি তবে আমার পদ্ধতিতে এনপি.উনিক এবং আকৃতি ব্যবহার করা হয়েছে। ইউ 9 এর ফাংশনে এনপি.এল () এবং এনপি.ডিফ () ব্যবহার করা হয় - আমি এই ফাংশনগুলির কোনওটিই ব্যবহার করি না।

— লুইস বি

1

আপনি করতে পারেন:

reduce(and_, (x==yourList[0] for x in yourList), True)

এটি মোটামুটি বিরক্তিকর যে পাইথন আপনাকে অপারেটরগুলির মতো আমদানি করে তোলে operator.and_। পাইথন 3 হিসাবে, আপনাকেও আমদানি করতে হবেfunctools.reduce ।

(আপনার এই পদ্ধতিটি ব্যবহার করা উচিত নয় কারণ এটি অ-সমমানের মানগুলি খুঁজে পেলে এটি ভঙ্গ হবে না, তবে পুরো তালিকাটি পরীক্ষা করে চালিয়ে যাবে It এটি কেবলমাত্র সম্পূর্ণতার উত্তর হিসাবে এখানে অন্তর্ভুক্ত করা হয়েছে))

— ninjagecko
সূত্র

এটি শর্ট সার্কিট হবে না। আপনি কেন এটি আপনার অন্যান্য সমাধানের চেয়ে পছন্দ করবেন?

— সর্বাধিক

@ ম্যাক্স: আপনি ঠিক এই কারণে করতেন না; আমি এটি সম্পূর্ণতার জন্যই অন্তর্ভুক্ত করেছি। ধন্যবাদ আমি সম্ভবত এটি সম্পাদনা করা উচিত, ধন্যবাদ।

— নিনজাগেকো

1

lambda lst: reduce(lambda a,b:(b,b==a[0] and a[1]), lst, (lst[0], True))[1]

পরেরটি শর্ট সার্কিট করবে:

all(itertools.imap(lambda i:yourlist[i]==yourlist[i+1], xrange(len(yourlist)-1)))

— user3015260
সূত্র

আপনার প্রথম কোডটি অবশ্যই স্পষ্টত ভুল ছিল: reduce(lambda a,b:a==b, [2,2,2])ফলন False... আমি এটি সম্পাদনা করেছি, তবে এইভাবে এটি আর সুন্দর নয়

— বার্ডারিও ২

@ বার্ডারিও তারপরে অন্য কারও লেখা যা পরিবর্তন করা তার পরিবর্তে আপনার নিজের উত্তরটি লেখা উচিত ছিল। যদি আপনি এই উত্তরটি ভুল বলে মনে করেন তবে আপনি এটিতে মন্তব্য করতে পারেন এবং / অথবা এটি ডাউনওয়েট করতে পারেন।

— গর্পিক

3

সমস্ত লোকেরা এটি পড়ার জন্য এটি রেখে দেওয়ার চেয়ে কোনও ভুল সমাধান করা ভাল, সম্ভবত যে মন্তব্যটি ভুল তা কেন ব্যাখ্যা করেছে তা

— মিস করবেন

3

"কখন আমার পোস্টগুলি সম্পাদনা করা উচিত?" "যে কোনও সময় আপনি অনুভব করেন যে আপনি পোস্টটি আরও ভাল করে তুলতে পারেন, এবং এতে করার প্রবণতা রয়েছে Ed

— বেরডারিও

1

তালিকায় সেটটিতে পরিবর্তন করুন। তারপরে যদি সেটটির আকার মাত্র 1 হয় তবে তারা অবশ্যই একই রকম হত।

if len(set(my_list)) == 1:

— Lumo5
সূত্র

1

খাঁটি পাইথন পুনরাবৃত্তির বিকল্প রয়েছে:

 def checkEqual(lst):
    if len(lst)==2 :
        return lst[0]==lst[1]
    else:
        return lst[0]==lst[1] and checkEqual(lst[1:])

তবে কিছু কারণে এটি অন্যান্য ক্ষেত্রে অপেক্ষাকৃত কম দুটি আকারের অর্ডার। সি ভাষার মানসিকতা থেকে আগত, আমি এটি আরও দ্রুত হওয়ার প্রত্যাশা করছিলাম, তবে তা নয়!

অন্যান্য অসুবিধাটি হ'ল পাইথনে পুনরাবৃত্তি সীমা রয়েছে যা এক্ষেত্রে সামঞ্জস্য করা দরকার। উদাহরণস্বরূপ ব্যবহার এই ।

— Foad
সূত্র

0

আপনি .nunique()একটি তালিকার অনন্য আইটেমের সংখ্যা সন্ধান করতে ব্যবহার করতে পারেন ।

def identical_elements(list):
    series = pd.Series(list)
    if series.nunique() == 1: identical = True
    else:  identical = False
    return identical



identical_elements(['a', 'a'])
Out[427]: True

identical_elements(['a', 'b'])
Out[428]: False

— সাঈদ
সূত্র

0

আপনি ব্যবহার করতে পারেন set। এটি একটি সেট তৈরি করবে এবং পুনরাবৃত্তিমূলক উপাদানগুলি সরিয়ে ফেলবে। তারপরে এটিতে 1 টির বেশি উপাদান নেই।

if len(set(your_list)) <= 1:
    print('all ements are equal')

উদাহরণ:

>>> len(set([5, 5])) <= 1
True

— MHB
সূত্র

তালিকার সমস্ত উপাদান অভিন্ন কিনা তা পরীক্ষা করে দেখুন

এটি করার দুটি সহজ উপায় এখানে

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

সমস্ত ব্যবহার করে ()