কোনও তালিকা ইতিমধ্যে ASCবা এর মধ্যে বাছাই হয়েছে কিনা তা যাচাই করার জন্য কি পাইথোনিক উপায় আছে?DESC
listtimestamps = [1, 2, 3, 5, 6, 7]isttimestamps.isSorted()যে কিছু ফিরে Trueবা False।
আমি কিছু বার্তাগুলির জন্য টাইমস্ট্যাম্পগুলির একটি তালিকা ইনপুট করতে এবং লেনদেনগুলি সঠিক ক্রমে উপস্থিত হয়েছিল কিনা তা পরীক্ষা করতে চাই।
উত্তর:
আসলে আমরা উত্তরটি অনিহাওয়াকে দিচ্ছি না। এখানে একটি লাইনার:
all(l[i] <= l[i+1] for i in xrange(len(l)-1))পাইথন 3 এর জন্য:
all(l[i] <= l[i+1] for i in range(len(l)-1))def isSorted(x, key = lambda x: x): return all([key(x[i]) <= key(x[i + 1]) for i in xrange(len(x) - 1)])
operator.leচেয়ে দ্রুত হওয়া উচিত
l = [1, 2, 3, 4, 1, 6, 7, 8, 7] all(l[i] <= l[i+1] for i in xrange(len(l)-1))True
xrangeআর নেই, কেবল ব্যবহার করুন range। আমি NameError: name 'xrange' is not definedযখন কোডটি চালাই তখন আমি পাই। আমি এটি কেবল rangeপরিবর্তে ব্যবহার করতে স্যুইচ করেছি xrangeএবং এটি কাজ করে works দেখুন: স্ট্যাকওভারফ্লো.com
আমি শুধু ব্যবহার করতে হবে
if sorted(lst) == lst:
# code hereযদি না এটি খুব বড় তালিকা হয় তবে আপনি কাস্টম ফাংশন তৈরি করতে চাইতে পারেন।
যদি আপনি এটি বাছাই না করে যদি এটি বাছাই না করা হয়, তবে চেকটি ভুলে গিয়ে এটি বাছাই করুন।
lst.sort()এবং এটি সম্পর্কে খুব বেশি চিন্তা করবেন না।
আপনি যদি কাস্টম ফাংশন চান তবে আপনি এর মতো কিছু করতে পারেন
def is_sorted(lst, key=lambda x: x):
for i, el in enumerate(lst[1:]):
if key(el) < key(lst[i]): # i is the index of the previous element
return False
return Trueএটি ও (এন) হবে যদি তালিকাটি ইতিমধ্যে সাজানো থাকে তবে (এবং ও (এন) forসেটিতে একটি লুপে!) তাই আপনি যদি বেশিরভাগ সময় এটির (এবং মোটামুটি এলোমেলো) সাজানোর প্রত্যাশা না করেন তবে আমি চাই, আবার, কেবল তালিকা সাজান।
এই পুনরাবৃত্তকারী ফর্মটি পূর্ণসংখ্যার সূচক ব্যবহারের চেয়ে 10-15% দ্রুত:
# python2 only
if str is bytes:
from itertools import izip as zip
def is_sorted(l):
return all(a <= b for a, b in zip(l, l[1:]))izipএবং isliceএটির তরল থেকে এটি দ্রুত করতে পারেন।
এটি কার্যকর করার একটি সুন্দর উপায় হ'ল imapফাংশনটি থেকে itertools:
from itertools import imap, tee
import operator
def is_sorted(iterable, compare=operator.le):
a, b = tee(iterable)
next(b, None)
return all(imap(compare, a, b))এই বাস্তবায়ন দ্রুত এবং যেকোন পুনরাবৃত্তিতে কাজ করে।
is_sorted(iter([1,2,3,2,5,8]))বা সমমানের জেনারেটর। আপনার জন্য একটি স্বতন্ত্র পুনরাবৃত্তি ব্যবহার করতে হবে tail, চেষ্টা করুন itertools.tee।
iter(x) is xপুনরাবৃত্তিকারীদের জন্য মনে রাখবেন
itertools.imapনতুন নামকরণ করা হয়েছে [__builtins__.]map।
আমি একটি মানদণ্ড চালিয়েছি এবং । এই মানদণ্ডগুলি একটি ম্যাকবুক প্রো 2010 13 "(কোর 2 ডুও 2.66GHz, 4 জিবি 1067MHz ডিডিআর 3 র্যাম, ম্যাক ওএস এক্স 10.6.5) এ চালিত হয়েছিল।sorted(lst, reverse=True) == lstদীর্ঘ তালিকার all(l[i] >= l[i+1] for i in xrange(len(l)-1))জন্য দ্রুততম ছিলাম , এবং সংক্ষিপ্ত তালিকার পক্ষে দ্রুততম
আপডেট: আমি স্ক্রিপ্টটি সংশোধন করেছি যাতে আপনি এটি সরাসরি আপনার নিজের সিস্টেমে চালাতে পারেন। পূর্ববর্তী সংস্করণে বাগ রয়েছে। এছাড়াও, আমি বাছাই করা এবং অরসেটেড উভয় ইনপুট যুক্ত করেছি।
all(l[i] >= l[i+1] for i in xrange(len(l)-1))sorted(l, reverse=True) == lall(l[i] >= l[i+1] for i in xrange(len(l)-1))all(l[i] >= l[i+1] for i in xrange(len(l)-1))সুতরাং বেশিরভাগ ক্ষেত্রেই স্পষ্ট বিজয়ী থাকে।
আপডেট: আরোনস্টার্লিংয়ের উত্তরগুলি (# 6 এবং # 7) আসলে সব ক্ষেত্রেই দ্রুত। # 7 দ্রুততম কারণ এটিতে কীটি দেখার জন্য ইন্ডায়ারেশনের একটি স্তর নেই।
#!/usr/bin/env python
import itertools
import time
def benchmark(f, *args):
t1 = time.time()
for i in xrange(1000000):
f(*args)
t2 = time.time()
return t2-t1
L1 = range(4, 0, -1)
L2 = range(100, 0, -1)
L3 = range(0, 4)
L4 = range(0, 100)
# 1.
def isNonIncreasing(l, key=lambda x,y: x >= y):
return all(key(l[i],l[i+1]) for i in xrange(len(l)-1))
print benchmark(isNonIncreasing, L1) # 2.47253704071
print benchmark(isNonIncreasing, L2) # 34.5398209095
print benchmark(isNonIncreasing, L3) # 2.1916718483
print benchmark(isNonIncreasing, L4) # 2.19576501846
# 2.
def isNonIncreasing(l):
return all(l[i] >= l[i+1] for i in xrange(len(l)-1))
print benchmark(isNonIncreasing, L1) # 1.86919999123
print benchmark(isNonIncreasing, L2) # 21.8603689671
print benchmark(isNonIncreasing, L3) # 1.95684289932
print benchmark(isNonIncreasing, L4) # 1.95272517204
# 3.
def isNonIncreasing(l, key=lambda x,y: x >= y):
return all(key(a,b) for (a,b) in itertools.izip(l[:-1],l[1:]))
print benchmark(isNonIncreasing, L1) # 2.65468883514
print benchmark(isNonIncreasing, L2) # 29.7504849434
print benchmark(isNonIncreasing, L3) # 2.78062295914
print benchmark(isNonIncreasing, L4) # 3.73436689377
# 4.
def isNonIncreasing(l):
return all(a >= b for (a,b) in itertools.izip(l[:-1],l[1:]))
print benchmark(isNonIncreasing, L1) # 2.06947803497
print benchmark(isNonIncreasing, L2) # 15.6351969242
print benchmark(isNonIncreasing, L3) # 2.45671010017
print benchmark(isNonIncreasing, L4) # 3.48461818695
# 5.
def isNonIncreasing(l):
return sorted(l, reverse=True) == l
print benchmark(isNonIncreasing, L1) # 2.01579380035
print benchmark(isNonIncreasing, L2) # 5.44593787193
print benchmark(isNonIncreasing, L3) # 2.01813793182
print benchmark(isNonIncreasing, L4) # 4.97615599632
# 6.
def isNonIncreasing(l, key=lambda x, y: x >= y):
for i, el in enumerate(l[1:]):
if key(el, l[i-1]):
return False
return True
print benchmark(isNonIncreasing, L1) # 1.06842684746
print benchmark(isNonIncreasing, L2) # 1.67291283607
print benchmark(isNonIncreasing, L3) # 1.39491200447
print benchmark(isNonIncreasing, L4) # 1.80557894707
# 7.
def isNonIncreasing(l):
for i, el in enumerate(l[1:]):
if el >= l[i-1]:
return False
return True
print benchmark(isNonIncreasing, L1) # 0.883186101913
print benchmark(isNonIncreasing, L2) # 1.42852401733
print benchmark(isNonIncreasing, L3) # 1.09229516983
print benchmark(isNonIncreasing, L4) # 1.59502696991enumerateভুল। enumerate(l[1:])দ্বারা প্রতিস্থাপন করা উচিতenumerate(l[1:], 1)
enumerate(l[1:])দ্বারা enumerate(l[1:], 1)আপনি প্রতিস্থাপন করতে পারে l[i-1]দ্বারা l[i]।
L5=range(100); random.shuffle(L5)তবে # 5 তুলনামূলকভাবে ধীর হয়। এই ক্ষেত্রে সংশোধিত # 7 দ্রুত সামগ্রিক কোডেপড.org
আমি এটি করতাম (এখানে অনেক উত্তর থেকে চুরি করা হয়েছে [অ্যারোন স্টার্লিং, ওয়াই ইপ টুং, পল ম্যাকগুইয়ারের কাছ থেকে সর্টা ]) এবং বেশিরভাগই আরমিন রোনাচার :
from itertools import tee, izip
def pairwise(iterable):
a, b = tee(iterable)
next(b, None)
return izip(a, b)
def is_sorted(iterable, key=lambda a, b: a <= b):
return all(key(a, b) for a, b in pairwise(iterable))একটি দুর্দান্ত জিনিস: আপনাকে সিরিজের জন্য দ্বিতীয় পুনরাবৃত্তি উপলব্ধি করতে হবে না (তালিকার স্লাইসের সাথে পৃথক)।
key। keyআইটেমগুলি তুলনামূলক মানগুলিতে পরিণত করতে ব্যবহার করা উচিত।
আমি numpy.diff () এর উপর ভিত্তি করে এই ওয়ান-লাইনারটি ব্যবহার করি:
def issorted(x):
"""Check if x is sorted"""
return (numpy.diff(x) >= 0).all() # is diff between all consecutive entries >= 0?আমি এটি অন্য কোনও পদ্ধতির বিপরীতে সত্যিই সময়সই করিনি, তবে আমি ধরে নিলাম যে এটি কোনও খাঁটি পাইথন পদ্ধতির চেয়ে দ্রুততর, বিশেষত বড় এন এর জন্য, যেহেতু numpy.diff (সম্ভবত) লুপটি সরাসরি সিটিতে চলে (এন -1 বিয়োগফলগুলি অনুসরণ করে এন -1 তুলনা)।
যাইহোক, আপনাকে x সতর্কতা অবলম্বন করা উচিত যদি x একটি স্বাক্ষরবিহীন অন্তর্ভুক্ত থাকে, যা নম্পি.ডিফ () এর মধ্যে নীরব পূর্ণসংখ্যার ডুবে যেতে পারে, ফলস্বরূপ একটি মিথ্যা ধনাত্মক হতে পারে। এখানে একটি পরিবর্তিত সংস্করণ রয়েছে:
def issorted(x):
"""Check if x is sorted"""
try:
if x.dtype.kind == 'u':
# x is unsigned int array, risk of int underflow in np.diff
x = numpy.int64(x)
except AttributeError:
pass # no dtype, not an array
return (numpy.diff(x) >= 0).all()এটি শীর্ষের উত্তরের মতো, তবে আমি এটি আরও ভাল পছন্দ করি কারণ এটি সুস্পষ্ট সূচী এড়ায়। আপনার তালিকার নাম রয়েছে তা ধরে নিলে lstআপনি
(item, next_item)নিজের তালিকা থেকে এই টিপলগুলি তৈরি করতে পারেন zip:
all(x <= y for x,y in zip(lst, lst[1:]))পাইথন 3 এ zipইতিমধ্যে একটি জেনারেটর রিটার্ন দেয় পাইথন 2 এ আপনি itertools.izipআরও ভাল মেমরির দক্ষতার জন্য ব্যবহার করতে পারেন ।
ছোট ডেমো:
>>> lst = [1, 2, 3, 4]
>>> zip(lst, lst[1:])
[(1, 2), (2, 3), (3, 4)]
>>> all(x <= y for x,y in zip(lst, lst[1:]))
True
>>>
>>> lst = [1, 2, 3, 2]
>>> zip(lst, lst[1:])
[(1, 2), (2, 3), (3, 2)]
>>> all(x <= y for x,y in zip(lst, lst[1:]))
Falseটিপলটি (3, 2)মূল্যায়ন করা হলে সর্বশেষ ব্যর্থ হয়।
বোনাস: সীমাবদ্ধ (!) জেনারেটর যাচাই করা যাচ্ছে না:
>>> def gen1():
... yield 1
... yield 2
... yield 3
... yield 4
...
>>> def gen2():
... yield 1
... yield 2
... yield 4
... yield 3
...
>>> g1_1 = gen1()
>>> g1_2 = gen1()
>>> next(g1_2)
1
>>> all(x <= y for x,y in zip(g1_1, g1_2))
True
>>>
>>> g2_1 = gen2()
>>> g2_2 = gen2()
>>> next(g2_2)
1
>>> all(x <= y for x,y in zip(g2_1, g2_2))
Falseআপনি itertools.izipযদি পাইথন 2 ব্যবহার করে থাকেন তবে এখানে অবশ্যই তা নিশ্চিত করে নিন , অন্যথায় আপনি জেনারেটর থেকে তালিকা তৈরি না করার উদ্দেশ্যে পরাস্ত করবেন।
isliceআপনি কাটা জন্য অনুকূলিত করতে ব্যবহার করতে পারেন । ইটারটুলস মডিউলটিতেও। all(x <= y for x, y in izip(lst, islice(lst, 1)))।
নীলাশুন বেশ ঠিক আছে। আপনি শুধু ব্যবহার করতে পারেন lst.sort()। পাইথনের বাছাইয়ের প্রয়োগ (টিমসোর্ট) পরীক্ষাটি ইতিমধ্যে বাছাই করা হয়েছে কিনা তা পরীক্ষা করে দেখুন। যদি তাই সাজান () লিনিয়ার সময়ে সম্পন্ন হবে। একটি তালিকা সাজানো হয়েছে তা নিশ্চিত করার জন্য পাইথোনিক জাতীয় মত শব্দগুলি;)
যদিও আমি মনে করি না যে sortedবিল্ট-ইন তার সিএমপি ফাংশনটি কল করে তার কোনও গ্যারান্টি নেইi+1, i নেই, তবে এটি সিপাইথনের পক্ষে তা করার মতো বলে মনে হচ্ছে না।
সুতরাং আপনি যেমন কিছু করতে পারে:
def my_cmp(x, y):
cmpval = cmp(x, y)
if cmpval < 0:
raise ValueError
return cmpval
def is_sorted(lst):
try:
sorted(lst, cmp=my_cmp)
return True
except ValueError:
return False
print is_sorted([1,2,3,5,6,7])
print is_sorted([1,2,5,3,6,7])অথবা এইভাবে (বিবৃতি ছাড়াই -> ইএএফপি ভুল হয়েছে ?;-)):
def my_cmp(x, y):
assert(x >= y)
return -1
def is_sorted(lst):
try:
sorted(lst, cmp=my_cmp)
return True
except AssertionError:
return Falseমোটেই পাইথোনিক নয়, তবে আমাদের কমপক্ষে একটি reduce()উত্তর দরকার, তাই না?
def is_sorted(iterable):
prev_or_inf = lambda prev, i: i if prev <= i else float('inf')
return reduce(prev_or_inf, iterable, float('-inf')) < float('inf')সঞ্চালক ভেরিয়েবল কেবল সর্বশেষ-চেক করা মানটিকে সঞ্চয় করে এবং যদি কোনও মান পূর্ববর্তী মানের থেকে ছোট হয় তবে সঞ্চালক অনন্তকে সেট করা থাকে (এবং এটি এখনও শেষে থাকবে অনন্ত, কারণ 'পূর্ববর্তী মান' সর্বদা এর চেয়ে বড় হবে বর্তমান এক)।
@Aaronsterling দ্বারা উল্লিখিত হিসাবে নীচের সমাধানটি হ'ল সংক্ষিপ্ততম এবং খুব দ্রুততম অ্যারে বাছাই করা হয় এবং খুব কম নয় বলে মনে হয়: Def is_sort (lst): রিটার্ন (সাজানো (lst) == lst)
বেশিরভাগ সময় অ্যারেটি বাছাই না করা থাকলে, এমন কোনও সমাধান ব্যবহার করা বাঞ্ছনীয় যা পুরো অ্যারেটি স্ক্যান করে না এবং একটি অরক্ষিত উপসর্গটি সনাক্ত হওয়ার সাথে সাথেই মিথ্যা প্রদান করে। নিম্নলিখিতটি আমি খুঁজে পেতে পেলাম দ্রুততম সমাধানটি, এটি বিশেষভাবে মার্জিত নয়:
def is_sorted(lst):
it = iter(lst)
try:
prev = it.next()
except StopIteration:
return True
for x in it:
if prev > x:
return False
prev = x
return Trueনাথান ফারিংটনের বেঞ্চমার্ক ব্যবহার করে, বড় বাছাই করা তালিকায় চালানো বাদে সব ক্ষেত্রেই বাছাই করা (lst) ব্যবহারের চেয়ে এটি ভাল রানটাইম অর্জন করে।
আমার কম্পিউটারে এখানে বেনমার্কের ফলাফল রয়েছে।
সাজানো (lst) == lst সমাধান
দ্বিতীয় সমাধান:
আপনি যদি নম্পি অ্যারেগুলির দ্রুততম উপায় চান তবে নাম্বা ব্যবহার করুন , যদি আপনি কনডা ব্যবহার করেন তবে ইতিমধ্যে ইনস্টল করা উচিত
কোডটি দ্রুত হবে কারণ এটি নাম্বার দ্বারা সংকলিত হবে
import numba
@numba.jit
def issorted(vec, ascending=True):
if len(vec) < 2:
return True
if ascending:
for i in range(1, len(vec)):
if vec[i-1] > vec[i]:
return False
return True
else:
for i in range(1, len(vec)):
if vec[i-1] < vec[i]:
return False
return Trueএবং তারপর:
>>> issorted(array([4,9,100]))
>>> Trueকেবল অন্য উপায় যুক্ত করতে (এটির জন্য অতিরিক্ত মডিউল প্রয়োজন হলেও) iteration_utilities.all_monotone:
>>> from iteration_utilities import all_monotone
>>> listtimestamps = [1, 2, 3, 5, 6, 7]
>>> all_monotone(listtimestamps)
True
>>> all_monotone([1,2,1])
Falseডিইএসসি অর্ডার পরীক্ষা করার জন্য:
>>> all_monotone(listtimestamps, decreasing=True)
False
>>> all_monotone([3,2,1], decreasing=True)
Truestrictআপনি যদি কঠোরভাবে পরীক্ষা করতে চান তবে (পর পরের উপাদানগুলি সমান না হওয়া উচিত) একঘেয়েমিক ক্রমগুলির জন্য একটি প্যারামিটারও রয়েছে।
এটি আপনার ক্ষেত্রে কোনও সমস্যা নয় তবে যদি আপনার সিকোয়েন্সগুলিতে nanমান থাকে তবে কয়েকটি পদ্ধতি ব্যর্থ হবে, উদাহরণস্বরূপ সাজানো সহ:
def is_sorted_using_sorted(iterable):
return sorted(iterable) == iterable
>>> is_sorted_using_sorted([3, float('nan'), 1]) # definetly False, right?
True
>>> all_monotone([3, float('nan'), 1])
Falseদ্রষ্টব্য যে iteration_utilities.all_monotoneএখানে উল্লিখিত অন্যান্য সমাধানগুলির তুলনায় বিশেষত অরসেটেড ইনপুটগুলির জন্য ( বেঞ্চমার্ক দেখুন ) তুলনায় দ্রুত সম্পাদন করে ।
from itertools import tee
def is_sorted(l):
l1, l2 = tee(l)
next(l2, None)
return all(a <= b for a, b in zip(l1, l2))all(a <= b for a, b in zip(l, l[1:]))
lজেনারেটর হয় এবং স্লাইসিং সমর্থন করে না তখন কাজ করে।
পাইথন 3.6.8
from more_itertools import pairwise
class AssertionHelper:
@classmethod
def is_ascending(cls, data: iter) -> bool:
for a, b in pairwise(data):
if a > b:
return False
return True
@classmethod
def is_descending(cls, data: iter) -> bool:
for a, b in pairwise(data):
if a < b:
return False
return True
@classmethod
def is_sorted(cls, data: iter) -> bool:
return cls.is_ascending(data) or cls.is_descending(data)>>> AssertionHelper.is_descending((1, 2, 3, 4))
False
>>> AssertionHelper.is_ascending((1, 2, 3, 4))
True
>>> AssertionHelper.is_sorted((1, 2, 3, 4))
True
from functools import reduce
# myiterable can be of any iterable type (including list)
isSorted = reduce(lambda r, e: (r[0] and (r[1] or r[2] <= e), False, e), myiterable, (True, True, None))[0]উদ্ভূত হ্রাস মান (একটি 3-অংশ tuple হয় sortedSoFarFlag , firstTimeFlag , lastElementValue )। এটি প্রাথমিকভাবে সঙ্গে (আরম্ভ করা হয় True, True, None), যা একটি খালি তালিকার জন্য ফলাফলের হিসাবে ব্যবহার করা হয় (গণ্য যেমন সাজানো কারণ কোন আউট-অফ-অর্ডার উপাদান)। এটি প্রতিটি উপাদানকে প্রক্রিয়া করার সাথে সাথে এটি টিপলের জন্য নতুন মানগুলি গণনা করে (পরবর্তী উপাদানটির সাথে পূর্ববর্তী টিপল মানগুলি ব্যবহার করে):
[0] (sortedSoFarFlag) evaluates true if: prev_0 is true and (prev_1 is true or prev_2 <= elementValue)
[1] (firstTimeFlag): False
[2] (lastElementValue): elementValueহ্রাসের চূড়ান্ত ফলাফল হ'ল:
[0]: True/False depending on whether the entire list was in sorted order
[1]: True/False depending on whether the list was empty
[2]: the last element valueপ্রথম মানটি হ'ল আমরা আগ্রহী তাই আমরা [0]হ্রাস ফলাফল থেকে এটি ধরতে ব্যবহার করি ।
অ্যাসাইনমেন্ট এক্সপ্রেশন (পাইথন ৩.৮ এ যুক্ত) ব্যবহার করে একটি সমাধান:
def is_sorted(seq):
seq_iter = iter(seq)
cur = next(seq_iter, None)
return all((prev := cur) <= (cur := nxt) for nxt in seq_iter)
z = list(range(10))
print(z)
print(is_sorted(z))
import random
random.shuffle(z)
print(z)
print(is_sorted(z))
z = []
print(z)
print(is_sorted(z))দেয়:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
True
[1, 7, 5, 9, 4, 0, 8, 3, 2, 6]
False
[]
Trueযদি এটি বাছাই করা হয় তবে অন্যটি মিথ্যা মুদ্রণ করবে True
def is_Sorted(lst):
if len(lst) == 1:
return True
return lst[0] <= lst[1] and is_Sorted(lst[1:])
any_list = [1,2,3,4]
print is_Sorted(any_list)RuntimeError: maximum recursion depth exceededদীর্ঘ তালিকার জন্য উত্থাপন করবে । ব্যবহার করে দেখুন any_list = range(1000)।
এটা কেমন ? সরল ও সোজা।
def is_list_sorted(al):
llength =len(al)
for i in range (llength):
if (al[i-1] > al[i]):
print(al[i])
print(al[i+1])
print('Not sorted')
return -1
else :
print('sorted')
return trueপূর্ণসংখ্যা বা স্ট্রিংয়ের জন্য অবশ্যই পাইথন 3 এবং এর উপরে কাজ করে:
def tail(t):
return t[:]
letters = ['a', 'b', 'c', 'd', 'e']
rest = tail(letters)
rest.sort()
if letters == rest:
print ('Given list is SORTED.')
else:
print ('List NOT Sorted.')================================================== ===================
প্রদত্ত তালিকাটি বাছাই করা হয়েছে কিনা তা সন্ধান করার আরেকটি উপায়
trees1 = list ([1, 4, 5, 3, 2])
trees2 = list (trees1)
trees2.sort()
if trees1 == trees2:
print ('trees1 is SORTED')
else:
print ('Not sorted')
keyব্যবহারের জন্য আপনি কোনও ফাংশন পাস করতে পারেন।key=lambda x, y: x < yএকটি ভাল ডিফল্ট করে তোলে।