മൂല്യങ്ങൾ അനുസരിച്ച് ഒരു പൈത്തൺ നിഘണ്ടു എങ്ങനെ അടുക്കാം

പൈത്തണിൽ നിഘണ്ടു മൂല്യങ്ങൾ അടുക്കുന്നു: ഒരു ദ്രുത ഗൈഡ്

പൈത്തണിലെ കീകൾ ഉപയോഗിച്ച് ഒരു നിഘണ്ടു അടുക്കുന്നത് നേരായ കാര്യമാണ്, എന്നാൽ പകരം മൂല്യങ്ങൾ അനുസരിച്ച് അടുക്കേണ്ടതെങ്കിലോ? ഡാറ്റാബേസുകളിൽ നിന്നോ മറ്റ് ഡാറ്റാ ഉറവിടങ്ങളിൽ നിന്നോ ഉള്ള ഡാറ്റ കൈവശം വയ്ക്കുന്ന നിഘണ്ടുക്കളുമായി ഇടപെടുമ്പോൾ ഇത് ഒരു സാധാരണ സാഹചര്യമാണ്, ഇവിടെ കീകൾ അദ്വിതീയ സ്ട്രിംഗുകളും മൂല്യങ്ങൾ സംഖ്യാ ഫീൽഡുകളുമാണ്.

ഈ പ്രശ്നം പരിഹരിക്കാൻ നിഘണ്ടുക്കളുടെ ലിസ്റ്റുകൾ ഉപയോഗിക്കുമ്പോൾ, ഒരൊറ്റ നിഘണ്ടുവിൽ പ്രവർത്തിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ലളിതമായ പരിഹാരങ്ങളുണ്ട്. ഈ ഗൈഡിൽ, ഒരു പൈത്തൺ നിഘണ്ടു അതിൻ്റെ മൂല്യങ്ങൾ അനുസരിച്ച്, ആരോഹണക്രമത്തിലോ അവരോഹണക്രമത്തിലോ, കാര്യക്ഷമവും എളുപ്പത്തിൽ മനസ്സിലാക്കാവുന്നതുമായ രീതികൾ ഉപയോഗിച്ച് എങ്ങനെ അടുക്കാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും.

കമാൻഡ്	വിവരണം
sorted()	ഒരു ഐറ്റബിളിലെ ഇനങ്ങളിൽ നിന്ന് ഒരു പുതിയ അടുക്കിയ ലിസ്റ്റ് തിരികെ നൽകുന്ന ഒരു ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷൻ.
dict()	പൈത്തണിൽ ഒരു നിഘണ്ടു നിർമ്മിക്കുന്നു.
key=lambda item: item[1]	സോർട്ടിംഗ് നിഘണ്ടു മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതായിരിക്കണം എന്ന് വ്യക്തമാക്കാൻ ലാംഡ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു.
reverse=True	ഇനങ്ങളെ അവരോഹണ ക്രമത്തിൽ അടുക്കുന്നതിനുള്ള സോർട്ടഡ്() ഫംഗ്‌ഷനിലെ പാരാമീറ്റർ.
@app.route()	ഒരു ഫംഗ്‌ഷൻ URL-ലേക്ക് ബന്ധിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന ഫ്ലാസ്ക് ഡെക്കറേറ്റർ.
jsonify()	പൈത്തൺ ഒബ്‌ജക്‌റ്റുകളെ JSON ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള ഫ്ലാസ്ക് പ്രവർത്തനം.

മൂല്യങ്ങൾ അനുസരിച്ച് ഒരു നിഘണ്ടു അടുക്കുന്നതിനുള്ള സ്ക്രിപ്റ്റുകൾ മനസ്സിലാക്കുന്നു

പൈത്തണിൻ്റെ ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് ഒരു നിഘണ്ടു അതിൻ്റെ മൂല്യങ്ങൾ ഉപയോഗിച്ച് എങ്ങനെ അടുക്കാമെന്ന് ആദ്യ സ്‌ക്രിപ്റ്റ് കാണിക്കുന്നു. ദി നിഘണ്ടുവിലെ ഇനങ്ങൾ അടുക്കുന്നതിന് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. സ്വതവേ, കീകളെ അടിസ്ഥാനമാക്കി ഇനങ്ങൾ ആരോഹണ ക്രമത്തിൽ അടുക്കുന്നു. എന്നിരുന്നാലും, ഉപയോഗിച്ച് ഒരു ഇഷ്‌ടാനുസൃത കീ ഫംഗ്‌ഷൻ നൽകിക്കൊണ്ട് , നിഘണ്ടുവിലെ മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി അടുക്കാൻ ഞങ്ങൾ പൈത്തണിനോട് നിർദ്ദേശിക്കുന്നു. ദി lambda ഫംഗ്ഷൻ ഓരോ നിഘണ്ടു ഇനത്തിൽ നിന്നും മൂല്യം വേർതിരിച്ചെടുക്കുന്നു, ഇത് അനുവദിക്കുന്നു അതിനനുസരിച്ച് നിഘണ്ടു ഓർഡർ ചെയ്യുന്നതിനുള്ള പ്രവർത്തനം. ഫലം വീണ്ടും ഒരു നിഘണ്ടുവിൽ സംഭരിക്കുന്നതിന്, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. കൂടാതെ, അവരോഹണ ക്രമത്തിൽ നിഘണ്ടു അടുക്കുന്നതിന്, the പരാമീറ്റർ കൈമാറുന്നു sorted() പ്രവർത്തനം.

രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് സോർട്ടിംഗ് ലോജിക്കിൽ നിർമ്മിക്കുകയും അതിനെ ഒരു ഫ്ലാസ്ക് വെബ് ആപ്ലിക്കേഷനുമായി സംയോജിപ്പിക്കുകയും ചെയ്യുന്നു. വെബ് ആപ്ലിക്കേഷനുകൾ എളുപ്പത്തിൽ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന പൈത്തണിനായുള്ള ഭാരം കുറഞ്ഞ ഒരു വെബ് ചട്ടക്കൂടാണ് ഫ്ലാസ്ക്. ഈ സ്ക്രിപ്റ്റിൽ, ദി അലങ്കാരപ്പണിക്കാരൻ ബന്ധിക്കുന്നു '/sort-dict' URL റൂട്ടിലേക്കുള്ള പ്രവർത്തനം. ഈ റൂട്ട് ആക്സസ് ചെയ്യുമ്പോൾ, ഫംഗ്ഷൻ ആദ്യ സ്ക്രിപ്റ്റിലെ അതേ ലോജിക് ഉപയോഗിച്ച് ആരോഹണ, അവരോഹണ ക്രമങ്ങളിൽ നിഘണ്ടു അടുക്കുന്നു. ദി ക്രമീകരിച്ച നിഘണ്ടുക്കളെ JSON ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യാൻ Flask-ൽ നിന്നുള്ള ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു, അത് പ്രതികരണമായി നൽകുന്നു. ഈ വെബ് ആപ്ലിക്കേഷൻ ഉപയോക്താക്കളെ ഒരു വെബ് ബ്രൗസറിലൂടെ ക്രമീകരിച്ച നിഘണ്ടുക്കൾ ആക്സസ് ചെയ്യാൻ അനുവദിക്കുന്നു, ഒരു വെബ് സന്ദർഭത്തിൽ നിഘണ്ടു മൂല്യങ്ങൾ അടുക്കുന്നതിനുള്ള പ്രായോഗിക ഉപയോഗ കേസ് പ്രകടമാക്കുന്നു.

# Sample dictionary
data = {'apple': 3, 'banana': 1, 'cherry': 2}

# Sort dictionary by values in ascending order
sorted_data_asc = dict(sorted(data.items(), key=lambda item: item[1]))
print("Ascending order:", sorted_data_asc)

# Sort dictionary by values in descending order
sorted_data_desc = dict(sorted(data.items(), key=lambda item: item[1], reverse=True))
print("Descending order:", sorted_data_desc)

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/sort-dict')
def sort_dict():
    data = {'apple': 3, 'banana': 1, 'cherry': 2}
    sorted_data_asc = dict(sorted(data.items(), key=lambda item: item[1]))
    sorted_data_desc = dict(sorted(data.items(), key=lambda item: item[1], reverse=True))
    return jsonify(ascending=sorted_data_asc, descending=sorted_data_desc)

if __name__ == '__main__':
    app.run(debug=True)

മൂല്യങ്ങൾ അനുസരിച്ച് നിഘണ്ടുക്കൾ അടുക്കുന്നതിനുള്ള വിപുലമായ സാങ്കേതിക വിദ്യകൾ

മൂല്യങ്ങൾ അനുസരിച്ച് നിഘണ്ടുക്കൾ അടുക്കുന്നതും ഇത് ഉപയോഗിച്ച് നേടാം മുതൽ പ്രവർത്തനം ഒരു ലാംഡ ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നതിനേക്കാൾ കൂടുതൽ വായിക്കാൻ കഴിയുന്നതും കൂടുതൽ കാര്യക്ഷമവുമായ മോഡ്യൂൾ. ദി അനുബന്ധ മൂല്യങ്ങൾ വീണ്ടെടുക്കുന്നതിന് ഒന്നോ അതിലധികമോ കീകൾ വ്യക്തമാക്കാൻ ഫംഗ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു നിഘണ്ടു അടുക്കുന്ന സന്ദർഭത്തിൽ, നിഘണ്ടു ഇനങ്ങളുടെ മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കിയാണ് സോർട്ടിംഗ് ചെയ്യേണ്ടതെന്ന് വ്യക്തമാക്കാൻ ഇത് ഉപയോഗിക്കാം. വലിയ നിഘണ്ടുക്കൾ കൈകാര്യം ചെയ്യുമ്പോൾ അല്ലെങ്കിൽ പ്രകടനം ആശങ്കാകുലമാകുമ്പോൾ ഈ രീതി പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും.

കൂടാതെ, ഡാറ്റാ ഘടനകളിൽ അടുക്കുന്നതിൻ്റെ പ്രത്യാഘാതങ്ങൾ പരിഗണിക്കേണ്ടത് പ്രധാനമാണ്. മൂല്യങ്ങൾ അനുസരിച്ച് ഒരു നിഘണ്ടു അടുക്കുകയും ഫലം ഒരു പുതിയ നിഘണ്ടുവിൽ സംഭരിക്കുകയും ചെയ്യുമ്പോൾ പല സാഹചര്യങ്ങളിലും ഇത് നന്നായി പ്രവർത്തിക്കുന്നു, അത് ഇനങ്ങളുടെ യഥാർത്ഥ ക്രമം സംരക്ഷിക്കുന്നില്ല. റാങ്ക് ചെയ്‌ത ലിസ്‌റ്റുകൾ സൃഷ്‌ടിക്കുന്നത് അല്ലെങ്കിൽ ഇൻസേർഷൻ ഓർഡർ സംരക്ഷിക്കുന്നത് പോലുള്ള ക്രമം നിലനിർത്തുന്നത് നിർണായകമായ ഉപയോഗ സന്ദർഭങ്ങളിൽ നിന്ന് മൊഡ്യൂൾ കൂടുതൽ ഉചിതമായേക്കാം. ദി ഇനങ്ങൾ തിരുകുമ്പോൾ അവയുടെ ക്രമം നിലനിർത്തുന്നു, തരംതിരിച്ചതിന് ശേഷവും മൂലകങ്ങളുടെ ക്രമം സംരക്ഷിക്കേണ്ട സാഹചര്യങ്ങൾക്ക് ഇത് അനുയോജ്യമാക്കുന്നു.