දත්ත සමුදායක ක්ෂේත්‍ර දෙකකින් කියවන ලද අගයන් පිළිබඳ ශබ්ද කෝෂයක් මා සතුව ඇත: නූල් ක්ෂේත්‍රයක් සහ සංඛ්‍යා ක්ෂේත්‍රයක්. සංගීත ක්ෂේත්‍රය අද්විතීය බැවින් ශබ්ද කෝෂයේ යතුර එයයි.

මට යතුරු මත වර්ග කළ හැකිය, නමුත් අගයන් මත පදනම්ව මා වර්ග කරන්නේ කෙසේද?

සටහන: මම මෙහි ස්ටක් පිටාර ගැලීමේ ප්‍රශ්නය කියවා ඇත්තෙමි . ශබ්ද කෝෂයේ අගය අනුව ශබ්ද කෝෂ ලැයිස්තුවක් වර්ග කරන්නේ කෙසේද? බොහෝ විට ශබ්ද කෝෂ ලැයිස්තුවක් ඇති කිරීම සඳහා මගේ කේතය වෙනස් කළ හැකිය, නමුත් මට ඇත්ත වශයෙන්ම ශබ්ද කෝෂ ලැයිස්තුවක් අවශ්‍ය නොවන බැවින් මට දැන ගැනීමට අවශ්‍ය වූයේ නඟින හෝ බැසීමේ අනුපිළිවෙලට වර්ග කිරීම සඳහා සරල විසඳුමක් තිබේද යන්නයි.

පයිතන් 3.6+

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
{k: v for k, v in sorted(x.items(), key=lambda item: item[1])}
{0: 0, 2: 1, 1: 2, 4: 3, 3: 4}

පැරණි පයිතන්

ශබ්ද කෝෂයක් වර්ග කිරීමට නොහැකි අතර, වර්ග කර ඇති ශබ්දකෝෂයක නිරූපණයක් ලබා ගැනීම සඳහා පමණි. ශබ්දකෝෂ සහජයෙන්ම පිළිවෙලට නැත, නමුත් ලැයිස්තු සහ ටුපල් වැනි වෙනත් වර්ග එසේ නොවේ. එබැවින් වර්ග කළ අගයන් නිරූපණය කිරීම සඳහා ඔබට ඇණවුම් කළ දත්ත වර්ගයක් අවශ්‍ය වේ, එය ලැයිස්තුවක් වනු ඇත - බොහෝ විට ටුපල් ලැයිස්තුවකි.

උදාහරණයක් වශයෙන්,

import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(1))

sorted_xසෑම ටුපල් එකකම දෙවන මූලද්‍රව්‍යය අනුව වර්ග කළ ටුපල් ලැයිස්තුවක් වනු ඇත. dict(sorted_x) == x.

අගයන් වෙනුවට යතුරු වර්ග කිරීමට කැමති අයට:

import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(0))

පයිතන් 3 හි ඇසුරුම් කිරීමට අවසර නැති බැවින් [1] අපට භාවිතා කළ හැකිය

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=lambda kv: kv[1])

ප්‍රතිදානය ආ ict ාවක් ලෙස ඔබට අවශ්‍ය නම්, ඔබට මෙය භාවිතා කළ හැකිය collections.OrderedDict:

import collections

sorted_dict = collections.OrderedDict(sorted_x)

තරම් සරල: sorted(dict1, key=dict1.get)

හොඳයි, ඇත්ත වශයෙන්ම "ශබ්ද කෝෂ අගයන් අනුව වර්ග කිරීම" කළ හැකිය. මෑතකදී මට එය කිරීමට සිදු වූයේ කේත ගොල්ෆ් ක්‍රීඩාවකිනි (ගොඩගැසීමේ ප්‍රශ්න කේත ගොල්ෆ්: වචන සංඛ්‍යාත සටහන ). සංක්ෂිප්තව, ගැටළුව මේ ආකාරයේ විය: පෙළක් ලබා දී, එක් එක් වචනය කොපමණ වාර ගණනක් හමු වී ඇත්දැයි ගණනය කර ඉහළ වචන ලැයිස්තුවක් ප්‍රදර්ශනය කරන්න.

ඔබ වචන යතුරු ලෙස ශබ්ද කෝෂයක් සහ එක් එක් වචනයේ සිදුවීම් ගණන අගය ලෙස ගොඩනඟන්නේ නම්, මෙහි සරල කර ඇත්තේ:

from collections import defaultdict
d = defaultdict(int)
for w in text.split():
    d[w] += 1

එවිට ඔබට භාවිතා වන වාර ගණන අනුව ඇණවුම් කරන ලද වචන ලැයිස්තුවක් ලබා ගත හැකිය sorted(d, key=d.get)- වර්ග කිරීමේ යතුරක් ලෙස වචන සිදුවීම් ගණන භාවිතා කරමින් ශබ්ද කෝෂ යතුරු හරහා නැවත වර්ග කිරීම.

for w in sorted(d, key=d.get, reverse=True):
    print(w, d[w])

මම මෙම සවිස්තරාත්මක පැහැදිලි කිරීම ලියන්නේ මිනිසුන් බොහෝ විට අදහස් කරන්නේ "මට පහසුවෙන් ශබ්ද කෝෂයක් යතුරකින් වර්ග කළ හැකි නමුත් අගය අනුව වර්ග කරන්නේ කෙසේද" යන්නයි. තවද මම සිතන්නේ මුල් පෝස්ට් එවැනි ගැටලුවක් විසඳීමට උත්සාහ කළ බවයි. විසඳුම වන්නේ ඉහත පෙන්වා ඇති පරිදි අගයන් මත පදනම්ව යතුරු ලැයිස්තුවක් කිරීමයි.

ඔබට භාවිතා කළ හැකිය:

sorted(d.items(), key=lambda x: x[1])

මෙය ශබ්ද කෝෂය තුළ ඇති සෑම ප්‍රවේශයකම අගයන් අනුව කුඩාම සිට විශාලතම දක්වා ශබ්දකෝෂය වර්ග කරයි.

එය අවරෝහණ පිළිවෙලට වර්ග කිරීම සඳහා එකතු කරන්න reverse=True:

sorted(d.items(), key=lambda x: x[1], reverse=True)

ආදානය:

d = {'one':1,'three':3,'five':5,'two':2,'four':4}
a = sorted(d.items(), key=lambda x: x[1])    
print(a)

ප්‍රතිදානය:

[('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]

අණපනත් වර්ග කළ නොහැක, නමුත් ඔබට ඒවායින් වර්ග කළ ලැයිස්තුවක් සෑදිය හැකිය.

විධාන අගයන් වර්ග කළ ලැයිස්තුවක්:

sorted(d.values())

(යතුර, අගය) යුගල ලැයිස්තුවක්, අගය අනුව වර්ග කර ඇත:

from operator import itemgetter
sorted(d.items(), key=itemgetter(1))

මෑතදී පයිතන් 2.7 හි, අපට නව ඕඩර්ඩෙක්ට් වර්ගය ඇත, එමඟින් අයිතම එකතු කළ අනුපිළිවෙල සිහිපත් වේ.

>>> d = {"third": 3, "first": 1, "fourth": 4, "second": 2}

>>> for k, v in d.items():
...     print "%s: %s" % (k, v)
...
second: 2
fourth: 4
third: 3
first: 1

>>> d
{'second': 2, 'fourth': 4, 'third': 3, 'first': 1}

මුල් පිටුවෙන් නව ඇණවුම් කළ ශබ්ද කෝෂයක් සෑදීම සඳහා, අගයන් අනුව වර්ග කිරීම:

>>> from collections import OrderedDict
>>> d_sorted_by_value = OrderedDict(sorted(d.items(), key=lambda x: x[1]))

ඕඩර්ඩෙක්ට් සාමාන්‍ය නියෝගයක් ලෙස හැසිරේ:

>>> for k, v in d_sorted_by_value.items():
...     print "%s: %s" % (k, v)
...
first: 1
second: 2
third: 3
fourth: 4

>>> d_sorted_by_value
OrderedDict([('first': 1), ('second': 2), ('third': 3), ('fourth': 4)])

යාවත්කාලීන කිරීම: 5 දෙසැම්බර් 2015 පයිතන් 3.5 භාවිතා කිරීම

පිළිගත් පිළිතුර ප්‍රයෝජනවත් යැයි මට පෙනී ගියද , සම්මත පුස්තකාල එකතු කිරීමේ මොඩියුලයෙන් ඕඩර්ඩෙක්ට් යොමු කිරීම ශක්‍ය, නවීන විකල්පයක් ලෙස යාවත්කාලීන නොකිරීම ගැන මම පුදුමයට පත් වීමි .

from operator import itemgetter
from collections import OrderedDict

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = OrderedDict(sorted(x.items(), key=itemgetter(1)))
# OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])

නිල ඕර්ඩර්ඩික් ප්‍රලේඛනය ද ඊට සමාන උදාහරණයක් සපයයි, නමුත් වර්ග කිරීමේ කාර්යය සඳහා ලැම්බඩා භාවිතා කිරීම:

# regular unsorted dictionary
d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

# dictionary sorted by value
OrderedDict(sorted(d.items(), key=lambda t: t[1]))
# OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

හැන්ක් ගේ ගේ පිළිතුරට බොහෝ සෙයින් සමාන ය :

sorted([(value,key) for (key,value) in mydict.items()])

හෝ ජෝන් ෆවුහි යෝජනා කළ පරිදි තරමක් ප්‍රශස්ත කර ඇත:

sorted((value,key) for (key,value) in mydict.items())

බොහෝ විට නම් තැබීම භාවිතා කිරීම ඉතා පහසුය . උදාහරණයක් ලෙස, ඔබට 'නම' යතුරු ලෙසත්, 'ලකුණු' අගයන් ලෙසත් ඇති අතර ඔබට 'ලකුණු' මත වර්ග කිරීමට අවශ්‍යය:

import collections
Player = collections.namedtuple('Player', 'score name')
d = {'John':5, 'Alex':10, 'Richard': 7}

පළමුව අඩුම ලකුණු සමඟ වර්ග කිරීම:

worst = sorted(Player(v,k) for (k,v) in d.items())

පළමුව වැඩිම ලකුණු සමඟ වර්ග කිරීම:

best = sorted([Player(v,k) for (k,v) in d.items()], reverse=True)

දැන් ඔබට නම සහ ලකුණු ලබා ගත හැකිය, දෙවන හොඳම ක්‍රීඩකයා (දර්ශකය = 1) ඉතා පයිතොනිකව මේ ආකාරයට කියමු:

player = best[1]
player.name
    'Richard'
player.score
    7

වන විට පිඹුරා 3.6 වන බිල්ට් dict නියෝග කරනු ඇත

ශුභ ආරංචියක්, එබැවින් OP හි මුල් භාවිතා කිරීමේ යුගලය දත්ත සමුදායකින් ලබාගෙන ඇත්තේ අද්විතීය නූල් අයිඩී යතුරු ලෙස සහ සංඛ්‍යාත්මක අගයන් ලෙස ගොඩනංවන ලද පයිතන් v3.6 + විධානයට අගයන් ලෙස ය, දැන් ඇතුළත් කිරීමේ අනුපිළිවෙලට ගරු කළ යුතුය.

දත්ත සමුදා විමසුමක ප්‍රති ing ලයක් ලෙස තීරු වගු ප්‍රකාශන දෙකක් කියන්නේ නම්:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

k_seq සහ v_seq (සංඛ්‍යාත්මක දර්ශකයෙන් පෙලගැසී ඇති අතර පා course මාලාවේ එකම දිග සමඟ) පයිතන් ටුපල් දෙකක ගබඩා වේ, පසුව:

k_seq = ('foo', 'bar', 'baz')
v_seq = (0, 1, 42)
ordered_map = dict(zip(k_seq, v_seq))

පසුව ප්‍රතිදානය කිරීමට ඉඩ දෙන්න:

for k, v in ordered_map.items():
    print(k, v)

මෙම අවස්ථාවෙහිදී (නව පයිතන් 3.6+ බිල්ට් ඩික්ට් සඳහා!):

foo 0
bar 1
baz 42

v හි අගය අනුව එකම අනුපිළිවෙලින්.

මගේ පරිගණකයේ පයිතන් 3.5 ස්ථාපනය කරන විට එය දැනට ලබා දෙන්නේ:

bar 1
foo 0
baz 42

විස්තර:

රේමන්ඩ් හෙටින්ගර් විසින් 2012 දී යෝජනා කරන ලද පරිදි ( "වේගවත් පුනරාවර්තනයක් සහිත වඩාත් සංයුක්ත ශබ්දකෝෂ" යන මාතෘකාව සහිත පයිතන්-දේව් හි cf. තැපෑල ) සහ දැන් (2016 දී) වික්ටර් ස්ටිනර් විසින් තැපෑලෙන් පයිතන්-දේව් වෙත ලිපියක් මගින් ප්‍රකාශයට පත් කරන ලදී. සංයුක්ත හා පුද්ගලික අනුවාදයක් ලබා ගනී; සහ 27350 නිකුතුව නිවැරදි කිරීම / ක්‍රියාත්මක කිරීම හේතුවෙන් “සංයුක්ත හා ඇණවුම් කළ නියෝගය” අපි දැන් බිල්ට් ඇතුලත් කරන්න සාමය ආරක්ෂා කිරීම සඳහා dict භාවිතා කිරීමට, හැකි වනු ඇත Python 3.6 !!

පළමු පියවර ලෙස මෙය තුනී ස්ථරයක් ඕඩර්ඩෙක්ට් ක්‍රියාත්මක කිරීමට හේතු වනු ඇතැයි අපේක්‍ෂා කරමු. @ ජිම් ෆසරකිස්-හිල්යාඩ් පෙන්වා දුන් පරිදි, සමහරු අනාගතයේ දී ඕඩර්ඩෙක්ට් වර්ගය සඳහා භාවිතා කිරීමේ අවස්ථා දකිති. මම හිතන්නේ පයිතන් ප්‍රජාව පරිස්සමින් පරීක්ෂා කර බලනු ඇත, මෙය කාලය පිළිබඳ පරීක්ෂණයට ලක් වන්නේ නම් සහ ඊළඟ පියවර මොනවාද යන්න.

ස්ථාවර ඇණවුමකින් විවෘත කළ හැකියාවන් අතපසු නොකිරීමට අපගේ කේතීකරණ පුරුදු ගැන නැවත සිතා බැලීමට කාලය:

• මූල පද තර්ක සහ
• (අතරමැදි) ඩික්ට් ගබඩා කිරීම

පළමුවැන්න එය සමහර අවස්ථාවල කාර්යයන් සහ ක්‍රමවේදයන් ක්‍රියාත්මක කිරීමේදී යැවීම පහසු කරයි.

දෙවැන්න dictනල මාර්ග සැකසීමේදී අතරමැදි ආචයනය ලෙස වඩාත් පහසුවෙන් භාවිතා කිරීමට දිරිගන්වයි .

රේමන්ඩ් හෙට්ටිංගර් විසින් " පයිතන් 3.6 ශබ්දකෝෂ පිටුපස ඇති තාක්‍ෂණය " විස්තර කරන ලියකියවිලි කාරුණිකව සපයන ලදී - ඔහුගේ සැන් ෆ්රැන්සිස්කෝ පයිතන් රැස්වීම් සමූහ ඉදිරිපත් කිරීම 2016-DEC-08 වෙතින්.

සමහර විට ස්ටැක් පිටාර ගැලීම ඉහළ සැරසිලි ප්‍රශ්න සහ පිළිතුරු පිටුවලට මෙම තොරතුරු වල ප්‍රභේද ලැබෙනු ඇති අතර බොහෝ උසස් තත්ත්වයේ පිළිතුරු සඳහා එක් අනුවාදයක් යාවත්කාලීන කිරීම අවශ්‍ය වේ.

Caveat Emptor (නමුත් 2017-12-15 යාවත්කාලීන කිරීමද බලන්න):

@Ajcr නිවැරදිව සටහන් කර ඇති පරිදි: "මෙම නව ක්‍රියාවට නැංවීමේ අංගය ක්‍රියාත්මක කිරීමේ විස්තරයක් ලෙස සලකනු ලබන අතර එය විශ්වාස නොකළ යුතුය." ( whatsnew36 වෙතින් ) නිට් පික් කිරීම නොවේ, නමුත් උපුටා දැක්වීම ටිකක් අශුභවාදී ලෙස කපා ඇත ;-). එය දිගටම පවතින්නේ "(මෙය අනාගතයේ දී වෙනස් විය හැකි නමුත්, වර්තමාන හා අනාගත පයිතන් ක්‍රියාවට නැංවීම සඳහා අර්ථකථන-සංරක්ෂණ අර්ථ නිරූපණයන් අනිවාර්ය කිරීම සඳහා භාෂා පිරිවිතර වෙනස් කිරීමට පෙර, මෙම නව නියෝග ක්‍රියාත්මක කිරීම සඳහා භාෂා කිහිපයක් නිකුත් කිරීමට අපේක්ෂා කෙරේ; අහඹු පුනරාවර්තන අනුපිළිවෙල තවමත් ක්‍රියාත්මක වන භාෂාවේ පැරණි අනුවාදයන් සමඟ පසුපසට-ගැළපුම ආරක්ෂා කර ගැනීමට උපකාරී වේ, උදා: පයිතන් 3.5).

සමහර මානව භාෂාවල මෙන් (උදා: ජර්මානු), භාවිතය භාෂාව හැඩගස්වන අතර, කැමැත්ත දැන් ප්‍රකාශයට පත් කර ඇත ... whatsnew36 හි .

යාවත්කාලීන කිරීම 2017-12-15:

දී මෙම පිඹුරා-dev ලැයිස්තුවට තැපැල් ගයිඩෝ වෑන් Rossum මෙසේ ප්රකාශ කලේ ය:

එය එසේ කරන්න. “ඩික්ට් ඇතුළු කිරීමේ අනුපිළිවෙල තබා ගනී” යනු තීන්දුවයි. ස්තූතියි!

ඉතින්, 3.6 අනුවාදය සීපයිතන් ඩික්ට් ඇතුළු කිරීමේ ඇණවුමේ අතුරු effect ලය දැන් භාෂා පිරිවිතරයේ කොටසක් බවට පත්වෙමින් තිබේ (තවදුරටත් ක්‍රියාත්මක කිරීමේ විස්තරයක් පමණක් නොවේ). collections.OrderedDictසාකච්ඡාවේදී රේමන්ඩ් හෙටින්ගර් විසින් සිහිපත් කළ පරිදි එම තැපැල් නූල් කැපී පෙනෙන නිර්මාණ ඉලක්ක කිහිපයක් මතු විය.

මට එකම ගැටලුව ඇති අතර මම එය මේ ආකාරයෙන් විසඳා ගත්තෙමි:

WantedOutput = sorted(MyDict, key=lambda x : MyDict[x]) 

("නියෝගයක් වර්ග කළ නොහැක" යනුවෙන් පිළිතුරු දෙන පුද්ගලයින් ප්‍රශ්නය කියවා නැත! ඇත්ත වශයෙන්ම, "මට යතුරු මත වර්ග කළ හැකිය, නමුත් සාරධර්ම මත පදනම්ව මා වර්ග කරන්නේ කෙසේද?" පැහැදිලිවම අදහස් කරන්නේ ඔහුට ලැයිස්තුවක් අවශ්‍ය බවයි. යතුරු ඒවායේ අගයන්හි වටිනාකම අනුව වර්ග කර ඇත.)

ඇණවුම මනාව අර්ථ දක්වා නොමැති බව කරුණාවෙන් සලකන්න (එකම අගය සහිත යතුරු ප්‍රතිදාන ලැයිස්තුවේ අත්තනෝමතික අනුපිළිවෙලකට වනු ඇත).

වටිනාකම් සංඛ්යාත්මක නම් ඔබ ද භාවිතා කළ හැක Counterසිට එකතු .

from collections import Counter

x = {'hello': 1, 'python': 5, 'world': 3}
c = Counter(x)
print(c.most_common())

>> [('python', 5), ('world', 3), ('hello', 1)]    

පයිතන් 2.7 හි සරලවම කරන්න:

from collections import OrderedDict
# regular unsorted dictionary
d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

# dictionary sorted by key
OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

# dictionary sorted by value
OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

පිටපත්-අලවන්න: http://docs.python.org/dev/library/collections.html#ordereddict-examples-and-recipes

භුක්ති විඳින්න ;-)

කේතය මෙයයි:

import operator
origin_list = [
    {"name": "foo", "rank": 0, "rofl": 20000},
    {"name": "Silly", "rank": 15, "rofl": 1000},
    {"name": "Baa", "rank": 300, "rofl": 20},
    {"name": "Zoo", "rank": 10, "rofl": 200},
    {"name": "Penguin", "rank": -1, "rofl": 10000}
]
print ">> Original >>"
for foo in origin_list:
    print foo

print "\n>> Rofl sort >>"
for foo in sorted(origin_list, key=operator.itemgetter("rofl")):
    print foo

print "\n>> Rank sort >>"
for foo in sorted(origin_list, key=operator.itemgetter("rank")):
    print foo

ප්‍රති results ල මෙන්න:

මුල්

{'name': 'foo', 'rank': 0, 'rofl': 20000}
{'name': 'Silly', 'rank': 15, 'rofl': 1000}
{'name': 'Baa', 'rank': 300, 'rofl': 20}
{'name': 'Zoo', 'rank': 10, 'rofl': 200}
{'name': 'Penguin', 'rank': -1, 'rofl': 10000}

Rofl

{'name': 'Baa', 'rank': 300, 'rofl': 20}
{'name': 'Zoo', 'rank': 10, 'rofl': 200}
{'name': 'Silly', 'rank': 15, 'rofl': 1000}
{'name': 'Penguin', 'rank': -1, 'rofl': 10000}
{'name': 'foo', 'rank': 0, 'rofl': 20000}

නිලය

{'name': 'Penguin', 'rank': -1, 'rofl': 10000}
{'name': 'foo', 'rank': 0, 'rofl': 20000}
{'name': 'Zoo', 'rank': 10, 'rofl': 200}
{'name': 'Silly', 'rank': 15, 'rofl': 1000}
{'name': 'Baa', 'rank': 300, 'rofl': 20}

පහත දැක්වෙන ප්‍රවේශය උත්සාහ කරන්න. පහත දැක්වෙන දත්ත සමඟ මයිඩික්ට් නම් ශබ්දකෝෂය නිර්වචනය කරමු:

mydict = {'carl':40,
          'alan':2,
          'bob':1,
          'danny':3}

යමෙකුට ශබ්ද කෝෂය යතුරු මගින් වර්ග කිරීමට අවශ්‍ය නම්, යමෙකුට එවැනි දෙයක් කළ හැකිය:

for key in sorted(mydict.iterkeys()):
    print "%s: %s" % (key, mydict[key])

මෙය පහත ප්‍රතිදානය ලබා දිය යුතුය:

alan: 2
bob: 1
carl: 40
danny: 3

අනෙක් අතට, යමෙකුට ශබ්ද කෝෂයක් අගය අනුව වර්ග කිරීමට අවශ්‍ය නම් (ප්‍රශ්නයෙහි අසන පරිදි) යමෙකුට පහත සඳහන් දෑ කළ හැකිය:

for key, value in sorted(mydict.iteritems(), key=lambda (k,v): (v,k)):
    print "%s: %s" % (key, value)

මෙම විධානයේ ප්‍රති result ලය (ශබ්ද කෝෂය අගය අනුව වර්ග කිරීම) පහත සඳහන් දෑ ලබා දිය යුතුය:

bob: 1
alan: 2
danny: 3
carl: 40

ඔබට "ප්‍රතිලෝම දර්ශකයක්" ද නිර්මාණය කළ හැකිය

from collections import defaultdict
inverse= defaultdict( list )
for k, v in originalDict.items():
    inverse[v].append( k )

දැන් ඔබේ ප්‍රතිලෝමයට අගයන් ඇත; සෑම අගයකටම අදාළ යතුරු ලැයිස්තුවක් ඇත.

for k in sorted(inverse):
    print k, inverse[k]

පයිතන් 3.6 සිට ඇරඹෙන dictවස්තු දැන් ඇතුළත් කිරීමේ අනුපිළිවෙලින් ඇණවුම් කර ඇත. එය නිල වශයෙන් පයිතන් 3.7 හි පිරිවිතරයන්හි ඇත.

>>> words = {"python": 2, "blah": 4, "alice": 3}
>>> dict(sorted(words.items(), key=lambda x: x[1]))
{'python': 2, 'alice': 3, 'blah': 4}

ඊට පෙර, ඔබට භාවිතා කිරීමට සිදු විය OrderedDict .

පයිතන් 3.7 ප්‍රලේඛනය මෙසේ පවසයි:

3.7 අනුවාදයේ වෙනස් කර ඇත: ශබ්ද කෝෂ අනුපිළිවෙල ඇතුළත් කිරීමේ අනුපිළිවෙල බවට සහතික වේ. මෙම හැසිරීම 3.6 සිට CPython ක්‍රියාත්මක කිරීමේ විස්තරය විය.

ඔබට එකතු කිරීම් භාවිතා කළ හැකිය . සටහන, මෙය සංඛ්‍යාත්මක හා සංඛ්‍යාත්මක නොවන අගයන් සඳහා ක්‍රියා කරනු ඇත.

>>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
>>> from collections import Counter
>>> #To sort in reverse order
>>> Counter(x).most_common()
[(3, 4), (4, 3), (1, 2), (2, 1), (0, 0)]
>>> #To sort in ascending order
>>> Counter(x).most_common()[::-1]
[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]
>>> #To get a dictionary sorted by values
>>> from collections import OrderedDict
>>> OrderedDict(Counter(x).most_common()[::-1])
OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])

අගය අනුව ස්ථිර ලෙස වර්ග කර ඇති ශබ්ද කෝෂයක් වන skip dict භාවිතා කළ හැකිය .

>>> data = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
>>> SkipDict(data)
{0: 0.0, 2: 1.0, 1: 2.0, 4: 3.0, 3: 4.0}

ඔබ භාවිතා කරන්නේ නම් keys(), values()නැතහොත් items()ඔබ අගය අනුව වර්ග කළ අනුපිළිවෙලට නැවත කියනු ඇත.

එය ක්‍රියාත්මක වන්නේ skip list datastructure භාවිතා කරමිනි.

යතුර වෙත යැවිය හැකි අභිරුචි ශ්‍රිතයක් ද ඔබට භාවිතා කළ හැකිය.

def dict_val(x):
    return x[1]
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=dict_val)

from django.utils.datastructures import SortedDict

def sortedDictByKey(self,data):
    """Sorted dictionary order by key"""
    sortedDict = SortedDict()
    if data:
        if isinstance(data, dict):
            sortedKey = sorted(data.keys())
            for k in sortedKey:
                sortedDict[k] = data[k]
    return sortedDict

ඩිලෙටන්ට් පෙන්වා දුන් පරිදි , පයිතන් 3.6 දැන් ඇණවුම තබා ගනීවි ! නැවත ලිවිය හැකි (ටුපල්, ලිස්ට්, ඩික්ට්) වර්ග කිරීම පහසු කරන මා ලියූ ශ්‍රිතයක් බෙදා ගැනීමට මම සිතුවෙමි. අවසාන අවස්ථාවේ දී, ඔබට යතුරු හෝ අගයන් මත වර්ග කළ හැකි අතර, එය සංඛ්‍යාත්මක සංසන්දනය සැලකිල්ලට ගත හැකිය. > = 3.6 සඳහා පමණි!

උදා: නූල් සහ තීන්ත රඳවා ඇති අනුකාරකයක් මත වර්ග කිරීම භාවිතා කිරීමට ඔබ උත්සාහ කරන විට, වර්ග කළ () අසමත් වේ. ඇත්ත වශයෙන්ම ඔබට str () සමඟ සංසන්දනය කිරීමට බල කළ හැකිය. කෙසේ වෙතත්, සමහර අවස්ථාවල ඔබට සත්‍ය සංඛ්‍යාත්මක සැසඳීමක් කිරීමට අවශ්‍ය 12වන්නේ ඊට වඩා කුඩා 20(නූල් සංසන්දනය කිරීමේදී එය නොවේ). ඒ නිසා මම පහත සඳහන් කරුණු ඉදිරිපත් කළා. ඔබට පැහැදිලි සංඛ්‍යාත්මක සංසන්දනයක් අවශ්‍ය වූ විට ඔබට ධජය භාවිතා කළ හැකියnum_as_num එමඟින් සියලු සංඛ්‍යා පාවෙන බවට පරිවර්තනය කිරීමට උත්සාහ කිරීමෙන් පැහැදිලි සංඛ්‍යාත්මක වර්ග කිරීමක් කිරීමට උත්සාහ කරනු ඇත. එය සාර්ථක වුවහොත්, එය සංඛ්‍යාත්මක වර්ග කිරීම සිදු කරයි, එසේ නොවුවහොත් එය නූල් සංසන්දනයකට යොමු වේ.

වැඩිදියුණු කිරීම හෝ තල්ලු ඉල්ලීම් පිළිගැනීම.

def sort_iterable(iterable, sort_on=None, reverse=False, num_as_num=False):
    def _sort(i):
      # sort by 0 = keys, 1 values, None for lists and tuples
      try:
        if num_as_num:
          if i is None:
            _sorted = sorted(iterable, key=lambda v: float(v), reverse=reverse)
          else:
            _sorted = dict(sorted(iterable.items(), key=lambda v: float(v[i]), reverse=reverse))
        else:
          raise TypeError
      except (TypeError, ValueError):
        if i is None:
          _sorted = sorted(iterable, key=lambda v: str(v), reverse=reverse)
        else:
          _sorted = dict(sorted(iterable.items(), key=lambda v: str(v[i]), reverse=reverse))

      return _sorted

    if isinstance(iterable, list):
      sorted_list = _sort(None)
      return sorted_list
    elif isinstance(iterable, tuple):
      sorted_list = tuple(_sort(None))
      return sorted_list
    elif isinstance(iterable, dict):
      if sort_on == 'keys':
        sorted_dict = _sort(0)
        return sorted_dict
      elif sort_on == 'values':
        sorted_dict = _sort(1)
        return sorted_dict
      elif sort_on is not None:
        raise ValueError(f"Unexpected value {sort_on} for sort_on. When sorting a dict, use key or values")
    else:
      raise TypeError(f"Unexpected type {type(iterable)} for iterable. Expected a list, tuple, or dict")

මෙන්න zip on d.values()සහd.keys() . මෙම සබැඳියට පහළින් පේළි කිහිපයක් (ශබ්ද කෝෂ දර්ශන වස්තු මත):

මෙය zip () භාවිතා කරමින් (අගය, යතුර) යුගල සෑදීමට ඉඩ දෙයි: pair = zip (d.values ​​(), d.keys ()).

එබැවින් අපට පහත සඳහන් දෑ කළ හැකිය:

d = {'key1': 874.7, 'key2': 5, 'key3': 8.1}

d_sorted = sorted(zip(d.values(), d.keys()))

print d_sorted 
# prints: [(5, 'key2'), (8.1, 'key3'), (874.7, 'key1')]

ඇත්ත වශයෙන්ම, මතක තබා ගන්න, OrderedDictසාමාන්‍ය පයිතන් ශබ්දකෝෂවල මුල් අනුපිළිවෙල නොපවතින බැවින් ඔබ භාවිතා කළ යුතුය .

from collections import OrderedDict
a = OrderedDict(sorted(originalDict.items(), key=lambda x: x[1]))

ඔබට පයිතන් 2.7 හෝ ඊට වැඩි නොමැති නම්, ඔබට කළ හැකි හොඳම දෙය වන්නේ උත්පාදක ශ්‍රිතයක අගයන් ඉක්මවා යාමයි. (මෙහි OrderedDict2.4 සහ 2.6 සඳහා ඇත , නමුත්

අ) එය කෙතරම් හොඳින් ක්‍රියාත්මක වේදැයි මම නොදනිමි

හා

ආ) ඔබ එය බාගත කර ස්ථාපනය කළ යුතුය. ඔබට පරිපාලනමය ප්‍රවේශයක් නොමැති නම්, විකල්පය අවසන් වනු ඇතැයි මම බිය වෙමි.)

def gen(originalDict):
    for x, y in sorted(zip(originalDict.keys(), originalDict.values()), key=lambda z: z[1]):
        yield (x, y)
    #Yields as a tuple with (key, value). You can iterate with conditional clauses to get what you want. 

for bleh, meh in gen(myDict):
    if bleh == "foo":
        print(myDict[bleh])

ඔබට සෑම අගයක්ම මුද්‍රණය කළ හැකිය

for bleh, meh in gen(myDict):
    print(bleh, meh)

පයිතන් 3.0 හෝ ඊට වැඩි භාවිතා නොකරන්නේ නම් මුද්‍රණයෙන් පසු වරහන් ඉවත් කිරීමට කරුණාකර මතක තබා ගන්න

Dicts වෙතින් ValueSortedDict භාවිතා කරන්න :

from dicts.sorteddict import ValueSortedDict
d = {1: 2, 3: 4, 4:3, 2:1, 0:0}
sorted_dict = ValueSortedDict(d)
print sorted_dict.items() 

[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]

ආ ict ාවක් හරහා අනුමාන කර එහි අගයන් අනුව අනුපිළිවෙලට වර්ග කරන්න:

$ python --version
Python 3.2.2

$ cat sort_dict_by_val_desc.py 
dictionary = dict(siis = 1, sana = 2, joka = 3, tuli = 4, aina = 5)
for word in sorted(dictionary, key=dictionary.get, reverse=True):
  print(word, dictionary[word])

$ python sort_dict_by_val_desc.py 
aina 5
tuli 4
joka 3
sana 2
siis 1

මෙය 3.1.x වලින් ක්‍රියා කරයි:

import operator
slovar_sorted=sorted(slovar.items(), key=operator.itemgetter(1), reverse=True)
print(slovar_sorted)

සෑම කෙනෙකුටම පයිතන් වෙතින් අදාළ කුසලතා ඉගෙන ගත්තා .

ශබ්ද කෝෂය වර්ග කිරීමට ඔබට උදව් කිරීමට ඔබට තාවකාලික ලැයිස්තුවක් භාවිතා කළ හැකිය:

#Assume dictionary to be:
d = {'apple': 500.1, 'banana': 1500.2, 'orange': 1.0, 'pineapple': 789.0}

# create a temporary list
tmp = []

# iterate through the dictionary and append each tuple into the temporary list 
for key, value in d.items():
    tmptuple = (value, key)
    tmp.append(tmptuple)

# sort the list in ascending order
tmp = sorted(tmp)

print (tmp)

ඔබට ලැයිස්තුව අවරෝහණ පිළිවෙලට වර්ග කිරීමට අවශ්‍ය නම්, මුල් වර්ග කිරීමේ රේඛාව පහත පරිදි වෙනස් කරන්න:

tmp = sorted(tmp, reverse=True)

ලැයිස්තු අවබෝධය භාවිතා කරමින්, එක් ලයිනර් එකක් වනුයේ:

#Assuming the dictionary looks like
d = {'apple': 500.1, 'banana': 1500.2, 'orange': 1.0, 'pineapple': 789.0}
#One liner for sorting in ascending order
print (sorted([(v, k) for k, v in d.items()]))
#One liner for sorting in descending order
print (sorted([(v, k) for k, v in d.items()], reverse=True))

නියැදි ප්‍රතිදානය:

#Asending order
[(1.0, 'orange'), (500.1, 'apple'), (789.0, 'pineapple'), (1500.2, 'banana')]
#Descending order
[(1500.2, 'banana'), (789.0, 'pineapple'), (500.1, 'apple'), (1.0, 'orange')]

ඔබේ අගයන් පූර්ණ සංඛ්‍යා නම්, සහ ඔබ පයිතන් 2.7 හෝ ඊට වඩා නව භාවිතා කරන්නේ නම්, collections.Counterඒ වෙනුවට ඔබට භාවිතා කළ හැකිය dict. මෙම most_commonක්‍රමය මඟින් ඔබට සියලු අයිතම ලබා දෙනු ඇත.

සම්පූර්ණත්වය උදෙසා, මම ගොඩවල් භාවිතා කරමින් විසඳුමක් පළ කරමි . සටහන, මෙම ක්‍රමය සංඛ්‍යාත්මක හා සංඛ්‍යාත්මක නොවන අගයන් සඳහා ක්‍රියා කරනු ඇත

>>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
>>> x_items = x.items()
>>> heapq.heapify(x_items)
>>> #To sort in reverse order
>>> heapq.nlargest(len(x_items),x_items, operator.itemgetter(1))
[(3, 4), (4, 3), (1, 2), (2, 1), (0, 0)]
>>> #To sort in ascending order
>>> heapq.nsmallest(len(x_items),x_items, operator.itemgetter(1))
[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]

පයිතන්ගේ පැරණි අනුවාදයන් සමඟ පසුගාමී අනුකූලතාව රඳවා තබා ගැනීමේ අවශ්‍යතා නිසා මම හිතන්නේ ඕඩර්ඩෙක්ට් විසඳුම ඉතා අ wise ාන ය. ඔබට අවශ්‍ය වන්නේ පයිතන් 2.7 සහ පැරණි අනුවාද සමඟ ක්‍රියා කරන දෙයක්.

නමුත් වෙනත් පිළිතුරක සඳහන් එකතු කිරීමේ විසඳුම අතිශයින්ම විශිෂ්ටයි, මන්ද ඔබ ශබ්දකෝෂ සම්බන්ධයෙන් අතිශයින්ම වැදගත් වන යතුර සහ වටිනාකම අතර සම්බන්ධතාවයක් නැවත ලබා ගනී.

වෙනත් පිළිතුරක ඉදිරිපත් කර ඇති අංක එක තේරීම සමඟ මම එකඟ නොවෙමි, මන්ද එය යතුරු ඉවතට විසි කරයි.

මම ඉහත සඳහන් කළ විසඳුම භාවිතා කළෙමි (පහත දැක්වෙන කේතය) යතුරු සහ අගයන් දෙකටම ප්‍රවේශය රඳවා ගත් අතර මගේ නඩුවේ ඇණවුම අගයන් මත පැවතුනද වැදගත්කම වූයේ අගයන් ඇණවුම් කිරීමෙන් පසු යතුරු ඇණවුම් කිරීමයි.

from collections import Counter

x = {'hello':1, 'python':5, 'world':3}
c=Counter(x)
print c.most_common()


>> [('python', 5), ('world', 3), ('hello', 1)]