辞書を値でソートする方法
データベースの2つのフィールド、つまり文字列フィールドと数値フィールドから読み取った値の辞書があります。文字列フィールドは一意なので、それが辞書のキーです。
キーで並べ替えることができますが、値に基づいて並べ替えるにはどうすればよいですか。
注：ここでスタックオーバーフローの質問を読みました。辞書の値で辞書のリストを並べ替えるにはどうすればよいですか。そしておそらく辞書のリストを持つように私のコードを変更することができますが、私は本当に辞書のリストを必要としないので、昇順または降順のどちらかにソートする簡単な解決策があるかどうか知りたいと思いました。
ソートされた辞書の表現を取得するためだけに、辞書をソートすることは不可能です。辞書は本質的に無秩序ですが、リストやタプルなどの他のタイプはそうではありません。そのため、ソートされた値を表すための順序付きデータ型が必要になります。これはリスト、おそらくタプルのリストになります。
例えば、
import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(1))
sorted_xは、各Tupleの2番目の要素でソートされたタプルのリストです。 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))
Python 3では解凍は許可されていないので [1] 私たちは使うことができる
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=lambda kv: kv[1])
辞書として出力したい場合は、 collections.OrderedDict を使用できます。
import collections
sorted_dict = collections.OrderedDict(sorted_x)
同じくらい簡単：sorted(dict1, key=dict1.get)
実は、「辞書値によるソート」を行うことは実際には可能です。最近私はコードゴルフでそれをやらなければなりませんでした（スタックオーバーフローの質問コードゴルフ：単語頻度図）。要約すると、問題はそのようなものでした。テキストを与えられて、各Wordが遭遇される頻度を数えて、そして減少する頻度で分類されたトップの単語のリストを表示します。
単語をキーとして、各単語の出現回数を値として持つ辞書を作成すると、次のように簡略化されます。
from collections import defaultdict
d = defaultdict(int)
for w in text.split():
d[w] += 1
次に、sorted(d, key=d.get)の使用頻度順に並べられた単語のリストを取得することができます。ソートは、Wordの出現回数をソートキーとして使用して、辞書キーを反復処理します。
for w in sorted(d, key=d.get, reverse=True):
print w, d[w]
私はこの詳細な説明を書いているのは、「辞書をキーで簡単に並べ替えることができますが、値で並べ替えるにはどうすればよいか」という人々の意味を説明するためです。そして解決策は、上に示したように、値に基づいてキーのリストのようなものをすることです。
あなたが使用することができます：
sorted(d.items(), key=lambda x: x[1])
これにより、辞書内の各エントリの値によって辞書が最小から最大の順に並べ替えられます。
辞書を並べ替えることはできませんが、それらから並べ替えられたリストを作成することができます。
辞書値のソートされたリスト：
sorted(d.values())
値でソートされた（キー、値）のペアのリスト。
from operator import itemgetter
sorted(d.items(), key=itemgetter(1))
最近のPython 2.7では、新しい OrderedDict 型が追加されました。これは、項目が追加された順番を記憶しています。
>>> 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]))
OrderedDictは通常の辞書のように動作します。
>>> 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)])
更新：2015年12月5日、Python 3.5を使用して
私は、受け入れられた答えが有用であると思った一方で、標準ライブラリ collections モジュールからOrderedDictを参照できるように更新されていないことに驚きました。 - この種の問題を正確に解決するように設計されています。
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)])
公式のOrderedDictのドキュメントも非常によく似た例を提供していますが、sort関数にはラムダを使用しています。
# 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()])
あるいはJohn Fouhyが示唆しているようにわずかに最適化されています。
sorted((value,key) for (key,value) in mydict.items())
それはしばしば使うのにとても便利です。 namedtuple。たとえば、キーとして 'name'、値として 'score'の辞書があり、 'score'でソートしたいとします。
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)
これで名前とスコアを取得することができます。2番目に優秀なプレーヤー（index = 1）をPythonのように次のように言いましょう。
player = best[1]
player.name
'Richard'
player.score
7
Python 3.6 以降、組み込み辞書は順序付けされます。
朗報です。データベースから取得した一意の文字列IDをキーとして、数値を値として、組み込みのPython v3.6 +辞書にマッピングするというOPの元々の使用例では、挿入順序を考慮する必要があります。
データベースクエリから得られる2つの列テーブル式を次のように言うと：
SELECT a_key, a_value FROM a_table ORDER BY a_value;
2つのPythonタプル、k_seqとv_seq（数値インデックスで整列され、もちろん同じ長さ）に格納されます。
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)
この場合、次のようになります（新しいPython 3.6+組み込み辞書の場合）。
foo 0
bar 1
baz 42
vの値ごとに同じ順序で。
Python 3.5のどこに私のマシンがインストールされていますか？
bar 1
foo 0
baz 42
詳細：
2012年にRaymond Hettingerによって提案されたように（python-devの件名 "より高速な繰り返しを含むよりコンパクトな辞書" ）そして現在（2016年）、Victor Stinnerによってpython-devへのメールで発表されました。 subject "Python 3.6辞書はコンパクトになりプライベート版になります;そしてキーワードは順序付けされます" Python 3.6では、問題27350の修正/実装により{ "コンパクト順序付けされた辞書" これで、挿入順序を維持するために組み込みの辞書を使用することができます。
うまくいけば、これは最初のステップとして薄層OrderedDict実装につながるでしょう。 @ JimFasarakis-Hilliardが示したように、将来的にはOrderedDict型のユースケースも見られるようになりました。私はPythonコミュニティ全体がこれを時間の試練に耐えられるかどうか、そして次のステップはどうなるのかを慎重に調べていくと思います。
以下の安定した順序付けによって開かれた可能性を見逃さないように、コーディング習慣を再考する時間です。
- キーワード引数と
- （中間）辞書ストレージ
1つ目は、関数やメソッドの実装におけるディスパッチを容易にするためです。
2つ目は、パイプラインを処理する際の中間ストレージとしてdictをより簡単に使用することを奨励するものです。
Raymond Hettingerは、彼のサンフランシスコPython Meetupグループのプレゼンテーション2016-DEC-08から " Python 3.6辞書の技術 "を説明する文書を親切に提供しました。
そして多分かなりのStack Overflowハイデコレーションされた質問と回答のページはこの情報の変種を受け取るでしょう、そして多くの高品質の答えは同じくバージョン毎の更新も必要になるでしょう。
Emptorに注意してください（ただし、下記のアップデート2017-12-15も参照してください）。
@ajcr氏が正しく指摘しているように、「この新しい実装の順序を保存するという側面は実装の詳細と見なされるため、信頼するべきではありません。」 （ whatsnew36 ）からnitピッキングではありません、 しかし 引用は少し悲観的にカットされました;-)。 （これは将来変更されるかもしれませんが、言語仕様を変更して現在および将来のすべてのPython実装に順序保持セマンティクスを強制する前に、この新しい辞書実装をいくつかのリリースで言語に含めることが望ましいです。ランダムな繰り返し順序がまだ有効な古いバージョンの言語との後方互換性を維持するのに役立ちます。
そのため、一部の人間の言語（ドイツ語など）と同様に、使用法によって言語が形成され、意志が宣言されています... whatsnew36 。
更新2017-12-15：
python-devリストへのメール で、Guido van Rossumは次のように宣言しています。
そうしてください。 「Dictが広告掲載の順番を守る」が決定です。ありがとうございます。
そのため、辞書挿入順序のバージョン3.6 CPythonの副作用は、言語仕様の一部になりつつあります（実装の詳細だけではなくなりました）。議論の間にRaymond Hettingerによって思い出させられたそのメールスレッドはまたcollections.OrderedDictのためのいくつかの際立ったデザイン目標を浮上させました。
与えられた辞書
e = {1:39, 4:34, 7:110, 2:87}
ソート
sred = sorted(e.items(), key=lambda value: value[1])
結果
[(4, 34), (1, 39), (2, 87), (7, 110)]
ラムダ関数を使用すると、値でソートして変数内に処理して保存できます。この場合は、 sred with e となります。
それが役立つことを願っています！
私は同じ問題を抱えていた、そして私はこのようにそれを解決した：
WantedOutput = sorted(MyDict, key=lambda x : MyDict[x])
（「辞書を並べ替えることはできません」と答えた人は質問を読んでいませんでした。キーはそれらの値の値に従ってソートされています。）
順序が明確に定義されていないことに注意してください（同じ値を持つキーは、出力リストでは任意の順序になります）。
Python 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
楽しい ;-）
技術的には、辞書はシーケンスではないのでソートできません。あなたはのようなことをすることができます
sorted(a_dictionary.values())
パフォーマンスは大したことではないと想定してください。
これはコードです：
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
結果は次のとおりです。
元の
{'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}
値が数値の場合は、コレクションの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)]
次の方法を試してください。次のデータを使ってmydictという辞書を定義しましょう。
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)
このコマンドの結果（辞書は値でソートされます）、次のようになります。
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]
collections.Counter を使用できます。これは数値と非数値の両方に有効です。
>>> 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)])
辞書内のキーと値のペアのリストを、値の大きい順に並べ替えて返します。
sorted(d.items(), key=lambda x: x[1], reverse=True)
キー順にソートされた辞書の場合は、次のようにします。
sorted(d.items(), reverse=True)
辞書自体はソートできないため、戻り値はタプルのリストです。
これは、印刷することも、さらなる計算に送ることもできます。
Python 3.6から、dictオブジェクトは挿入順に並べられました。正式にはPython 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を使わなければなりませんでした。
Python 3.7のドキュメント says：
バージョン3.7で変更された仕様：辞書順は挿入順であることが保証されています。この動作は3.6からのCPythonの実装の詳細でした。
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
Keyに渡すことができるカスタム関数を使うこともできます。
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)
もう1つの方法はlabmda関数を使うことです
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=lambda t: t[1])
Dilettantが指摘したように 、Python 3.6は順序を守る！になるでしょう。私は自分が書いた関数を共有して、イテラブル（Tuple、list、dict）のソートを容易にすると思いました。後者の場合は、キーまたは値のどちらでもソートでき、数値比較を考慮に入れることができます。 3.6以上の場合のみ！
あなたが保持するイテラブルに並べ替えを使用しようとするとintと同様に文字列、sorted（）は失敗します。もちろん、str（）を使って文字列の比較を強制することもできます。ただし、12が20よりも小さいactual数値比較を実行したい場合があります（これはストリング比較の場合ではありません）。そこで私は以下のことを思いついた。明示的な数値比較が必要な場合は、フラグ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（）を使用して（value、key）ペアを作成できます。pairs = 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')]
ValueSortedDict from 辞書 を使用します。
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)]
もちろん、通常のPython辞書では元の順序が維持されないため、OrderedDictを使用する必要があります。
from collections import OrderedDict
a = OrderedDict(sorted(originalDict.items(), key = lambda x: x[1]))
あなたがPython 2.7以上を持っていないならば、あなたがすることができる最善はジェネレータ関数の中で値を反復することです。 （2.4と2.6にはOrderedDictがあります ここ
a) I don't know about how well it works
そして
b) You have to download and install it of course. If you do not have administrative access, then I'm afraid the option's out.)
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)
Python 3.0以降を使用していない場合は、印刷後に括弧を忘れずに削除してください。
辞書を繰り返し、値の降順で並べ替えます。
$ 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
値が整数で、Python 2.7以降を使用している場合は、dictの代わりに collections.Counter を使用できます。 most_commonメソッドは、値でソートされたすべての項目をあなたに渡します。
私はこれを思いつきました、
import operator
x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
sorted_x = {k[0]:k[1] for k in sorted(x.items(), key=operator.itemgetter(1))}
Python 3.xの場合：x.items()をiteritems()に置き換えます。
>>> sorted_x
{0: 0, 1: 2, 2: 1, 3: 4, 4: 3}
またはcollections.OrderedDictで試してください！
x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
from collections import OrderedDict
od1 = OrderedDict(sorted(x.items(), key=lambda t: t[1]))
あなたはPythonのsort関数を使うことができます
sorted(iterable[, cmp[, key[, reverse]]])
したがって、あなたは使用することができます：
sorted(dictionary.items(),key = lambda x :x[1])
ソート機能の詳細については、このリンクを参照してください。 https://docs.python.org/2/library/functions.html#sorted
これは3.1.xで動作します。
import operator
slovar_sorted=sorted(slovar.items(), key=operator.itemgetter(1), reverse=True)
print(slovar_sorted)
完全を期すために、 heapq を使用してソリューションを投稿しています。このメソッドは数値と非数値の両方に機能することに注意してください。
>>> 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)]
Python for Everybody から適切なスキルを学んだだけです。
あなたはあなたが辞書をソートするのを助けるために一時的なリストを使うかもしれません：
#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')]
months = {"January": 31, "February": 28, "March": 31, "April": 30, "May": 31,
"June": 30, "July": 31, "August": 31, "September": 30, "October": 31,
"November": 30, "December": 31}
def mykey(t):
""" Customize your sorting logic using this function. The parameter to
this function is a Tuple. Comment/uncomment the return statements to test
different logics.
"""
return t[1] # sort by number of days in the month
#return t[1], t[0] # sort by number of days, then by month name
#return len(t[0]) # sort by length of month name
#return t[0][-1] # sort by last character of month name
# Since a dictionary can't be sorted by value, what you can do is to convert
# it into a list of tuples with Tuple length 2.
# You can then do custom sorts by passing your own function to sorted().
months_as_list = sorted(months.items(), key=mykey, reverse=False)
for month in months_as_list:
print month
Python の古いバージョンとの後方互換性を維持するという要件のために、OrderedDictソリューションは非常に賢明ではないと思います。 Python 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)]
Thomas Cokelaer これを非常にエレガントな方法で説明しています。私は彼の記事の簡単なメモを挙げるのが好きです。
次の辞書を考えましょう。
d = {"Pierre": 42, "Anne": 33, "Zoe": 24}
値に基づいてソートするために、以下のいくつかのアプローチが提示されています。
sorted関数とoperatorモジュール
import operator
sorted_d = sorted(d.items(), key=operator.itemgetter(1))
sorted関数とlambda関数
sorted_d = sorted(d.items(), key=lambda x: x[1])
sorted関数で順序付けられた辞書を返す
前のメソッドでは、返されるオブジェクトはタプルのリストです。だから私たちはもう辞書を持っていません。必要に応じてOrderedDictを使うことができます。
from collections import OrderedDict
sorted_d = OrderedDict(sorted(d.items(), key=lambda x: x[1]))
sorted関数とリストの内包表記
sorted_d = sorted((value, key) for (key,value) in d.items())
しかし、 彼 はまた、上記の手順の簡単なベンチマークを行いました。
Python 3.2を使う：
x = {"b":4, "a":3, "c":1}
for i in sorted(x.values()):
print(list(x.keys())[list(x.values()).index(i)])
このメソッドはラムダを使用せず、Python 3.6でうまく機能します。
# sort dictionary by value
d = {'a1': 'fsdfds', 'g5': 'aa3432ff', 'ca':'zz23432'}
def getkeybyvalue(d,i):
for k, v in d.items():
if v == i:
return (k)
sortvaluelist = sorted(d.values())
# In >> Python 3.6+ << the INSERTION-ORDER of a dict is preserved. That is,
# when creating a NEW dictionary and filling it 'in sorted order',
# that order will be maintained.
sortresult ={}
for i1 in sortvaluelist:
key = getkeybyvalue(d,i1)
sortresult[key] = i1
print ('=====sort by value=====')
print (sortresult)
print ('=======================')
組み込みモジュールなどを使用する以外に、私はそれを手動で解決しようとします..... 最初 dictの各項目に最小値を返すことを仕事とする関数を作りました：
def returnminDict(_dct):
dict_items = _dct.items()
list_items = list(dict_items)
init_items = list_items[0]
for i in range(len(list_items)):
if list_items[i][1] > init_items[1]:
continue
else:
init_items = list_items[i]
return init_items
第二 今、私たちは最小値を持つ項目を返す関数を持っている、そして私は新しい辞書を作り、辞書をループする：
def SelectDictSort(_dct):
new_dict = {}
while _dct:
mindict = returnminDict(_dct)
new_dict.update(dict((mindict,)))
_dct.pop(mindict[0])
return new_dict
私はこれを試してみてくださいSelectDictSort({2: 5, 5: 1, 4: 3, 1: 1, 0: 1, 9: 2, 8: 2})が返されます：
{0: 1, 1: 1, 5: 1, 8: 2, 9: 2, 4: 3, 2: 5}
うーん...私は正しいのかわからないが、これは私が試してみました....
（コードをretrun new_dctからreturn new_dictに更新）
>>> import collections
>>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
>>> sorted_x = collections.OrderedDict(sorted(x.items(), key=lambda t:t[1]))
>>> OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])
OrderedDictはdictのサブクラスです。