ฉันจะเรียงลำดับรายการพจนานุกรมตามค่าของพจนานุกรมได้อย่างไร

ฉันมีรายการพจนานุกรมและต้องการให้แต่ละรายการเรียงลำดับตามค่าคุณสมบัติเฉพาะ

คำนึงถึงอาร์เรย์ด้านล่าง

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

เมื่อเรียงตามnameควรเป็น

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

มันอาจดูสะอาดขึ้นโดยใช้กุญแจแทน 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)

import operator

ในการจัดเรียงรายการพจนานุกรมตาม key = 'name':

list_of_dicts.sort(key=operator.itemgetter('name'))

ในการจัดเรียงรายการพจนานุกรมตาม key = 'age':

list_of_dicts.sort(key=operator.itemgetter('age'))

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อาร์กิวเมนต์ใหม่มีประสิทธิภาพมากขึ้นและเป็น neater คำตอบที่ดีกว่าตอนนี้ดูเหมือนว่า:

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

... แลมบ์ดานั้นเป็น IMO เข้าใจง่ายกว่าoperator.itemgetterแต่ YMMV

หากคุณต้องการเรียงลำดับรายการด้วยปุ่มหลายปุ่มคุณสามารถทำสิ่งต่อไปนี้:

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']))

มันค่อนข้างแฮ็คเนื่องจากมันอาศัยการแปลงค่าเป็นตัวแทนสตริงเดียวสำหรับการเปรียบเทียบ แต่ทำงานได้ตามที่คาดไว้สำหรับตัวเลขรวมถึงค่าลบ (แม้ว่าคุณจะต้องจัดรูปแบบสตริงของคุณอย่างเหมาะสมด้วยการเติมเต็มศูนย์ถ้าคุณใช้ตัวเลข)

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

'key' ใช้เพื่อจัดเรียงตามค่าที่ต้องการและ 'itemgetter' จะตั้งค่านั้นให้กับแอตทริบิวต์ 'name' ของแต่ละรายการ

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']) 

ฉันเดาว่าคุณหมายถึง:

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

สิ่งนี้จะถูกจัดเรียงเช่นนี้:

sorted(l,cmp=lambda x,y: cmp(x['name'],y['name']))

คุณสามารถใช้ฟังก์ชั่นการเปรียบเทียบแบบกำหนดเองหรือคุณสามารถส่งผ่านฟังก์ชันที่คำนวณคีย์การเรียงลำดับแบบกำหนดเอง ซึ่งมักจะมีประสิทธิภาพมากกว่าเนื่องจากคีย์จะคำนวณเพียงครั้งเดียวต่อรายการในขณะที่ฟังก์ชันการเปรียบเทียบจะถูกเรียกอีกครั้ง

คุณสามารถทำได้ด้วยวิธีนี้:

def mykey(adict): return adict['name']
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, key=mykey)

itemgetterแต่ห้องสมุดมาตรฐานมีกิจวัตรประจำวันทั่วไปในการรับรายการของวัตถุโดยพลการ: ลองใช้วิธีนี้แทน:

from operator import itemgetter
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, key=itemgetter('name'))

ใช้ Schwartzian เปลี่ยนจาก Perl

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 transform เป็นสำนวนการเขียนโปรแกรม Perl ที่ใช้ในการปรับปรุงประสิทธิภาพของการเรียงลำดับรายการ สำนวนนี้เหมาะสำหรับการเรียงลำดับแบบการเปรียบเทียบเมื่อจริง ๆ แล้วการเรียงลำดับนั้นขึ้นอยู่กับการเรียงลำดับของคุณสมบัติบางอย่าง (คีย์) ขององค์ประกอบโดยที่การคำนวณคุณสมบัตินั้นเป็นการดำเนินการแบบเข้มข้นที่ควรทำจำนวนครั้งน้อยที่สุด การแปลงชวาร์ตเซียนมีความโดดเด่นในเรื่องที่ว่าไม่ได้ใช้อาร์เรย์ชั่วคราวที่มีชื่อ

คุณต้องใช้ฟังก์ชั่นการเปรียบเทียบของคุณเองที่จะเปรียบเทียบพจนานุกรมตามค่าของคีย์ชื่อ ดูการเรียงลำดับ Mini-HOW TO จาก PythonInfo Wiki

บางครั้งเราจำเป็นต้องใช้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}]

นี่คือโซลูชันทั่วไปทางเลือก - เรียงลำดับองค์ประกอบของ dict ตามคีย์และค่า ข้อดีของมัน - ไม่จำเป็นต้องระบุคีย์และมันจะยังคงใช้งานได้หากบางคีย์ขาดหายไปในพจนานุกรม

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)

การใช้แพ็กเกจแพนด้าเป็นวิธีอื่นแม้ว่าจะเป็นแบบรันไทม์ขนาดใหญ่ช้ากว่าวิธีแบบดั้งเดิมที่เสนอโดยคนอื่น ๆ :

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 +) ของ dicts:

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

ถ้าคุณไม่จำเป็นต้องเป็นต้นฉบับlistของdictionariesคุณสามารถปรับเปลี่ยนได้ในสถานที่ที่มีsort()วิธีการใช้ฟังก์ชั่นคีย์ที่กำหนดเอง

ฟังก์ชั่นที่สำคัญ:

def get_name(d):
    """ Return the value of a key in a dictionary. """

    return d["name"]

listต้องเรียงลำดับ:

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

เรียงลำดับแบบแทนที่:

data_one.sort(key=get_name)

หากคุณต้องการต้นฉบับlistให้เรียกใช้sorted()ฟังก์ชันที่ส่งผ่านไปยังlistและฟังก์ชั่นคีย์จากนั้นกำหนดค่าที่ส่งคืนlistไปยังตัวแปรใหม่:

data_two = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}]
new_data = sorted(data_two, key=get_name)

การพิมพ์และdata_onenew_data

>>> print(data_one)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]
>>> print(new_data)
[{'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

ตรวจสอบนี้ออก

ฉันเป็นแฟนตัวยงของตัวกรองด้วยแลมบ์ดา แต่มันไม่ใช่ตัวเลือกที่ดีที่สุดถ้าคุณพิจารณาความซับซ้อนของเวลา

ตัวเลือกแรก

sorted_list = sorted(list_to_sort, key= lambda x: x['name'])
# returns list of values

ตัวเลือกที่สอง

list_to_sort.sort(key=operator.itemgetter('name'))
#edits the list, does not return a new list

การเปรียบเทียบเวลาในการประมวลผลอย่างรวดเร็ว

# First option
python3.6 -m timeit -s "list_to_sort = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}, {'name':'Faaa', 'age':57}, {'name':'Errr', 'age':20}]" -s "sorted_l=[]" "sorted_l = sorted(list_to_sort, key=lambda e: e['name'])"

1000000 ลูปที่ดีที่สุดคือ 3: 0.736 usec ต่อวง

# Second option 
python3.6 -m timeit -s "list_to_sort = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}, {'name':'Faaa', 'age':57}, {'name':'Errr', 'age':20}]" -s "sorted_l=[]" -s "import operator" "list_to_sort.sort(key=operator.itemgetter('name'))"

1000000 ลูปที่ดีที่สุดคือ 3: 0.438 usec ต่อวง

หากประสิทธิภาพเป็นสิ่งที่น่ากังวลฉันจะใช้operator.itemgetterแทนlambdaฟังก์ชั่นในตัวที่ทำงานได้เร็วกว่าฟังก์ชั่นที่สร้างขึ้นด้วยมือ itemgetterฟังก์ชั่นที่ดูเหมือนว่าจะดำเนินการประมาณ 20% เร็วกว่าlambdaขึ้นอยู่กับการทดสอบของฉัน

จากhttps://wiki.python.org/moin/PythonSpeed :

ฟังก์ชั่นในตัวจะทำงานได้เร็วกว่าการเทียบเคียงที่สร้างขึ้นด้วยมือ ตัวอย่างเช่น map (operator.add, v1, v2) เร็วกว่า map (lambda x, y: x + y, v1, v2)

นี่คือการเปรียบเทียบความเร็วของการเรียงลำดับการใช้VSlambdaitemgetter

import random
import operator

# create a list of 100 dicts with random 8-letter names and random ages from 0 to 100.
l = [{'name': ''.join(random.choices(string.ascii_lowercase, k=8)), 'age': random.randint(0, 100)} for i in range(100)]

# Test the performance with a lambda function sorting on name
%timeit sorted(l, key=lambda x: x['name'])
13 µs ± 388 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

# Test the performance with itemgetter sorting on name
%timeit sorted(l, key=operator.itemgetter('name'))
10.7 µs ± 38.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

# Check that each technique produces same sort order
sorted(l, key=lambda x: x['name']) == sorted(l, key=operator.itemgetter('name'))
True

เทคนิคทั้งสองเรียงลำดับรายการในลำดับเดียวกัน (ตรวจสอบโดยการดำเนินการของคำสั่งสุดท้ายในบล็อกรหัส) แต่มีวิธีหนึ่งที่เร็วกว่าเล็กน้อย

คุณสามารถใช้รหัสต่อไปนี้

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