sort - python時間排序




如何根據Python中字典的值對字典列表進行排序? (12)

使用Perl的Schwartzian變換,

py = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

sort_on = "name"
decorated = [(dict_[sort_on], dict_) for dict_ in py]
decorated.sort()
result = [dict_ for (key, dict_) in decorated]

>>> result
[{'age': 10, 'name': 'Bart'}, {'age': 39, 'name': 'Homer'}]

更多關於Perl Schwartzian變換

在計算機科學中,Schwartzian變換是一種Perl編程習慣用法,用於提高對項目列表進行排序的效率。 這種習慣用法適用於基於比較的排序,當排序實際上基於元素的某個屬性(關鍵)的排序時,其中計算該屬性是應該執行最少次數的密集操作。 Schwartzian變換值得注意的是它不使用命名的臨時數組。

我收到了一個字典列表,並希望按字典的值進行排序。

這個

[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

按名稱排序,應該成為

[{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]

使用熊貓軟件包是另一種方法,儘管大規模運行時比其他人提出的更傳統的方法要慢得多:

import pandas as pd

listOfDicts = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
df = pd.DataFrame(listOfDicts)
df = df.sort_values('name')
sorted_listOfDicts = df.T.to_dict().values()

下面是一個小列表和一個大(100k +)字典列表的基準值:

setup_large = "listOfDicts = [];\
[listOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10})) for _ in range(50000)];\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(listOfDicts);"

setup_small = "listOfDicts = [];\
listOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}));\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(listOfDicts);"

method1 = "newlist = sorted(listOfDicts, key=lambda k: k['name'])"
method2 = "newlist = sorted(listOfDicts, key=itemgetter('name')) "
method3 = "df = df.sort_values('name');\
sorted_listOfDicts = df.T.to_dict().values()"

import timeit
t = timeit.Timer(method1, setup_small)
print('Small Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_small)
print('Small Method LC2: ' + str(t.timeit(100)))
t = timeit.Timer(method3, setup_small)
print('Small Method Pandas: ' + str(t.timeit(100)))

t = timeit.Timer(method1, setup_large)
print('Large Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_large)
print('Large Method LC2: ' + str(t.timeit(100)))
t = timeit.Timer(method3, setup_large)
print('Large Method Pandas: ' + str(t.timeit(1)))

#Small Method LC: 0.000163078308105
#Small Method LC2: 0.000134944915771
#Small Method Pandas: 0.0712950229645
#Large Method LC: 0.0321750640869
#Large Method LC2: 0.0206089019775
#Large Method Pandas: 5.81405615807

如果您想通過多個鍵對列表進行排序,您可以執行以下操作:

my_list = [{'name':'Homer', 'age':39}, {'name':'Milhouse', 'age':10}, {'name':'Bart', 'age':10} ]
sortedlist = sorted(my_list , key=lambda elem: "%02d %s" % (elem['age'], elem['name']))

這很冒險,因為它依賴於將值轉換為單個字符串表示形式進行比較,但它對包含負數的數字的預期效果(儘管如果使用數字,您將需要適當地使用零填充格式化字符串)


它可能看起來更清潔使用一個鍵,而不是一個cmp:

newlist = sorted(list_to_be_sorted, key=lambda k: k['name']) 

或者像JFSebastian和其他人所建議的那樣,

from operator import itemgetter
newlist = sorted(list_to_be_sorted, key=itemgetter('name')) 

為了完整性(正如fitzgeraldsteele的評論中指出的那樣),添加reverse=True來降序排序

newlist = sorted(l, key=itemgetter('name'), reverse=True)


我嘗試了這樣的事情:

my_list.sort(key=lambda x: x['name'])

它也適用於整數。


有時我們需要使用lower()作為例子

lists = [{'name':'Homer', 'age':39},
  {'name':'Bart', 'age':10},
  {'name':'abby', 'age':9}]

lists = sorted(lists, key=lambda k: k['name'])
print(lists)
# [{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}, {'name':'abby', 'age':9}]

lists = sorted(lists, key=lambda k: k['name'].lower())
print(lists)
# [ {'name':'abby', 'age':9}, {'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]

讓我們說一下帶有下面元素的字典D. 要排序只是在排序中使用鍵參數傳遞自定義函數如下

D = {'eggs': 3, 'ham': 1, 'spam': 2}

def get_count(tuple):
    return tuple[1]

sorted(D.items(), key = get_count, reverse=True)
or
sorted(D.items(), key = lambda x: x[1], reverse=True)  avoiding get_count function call

https://wiki.python.org/moin/HowTo/Sorting/#Key_Functions


這是另一種通用的解決方案 - 它通過鍵和值對字典的元素進行排序。 它的優點 - 無需指定鍵,並且如果某些字典中某些鍵丟失,它仍然可以工作。

def sort_key_func(item):
    """ helper function used to sort list of dicts

    :param item: dict
    :return: sorted list of tuples (k, v)
    """
    pairs = []
    for k, v in item.items():
        pairs.append((k, v))
    return sorted(pairs)
sorted(A, key=sort_key_func)

a = [{'name':'Homer', 'age':39}, ...]

# This changes the list a
a.sort(key=lambda k : k['name'])

# This returns a new list (a is not modified)
sorted(a, key=lambda k : k['name']) 

import operator
a_list_of_dicts.sort(key=operator.itemgetter('name'))

'key'用於按任意值排序,'itemgetter'將該值設置為每個項目的'name'屬性。


my_list = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

my_list.sort(lambda x,y : cmp(x['name'], y['name']))

my_list現在將成為你想要的。

(3年後)編輯補充:

新的key參數更加高效和整潔。 現在更好的答案是:

my_list = sorted(my_list, key=lambda k: k['name'])

... lambda是IMO,比operator.itemgetter更容易理解,但是YMMV。





data-structures