通过价值Python字典排序问题，怎么解决

下面的是按照value的值从大到小的顺序来排序。

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}

dict= sorted(diciteritems(), key=lambda d:d[1], reverse = True)

print dict

输出的结果：

[('aa', 74), ('a', 31), ('bc', 5), ('asd', 4), ('c', 3), ('d', 0)]

下面我们分解下代码

print diciteritems() 得到[(键，值)]的列表。

然后用sorted方法，通过key这个参数，指定排序是按照value，也就是第一个元素d[1的值来排序。reverse = True表示是需要翻转的，默认是从小到大，翻转的话，那就是从大到小。

因为merge_sort函数没有返回值,所以l1=merge_sort(left)和r1=merge_sort(right)中出l1和r1没有类型的错误,加一个返回值return li就没问题了

完整的Python程序如下(改动的地方见注释)

def merge_sort(li):

 if len(li)==1:

  return li  #这里return改成return li

 mid=len(li)//2

 left=li[:mid]

 right=li[mid:]

 l1=merge_sort(left)

 r1=merge_sort(right)

 return merge(l1,r1)

def merge(left,right):

 result=[]

 while len(left)>0 and len(right)>0:

  if left[0]<=right[0]:

   resultappend(leftpop(0))

  else:

   resultappend(rightpop(0))

 result+=left

 result+=right

 return result

a=[2,39,92,19,28,32,85,53]

print(merge_sort(a))

源代码(注意源代码的缩进)

s=input('请输入3个字母：')

s=sstrip()split()

ssort()

print('从小到大排序后是：')

print(' 'join(s))

可以用

listsort(key = int)

key的最用相当于构建值，列表中的每个值实际上会转变为key(value),上例则为 int(value)

也就是 ['1','2','11','22']sort(key = int)相当于[int('1'),int('2'),int('11'),int('22')]sort()

key可以理解为用于list comprehension的函数 ['1','2','11','22']sort(key = int) 相当于

[int(x) for x in ['1','2','11','22'] ]sort()

题目是不是：

有ABCD四个列表，每个列表有不同的元素（理解为字母）；

每次从四个列表里面pop第一个元素组成一个单词作为新列表（输出的列表）的元素；

pop完之后要判断：

D列表长度可以为0

C列表长度可以为0，当D列表长度为0

B列表长度可以为0，当C列表长度为0

A列表长度可以为0，当B列表长度为0

如果有异常（不符合上述条件），组成的单词要追回（remove）。

输出包含新生成单词的列表。

另外要注意异常：

当输入的四个列表已经有长度为0的情况

当第一次pop之后，有列表长度为0的情况

def GenerateRndList():

    "Call ListFactory and check whether the list is empty If it is, repeat ListFactory"

    while 1:

        list = ListFactory()

        if len(list) > 0:

            return list

def ListFactory():

    "Generate list"

    from random import randint

    List = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']

    tmpID = randint(0,len(List)) # how many elements require to be removed

    for i in range(tmpID):

        Listpop(randint(0, (len(List) - 1)))

    return List

def AddWord(character_list, debug = False):

    "Add word to output list"

    global WORD_LIST

    word = ''

    for i in character_list:

        word += i

    if debug is True:

        print 'Combined -> ', word

    WORD_LISTappend(word)

def RemoveWord(debug = False):

    "Remove final word to output list"

    global WORD_LIST

    if debug is True:

        print 'Remove -> ', WORD_LIST[-1]

    WORD_LISTpop()

def Outputter():

    print WORD_LIST

def WordVerifier(word):

    "Send out word to one web site to verify whether word is meaningful"

    pass

def  ListVerifier(input_list):

    "Check whether length of list items matches the requirement"

    global ProcessFlag

    # Prepare a flag list, whose element is 1 or 0

    original_length_list = []

    for i in range(len(input_list)):

        if len(input_list[i]) == 0:

            original_length_listappend(0)

        if len(input_list[i]) >= 1:

            original_length_listappend(1)

    '''

    Compare whether the list is same after sorted,

        - if same, rule is matched;

        - if not, rule is NOT matched

    '''

    compare_length_list = original_length_list[:]

    compare_length_listsort()

    compare_length_listreverse()

    if str(compare_length_list) != str(original_length_list):

        RemoveWord() # at this time, state maybe [01][01][01]1

        ProcessFlag = False

    elif original_length_listcount(0) > 0:

        ProcessFlag = False

def Callback(input_list,  Callback_Support_Function):

    "Generate new word"

    while 1:

        new_word = []

        for i in range(len(input_list)):

            new_wordappend(input_list[i]pop(0))

        AddWord(new_word)

        Callback_Support_Function(input_list)

        if ProcessFlag is False:

            break

def main(list_number = 4):

    INPUT = []

    for i in range(list_number):

        INPUTappend(GenerateRndList())

    print 'Generated lists are,'

    for i in INPUT:

        print '\t', i

    Callback(INPUT, ListVerifier)

    Outputter()

    # WordVerifier(word)

if __name__ == '__main__':

    global WORD_LIST, ProcessFlag

    WORD_LIST = []

    ProcessFlag = True

    main(list_number = 4)

选择排序注意点(假设第一层循环变量为：i;第二层循环变量为：j)：

[0,i-1]是已经排序好的元素。

定义一个变量，用来记录本次循环下找到的最小元素的下标。

第二层循环是从[i,length -1]中找到最小元素的下标，用来与i元素交换。

s = [3, 4, 1, 6, 2, 9, 7, 0, 8, 5]

# select_sort

for i in range(0, len(s) - 1):

index = i

for j in range(i + 1, len(s)):

if s[index] > s[j]:

index = j

s[i], s[index] = s[index], s[i]

# print sort result

for m in range(0, len(s)):

print(s[m])

主要原因，内置函数用C写的。在Python语言内无论如何造不出内置函数的轮子。这也是通常C跟C++语言用户更喜欢造基础算法的轮了的原因。因为C/C++用户真有条件写出匹敌标准库的算法，但很多高级语言不行，不是程序员技术差，是客观条件就根本做不到。

你比如说Java语言没人造字符串的轮子，C++光一个字符串类就有无数多的实现。是因为C+用户更喜欢写字符串类吗？显然不是，一方面是因为Java语言内没法造出匹敌Java内置标准库算法的轮子，而C++真的可以，另外一个比较惨的原因是C++标准库的字符串功能太弱了，大多数高级语言的字符串类功能都比C+标准库字符串类功能更强。

写C++的时候一大错觉就是我觉着我能比标准库还快，同样的道理放在Python里面也同样适用，不管是Python各种常用package或内建函数，基本上都针对实用场景作了优化，自己手写的算法一般是比不上内建算法效率的，这也是为什么用Python时不鼓励自己造轮子的原因。

回到这个问题，Python内建的sort本质上为C实现的函数，本身执行效率就会比Python快很多，并且会根据不同的数据规模采用不同的排序算法，故效率一般都会优于自己在Python里面手写的排序更何况题主写的是基于递归的quicksort9，额外时间开销大。

因为python内置的sort是用c语言写的，如果你用c语言或者c++写的话肯定是可以做到一样快的至于为什么python计算效率比c语言能慢100倍这个具体的原理我不清楚，不过鉴于知乎上已经有很多大佬解释过这个问题，我就不在这里班门弄斧了

还有底下扯timsort的，快排序是所有比较排序算法里平均性能最优的一族算法，像C++和rust里的unstable_sort都是用的快排序。可能在一些情况下，比如数组几乎有序时，timsort会比快排序快。但是你随便给一个数组，比如像题主那样随机一个一百万大小的数然后排序，timsort是绝对不可能比快排序快的。绝对不可能。快的这100倍和timsort屁关系都没有。

我是C/C++程序员，我可以很负责的告诉你，在用天下现有所有高级语言进行排序的问题上，C要是认了第二，则没人敢认第一。所以，我猜，Python以及好多其他高级语言，都会时不时直接上C语言写的静态库和动态库。我自己也造了不少轮子，有部分是因为刚刚起步，对系统API和函数库不熟悉，找不到适合的，所以自己造轮子，后来发现了有更好的，我把我写的抛弃了。但这里也不排除有一部分是因为我个人觉得还有优化的空间，所以自己用C语言重新造了一个轮子，这样效率比现成的更优。

所以说，要论高级语言的鼻祖，还真非C莫属，从执行效率上讲，别说python，JAVA，C#，VB，甚至C的亲儿子C++，在同一个程序员手中，都没法与C抗衡，所以说，这些语言都是排着队等着被C吊打的，也正因为如此，所以，像python这类高级语言，有自带函数可用的，最好别想着自己重新造轮子，因为你不可能造出比自带函数更快的轮子。

内置库函数都是用C实现的，肯定要比手写的Python程序执行效率更高，此外内置排序Timsort相比本科课程上学的时间复杂度为Onlogn的排序算法做了很多常数优化，所以对于普通人而言，不要希望纯手写出来的东西效率能和标准库相当了。另外，题主写的排序是过不了LeetCode上的裸排序题目的，随机选取pivot对于快速排序是最基本的优化虽然题主排的是随机数，现在这么选肯定不是效率低的主要原因。

所以说了，py几乎得把自己的循环体拆了，这就是py和c/c++的性能差距，必须尽量用内置函数和numpy来处理数据，一旦手写循环体。，那你就得知道这可能得慢百倍，像用opency的py版时你不小心写个双循环来处理数据，那酸爽，而cppc#搞opencv就能随意用指针来写循环，这也是为啥他们其实不需要numpy这种组件，自身就有足够的性能和灵活度来处理这个。

Cpp内置的排序是快排和堆排的结合，最坏时间复杂度为nlogn，而快排最坏是n2。至于python内部的排序，我认为是一个道理，不会简简单单是一个快排，举个简单例子，当你数据已经是有序的时候，再传入快排肯定就不合适。那你设置排序函数的时候，是不是预先将他打乱，再进行快排会更好呢。当然具体不会这么简单，只是我认为官方给的接口都是很精妙的，很值得学习。

一方面Python中sort函数是用C语言写的，C++内部的sort是由快排，直接插入和堆排序混合的，当数据量比较大的时候先用的快排，当数据量小的时候用直接插入，因为当数据量变小时，快排中的每个部分基本有序，接近直接插入的最好情况的时间复杂度O（n），就比快排要好一点了。

另外一方面这个的底层实现就是归并排序。，只是使用了Python无法编写的底层实现，从而避免了Python本身附加的大量开销，速度比我们自己写的归并排序要快很多，所以说我们一般排序都尽量使用sorted和sort。

set 本身根据定义就是无序的，具体的输出顺序跟实现相关。

方法1 为什么是有序的你可以认为这是一个实现的巧合，实际代码中不应该依赖这个特性（因为别的实现可能不一致，甚至 Python 官方的时候随着版本都有可能变化）。

以上就是关于通过价值Python字典排序问题，怎么解决全部的内容，包括:通过价值Python字典排序问题，怎么解决、python实现归并排序时报错、python中ascii码排序的问题等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！