sort() बनाम sorted() — Python में sorting पूरी

एक ही फर्क, पर बड़ा

दोनों वही sorting करते हैं। फर्क सिर्फ इतना है कि नतीजा कहाँ जाता है — और यही फर्क Python की सबसे आम गलतियों में से एक बनाता है।

nums = [3, 1, 2]

nums.sort()              # list को in-place बदलता है, None लौटाता है
print(nums)              # [1, 2, 3]

nums = [3, 1, 2]
new = sorted(nums)       # नई list लौटाता है, original untouched
print(new, nums)         # [1, 2, 3] [3, 1, 2]

nums = [3, 1, 2]
nums = nums.sort()       # ❌ nums अब None है!
print(nums)              # None
print(len(nums))         # TypeError: object of type 'NoneType' has no len()

# ✅ या in-place sort करो, assign मत करो
nums.sort()
# ✅ या नई list लो
nums = sorted(nums)

नियम याद रख लो: sort(), append(), reverse() और extend() — ये सब in-place methods हैं और None लौटाते हैं। इनका नतीजा assign करने पर आपका data None बन जाता है।

कौन सा कब

• sorted() चुनो जब original चाहिए, या जब आप list के अलावा किसी और iterable (tuple, dict, generator, string) को sort कर रहे हो।
• sort() चुनो जब list बहुत बड़ी हो और दूसरी copy की memory न हो — in-place sort extra list नहीं बनाता।
• नए code में ज़्यादातर sorted() — कम गलती की गुंजाइश, और original बचा रहता है।

sorted((3, 1, 2))          # ✅ tuple से list मिलती है
sorted("python")           # ✅ ['h', 'n', 'o', 'p', 't', 'y']
sorted({3, 1, 2})          # ✅ set से
sorted(d.items())          # ✅ dict से

(3, 1, 2).sort()           # ❌ AttributeError — tuple का sort() नहीं होता
"abc".sort()               # ❌ AttributeError — string का भी नहीं

key function — असली ताकत

key हर item से एक value निकालता है, और sorting उसी value पर होती है। यही वो feature है जो ज़्यादातर sorting सवाल हल करता है।

words = ["banana", "fig", "apple"]

sorted(words)                          # ['apple', 'banana', 'fig']  — alphabetical
sorted(words, key=len)                 # ['fig', 'apple', 'banana']  — लंबाई से
sorted(words, key=str.lower)           # case भुलाकर

students = [
    {"name": "Asha",  "marks": 91},
    {"name": "Ravi",  "marks": 42},
    {"name": "Meera", "marks": 77},
]
sorted(students, key=lambda s: s["marks"])              # marks बढ़ते क्रम में
sorted(students, key=lambda s: s["marks"], reverse=True) # घटते क्रम में

# कई criteria — पहले marks घटते, फिर नाम बढ़ते
sorted(students, key=lambda s: (-s["marks"], s["name"]))

आखिरी line एक तरकीब दिखाती है: tuple return करके multi-level sorting। Python tuples को element-by-element compare करता है, इसलिए (-marks, name) का मतलब है पहले marks घटते क्रम में, बराबर होने पर नाम बढ़ते क्रम में।

# operator module — lambda से तेज़ और साफ
from operator import itemgetter, attrgetter

sorted(students, key=itemgetter("marks"))
sorted(students, key=itemgetter("marks", "name"))
sorted(students, key=attrgetter("marks"))    # objects के लिए

reverse का मतलब

reverse=True उल्टा sort करता है — ये sort करके उलटने जैसा नहीं है, और फर्क तब दिखता है जब items बराबर हों:

students = [("Asha", 91), ("Zara", 91), ("Ravi", 42)]

# marks पर sort, बराबर होने पर नाम से
sorted(students, key=lambda s: s[1])
# [('Ravi', 42), ('Asha', 91), ('Zara', 91)]   — स्थिर sort

sorted(students, key=lambda s: s[1], reverse=True)
# [('Asha', 91), ('Zara', 91), ('Ravi', 42)]   — बराबर वालों का क्रम बना रहता है

sorted(students, key=lambda s: s[1])[::-1]
# [('Zara', 91), ('Asha', 91), ('Ravi', 42)]   — पूरा उलट गया, अलग नतीजा!

Python का sort stable है — बराबर items का आपसी क्रम नहीं बदलता। reverse=True इस स्थिरता को बनाए रखता है; [::-1] उसे तोड़ देता है। इसलिए घटते क्रम के लिए हमेशा reverse=True लिखो।

dict और tuple sorting

marks = {"Asha": 91, "Ravi": 42, "Meera": 77}

# value के हिसाब से, घटते क्रम में
sorted(marks.items(), key=lambda kv: kv[1], reverse=True)
# [('Asha', 91), ('Meera', 77), ('Ravi', 42)]

# dict वापस चाहिए तो
dict(sorted(marks.items(), key=lambda kv: kv[1], reverse=True))

# सिर्फ keys, value के क्रम में
sorted(marks, key=marks.get, reverse=True)     # ['Asha', 'Meera', 'Ravi']

# top 3 — heapq यहाँ बेहतर
import heapq
heapq.nlargest(3, marks.items(), key=lambda kv: kv[1])
heapq.nsmallest(2, marks, key=marks.get)

बड़े dict पर top-N चाहिए तो heapq.nlargest पूरा sort करने से तेज़ है — O(n log k) बनाम O(n log n)।

Mixed types — वो TypeError

Sorting की सबसे आम runtime गलती: list में अलग-अलग types के items।

mixed = [3, "a", 1]
sorted(mixed)
# 💥 TypeError: '<' not supported between instances of 'str' and 'int'

# None मिला हुआ — यही class of error
values = [3, None, 1]
sorted(values)
# 💥 TypeError: '<' not supported between instances of 'NoneType' and 'int'

# पहले गलत items ढूँढो
bad = [x for x in values if not isinstance(x, (int, float))]
print(bad)                              # [None]

# या None को अंत में भेजो
sorted(values, key=lambda x: (x is None, x))
# [1, 3, None]

# या सबको string बनाओ — पर सावधान, '10' < '9' होता है
sorted([10, 9, 1], key=str)             # [1, 10, 9]  — अक्सर नहीं चाहिए

आम गलतियाँ

• nums = nums.sort() लिखना। sort() None लौटाता है, तो आपका data खो जाता है।
• Tuple या string पर .sort() ढूँढना। सिर्फ list का sort() होता है; बाकी सब पर sorted()।
• घटते क्रम के लिए [::-1] use करना। ये stable sort को तोड़ देता है। reverse=True लिखो।
• dict को सीधे sort करना। sorted(d) सिर्फ keys देता है — items चाहिए तो d.items()।
• Mixed types वाली list sort करना। कोई warning नहीं, सीधा TypeError। पहले types check करो।

nums = [3, 1, 2]
result = nums.sort()      # result = None, nums बदल गया
result = sorted(nums)     # ✅ result = [1, 2, 3], nums वैसा ही

marks = {"a": 2, "b": 1}
sorted(marks)             # ['a', 'b']  — सिर्फ keys!
sorted(marks.items())     # [('a', 2), ('b', 1)]  — pairs

🛠️ Practice करो (free, browser में)

पढ़ना काफी नहीं — यही bug खुद fix करके देखो। नीचे के problems browser में ही चलते हैं, कोई install नहीं, कोई login नहीं।

• sorted() with a key function — key का असली use।
• sorting doesn't return a new list — sort() बनाम sorted() का trap।
• Sorting a list with mixed types — वही TypeError।

अक्सर पूछे जाने वाले सवाल

आगे पढ़ो

• List methods Hindi में
• List comprehension Hindi में
• map, filter, reduce Hindi में
• Python dictionary Hindi में
• Hindi hub — सारे Hindi guides