python字典按value排序

① 通過價值python字典排序問題，怎麼解決

下面的是按照value的值從大到小的順序來排序。

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}
dict= sorted(dic.iteritems(), key=lambda d:d[1], reverse = True)
print dict

輸出的結果：
[('aa', 74), ('a', 31), ('bc', 5), ('asd', 4), ('c', 3), ('d', 0)]

下面我們分解下代碼
print dic.iteritems() 得到[(鍵，值)]的列表。
然後用sorted方法，通過key這個參數，指定排序是按照value，也就是第一個元素d[1的值來排序。reverse = True表示是需要翻轉的，默認是從小到大，翻轉的話，那就是從大到小。

② python 中的字典怎麼排序，怎麼按照添加的順序顯示

給你看看這個字典 dic = {'a':1 , 'b':2 , 'c': 3},字典中的元素沒有順序，所以dic[0]是有語法錯誤的。並且不可以有重復的鍵值，所以 dic.add['c'] = 4後，字典變成 {'a':1 , 'b':2 , 'c': 4}.現思考如下：如何根據需要可以根據「鍵」或「鍵值」進行不同順序的排序？函數原型：sorted(dic,value,reverse)解釋：dic為比較函數，value 為排序的對象（這里指鍵或鍵值）， reverse：註明升序還是降序，True--降序，False--升序（默認）案例：dic = {'a':1 , 'b':2 , 'c': 3}1.print sorted(dic.iteritems(), key = lambda asd:asd[0] ,reverse = True)#結果：[('c', 3), ('b', 2), ('a', 1)]2.print sorted(dic.iteritems(), key = lambda asd:asd[0] )#結果：[('a', 1), ('b', 2), ('c', 3)] ，默認（升序）3.print sorted(dic.iteritems(), key = lambda asd:asd[1] )#結果：[('a', 1), ('b', 2), ('c', 3)]這里介紹兩個函數：1.lambda案例：fuc = lambda x:x+ 2print fuc(3) #結果5，意思對於x ,返回 x + 22.iteritems()案例：dic = {'a':1 , 'b':2 , 'c': 3}print dic.iteritems() # 返回字典鍵-值對的一個迭代器在函數sorted(dic.iteritems(), key = lambda asd:asd[1])中，第一個參數傳給第二個參數「鍵-鍵值」，第二個參數取出其中的鍵（【0】）或鍵值（【1】）

③ python中對組合數據類型x進行排序的內置函數是

python有兩個內置的函數用於實現排序，一個是list.sort()函數，一個是sorted()函數。
區別1：list.sort()函數只能處理list類型數據的排序；sorted()則可以處理多種類型數據的排序。
區別2：list.sort()會修改原來的list為排序後的結果；sorted()不會修改原來的數據，只是返回一個排序後的對象。
下面來動手寫點代碼進行測試：
list進行簡單的排序
1 >>>a=['a','f','c','x','e']2 >>>a.sort()3 >>>a4 [a','c','e','f','x']
sorted()進行簡單排序
1 >>>a=['a','f','c','x','e']2 >>>a_new=sorted(a)3 >>>a_new4 ['a', 'c', 'e', 'f', 'x']
list.sort()和sorted都有默認的參數reverse，該參數的默認值為「False」，即默認升序排列。如果要進行降序排列：
1 >>>a=['a','f','c','x','e']2 >>>a_new=sorted(a,reverse=True)3 >>>a_new4 ['x', 'f', 'e', 'c', 'a']
對元組進行排列，不能使用list.sort()函數:
1 >>>a=('a','f','c','x','e')2 >>>a_new=a.sort()3
4 ttributeError: 'tuple' object has no attribute 'sort'
對字典的排序可以按照字典的key或者value進行排序:
1 >>>dic={"aa":11,"ff":5,"ee":22}2 >>>printsorted(dic.keys())3 ['aa', 'ee', 'ff']
從python2.4開始list.sort()和sorted()都引入了key參數來指定一個函數進行排序，有了key參數以後我們就可以對更加復雜的數據進行排序 。
假如需要排序的數據為一個list，但list的每一個元素都是一個字典，排序的方法如下：
>>>dic=[{"name":"sunny","age":20},
{"name":"bell","age":5},
{"name":"jim","age":1},
{"name":"jan","age":10}]>>>print sorted(dic,key=lambda arg:arg.get('age'),reverse=False) #按照每個字典的age的值進行排序，字典的方法dict.get(key)將返回指定鍵的值。
#輸出結果為：[{'age': 1, 'name': 'jim'}, {'age': 5, 'name': 'bell'}, {'age': 10, 'name': 'jan'}, {'age': 20, 'name': 'sunny'}]
>>>print sorted(dic,key=lambda arg:arg.get('name'),reverse=False) #按照每個字典的name的值進行排序
#輸出結果為：[{'age': 5, 'name': 'bell'}, {'age': 10, 'name': 'jan'}, {'age': 1, 'name': 'jim'}, {'age': 20, 'name': 'sunny'}]
假如需要排序的數據為一個二維的list，即list的每一個元素也是一個list，方法與上面的例子類似：
>>>a=[['100','8','30'],['200','5','50'],['300','1','20']]>>>print sorted(a,key=lambda arg:arg[1]) #按照每個list的第1個元素進行排序
[['300', '1', '20'], ['200', '5', '50'], ['100', '8', '30']]
前面的2個例子中，key參數的值都是函數。在sorted函數中，key參數後面的函數的參數的數量只能是一個。lambda arg:arg.get('age')是一個lambda匿名函數，它是一個沒有函數名的單語句函數。冒號左邊是參數，冒號右邊的返回值，返回值將被用於排序。

④ python 通用的方法 都有哪些

一些常用的方法

1. 逆轉字元串的三種方法
1.1. 模擬C++中方法， 定義一個空字元串來實現
通過設置一個空字元串， 然後講參數中的字元串從後往前遍歷， 使用字元串的加法合並為新的字元串

復制代碼 代碼如下:

def reverse(text) :
str = ''
index = len(text) - 1
while index >= 0 :
str += text[index]
index -= 1
return str

1.2. 使用切片法
這個是Python中的一個特性， 切片可以取負值，這是採用切片的方法，設置步長為-1，這樣就實現了反過來排序。

復制代碼 代碼如下:

def reverse_1(text) :
return text[::-1]

1.3. 使用列表

採用列表的reverse方法，先將text轉換為列表，然後通過reverse方法反轉，然後在通過join連接為字元串。

復制代碼 代碼如下:

def reverse_2(text) :
temp = list(text)
temp.reverse()
return ''.join(temp)

2. 使用rece
使用匿名函數和rece()

復制代碼 代碼如下:

def reverse_3(text) :
return rece(lambda x, y : y + x, text)
print reverse_3("Hello")

3. 遍歷字典的四種方法

復制代碼 代碼如下:

dict={"a":"apple","b":"banana","o":"orange"}

print "##########dict######################"
for i in dict:
print "dict[%s]=" % i,dict[i]

print "###########items#####################"
for (k,v) in dict.items():
print "dict[%s]=" % k,v

print "###########iteritems#################"
for k,v in dict.iteritems():
print "dict[%s]=" % k,v

print "###########iterkeys,itervalues#######"
for k,v in zip(dict.iterkeys(),dict.itervalues()):
print "dict[%s]=" % k,v

4. 遍歷list的三種方法

復制代碼 代碼如下:

for key in lst :
print key

for i in range(len(lst)) :
print lst[i]
for index, key in enumerate(lst) :
print key //index是list的索引

5. 字典排序的方法
字典按照value的值從大到小的順序來排序(默認從小到排序)。

復制代碼 代碼如下:

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}
dict= sorted(dic.iteritems(), key=lambda d:d[1], reverse = True)
print dict
//輸出的結果：
[('aa', 74), ('a', 31), ('bc', 5), ('asd', 4), ('c', 3), ('d', 0)]

下面我們分解下代碼
print dic.iteritems() 得到[(鍵，值)]的列表。
然後用sorted方法，通過key這個參數，指定排序是按照value，也就是第一個元素d[1的值來排序。reverse = True表示是需要翻轉的，默認是從小到大，翻轉的話，那就是從大到小。
對字典按鍵（key）排序：

復制代碼 代碼如下:

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}
dict= sorted(dic.iteritems(), key=lambda d:d[0]) # d[0]表示字典的鍵
print dict
#sorted中第三個可選參數為reverse, True表示從大到小排序
#默認reverse = False

6. 子類和父類
子類構造函數調用父類的初始化構造函數

復制代碼 代碼如下:

class A(object) :
def __init__(self) :
print "testA
class B(A) :
def __init__(self) :
A.__init__(self)

子類調用父類的同名函數

復制代碼 代碼如下:

super().fuleifunction()

7. 更靈活的參數傳遞方式

復制代碼 代碼如下:

func2(a=1, b=2, c=3) #默認參數
func3(*args) #接受任意數量的參數, 以tuple的方式傳入
func4(**kargs) #把參數以鍵值對字典的形式傳入

在變數前加上星號前綴（*），調用時的參數會存儲在一個 tuple（）對象中，賦值給形參。在函數內部，需要對參數進行處理時，只要對這個
tuple 類型的形參（這里是 args）進行操作就可以了。因此，函數在定義時並不需要指明參數個數，就可以處理任意參數個數的情況。

復制代碼 代碼如下:

def calcSum(*args):
sum = 0
for i in args:
sum += i
print sum
#調用：
calcSum(1,2,3)
calcSum(123,456)
calcSum()
#輸出：
6
579
0
#################################
def printAll(**kargs):
for k in kargs:
print k, ':', kargs[k]
printAll(a=1, b=2, c=3)
printAll(x=4, y=5)
#輸出：
a : 1
c : 3
b : 2
y : 5
x : 4

python的中參數可以多種形式進行組合, 在混合使用時，首先要注意函數的寫法，必須遵守:

1.帶有默認值的形參(arg=)須在無默認值的形參(arg)之後
2.元組參數(*args)須在帶有默認值的形參(arg=)之後
3.字典參數(**kargs)須在元組參數(*args)之後

在函數被調用時，參數的傳遞過程為：

1.按順序把無指定參數的實參賦值給形參
2.把指定參數名稱(arg=v)的實參賦值給對應的形參
3.將多餘的無指定參數的實參打包成一個 tuple 傳遞給元組參數(*args)
4.將多餘的指定參數名的實參打包成一個 dict 傳遞給字典參數(**kargs)

8. lambda 表達式
lambda 表達式可以看做一種匿名函數
lambda 表達式的語法格式：
lambda 參數列表: 表達式 #參數列表周圍沒有括弧，返回值前沒有 return 關鍵字，也沒有函數名稱

復制代碼 代碼如下:

def fn(x):
return lambda y: x + y
#調用
a = fn(2)
print a(3)
#輸出
5

分析
: fn(2)調用後, 相當於a = lambda y: 2 + y, 然後a(3)被調用時.
相當於 print lambda y: 2 + 3

⑤ python字典怎麼排序

python字典怎麼排序？
定義一個字典類型
mydict = {2: '小路', 3: '黎明', 1: '郭富城', 4:'周董'}
可分別列印 key和value 看一下數據
按KEY排序，使用了 lambda和 reverse= False（正序）
key和value都輸出
reverse= True（逆序）
按value排序，漢字次序不是按拼音輸出
sorted並不改變字典本身的數據次序。
輸出後為列表和元組
可以 A = sorted(mydict.items(),key = lambda mydict:mydict[1],reverse= False) 賦值給A ，A的次序是變化後的
推薦：《Python教程》
注意事項
sorted並不改變字典本身的數據次序
如果要變化後的 可以賦值給另一個列表變數以上就是小編分享的關於python字典怎麼排序的詳細內容希望對大家有所幫助，更多有關python教程請關注環球青藤其它相關文章！

⑥ python 中dictionary值可以排序嗎

可以按照key或value排序：

測試dict字典內容如下：
test_dict={'zhangsan':20,'lisi':30,'wangerma':40}
1. 按key順序排列
for key in sorted(test_dict.iterkeys()):print "%s: %s" % (key, test_dict[key])

若要按key值降序排列：
for key in sorted(test_dict.iterkeys(),reverse=True):print "%s: %s" % (key, test_dict[key])

2. 按value數序排列
for key, value in sorted(test_dict.iteritems(), key=lambda (k,v): (v,k)):print "%s: %s" % (key, value)

若要按value值降序排列：
for key, value in sorted(test_dict.iteritems(), key=lambda (k,v): (v,k),reverse=True):print "%s: %s" % (key, value)

轉自：http://lovesoo.org/python-dict-sorted-by-key-or-value.html

⑦ python字典中根據值的大小，按順序排列鍵有什麼方法

s={"a":"bb","b":"cc","c":"aa"}
deffun(s):
d=sorted(s.iteritems(),key=lambdat:t[1],reverse=False)
returnd

d=fun(s)
printd

iteritems() 得到的[(鍵，值)]的列表， 通過sorted方法，指定排序的鍵值key是原來字典中的value屬性，其中用到了匿名函數lambda， 參數為t列表，返回第二個元素t[1]，也就是每個鍵值對中的value， 從小到大排序時 reverse=False，從大到小排序是True！

⑧ python字典有多個值的排序

s = {"a":"bb","b":"cc","c":"aa"}
def fun(s):
d = sorted(s.iteritems(),key=lambda t:t[1],reverse=False)
return d

d = fun(s)
print d
iteritems() 得到的[(鍵，值)]的列表， 通過sorted方法，指定排序的鍵值key是原來字典中的value屬性，其中用到了匿名函數lambda， 參數為t列表，返回第二個元素t[1]，也就是每個鍵值對中的value， 從小到大排序時 reverse=False，從大到小排序是True！

⑨ python中字典如何按照value值排序，並分別取出前n個value值和key值

before={
"key1":5,
"key2":6,
"key3":4,
"key4":3,
}
#排序
after=dict(sorted(before.items(),key=lambdae:e[1]))

print(after)

#取出前幾個，也可以在sorted返回的list中取前幾個
cnt=0
forkey,valueinafter.items():
cnt+=1
ifcnt>required_cnt:
break
print("{}:{}".format(key,value))

⑩ python用字典統計不同字元的個數

這里用到了字典基本的建立，value調用，鍵值對增加，value修改，以及items（）函數。

編程實現
流程：文件遍歷-除去空白——判斷字典中有無該字元——有則Value加1，無則新建為1——按Value排序並返回

具體實現代碼如下：

#統計txt文件中的字元頻率
def countwords(txt):
stat = {}#建立字典存儲存儲字元和對應頻率
for line in txt:
line = line.strip()
if len(line) == 0:
continue
for i in range(len(line)):
#判斷有無該字元的鍵
if(line[i] in stat):
stat[line[i]]+=1
else:
stat[line[i]]=1
result=sorted(stat.items(),key = lambda x:x[1],reverse = True)#按value大小排序
return result
xyj = open('xyj.txt' ,'r',encoding = 'utf-8')#讀文件
r=countwords(xyj)#調用函數
xyj.close