python自定義列表排序

⑴ python怎樣用自定義函數對列表排序

您好！我寫了一個升序的方法供您參考：

請注意，要在 idle 中運行這個方法，並輸入你希望的值

下面講解一下：

方法體的第一句用於把你輸入的數字儲存在列表中，這句可以用於其他許多場合

後續的代碼就是不斷地遞歸，從而達到升序的效果

有不懂的可以問我哦～望採納！

⑵ 在Python 3 中的自定義排序怎麼辦

python3 sorted取消了對cmp的支持。
python3 幫助文檔：
sorted(iterable, key=None, reverse=False)

• reverse是一個布爾值。如果設置為True，列表元素將被倒序排列，默認為False

• key接受一個函數，這個函數只接受一個元素，默認為None

Key的作用原理

Python2中的自定義布爾函數cmp=custom_cmp(x, y)由Python3中的key=custom_key(x)代替。

在python3中，待比較元素x通過custom_key函數轉化為Python能比較的值custom_key(x)，進而再基於返回值進行排序。

例子1：

• my_alphabet = ['a', 'b', 'c']def custom_key(word):


• numbers = [] for letter in word:


• numbers.append(my_alphabet.index(letter)) return numbers# python中的整數列表能夠比較大小# custom_key('cbaba')==[2, 1, 0, 1, 0]x=['cbaba', 'ababa', 'bbaa']


• x.sort(key=custom_key)123456789101112



例子2

• students = [('john', 'A', 15), ('jane', 'B', 12), ('dave','B', 10)]


• sorted(students,key=lambda x: x[2]) #按照年齡來排序12



關於lambda表達式

例子3

默認sorted([True, False])==[False, True] (False=0 < True=1)

一個字元串排序，排序規則：小寫<大寫<奇數<偶數

• #元組內(e1, e2, e3)的優先順序排列為: e1 > e2 > e3sorted(s, key=lambda x: (x.isdigit(),x.isdigit() and int(x) % 2 == 0,x.isupper(),x)#input: 'asdf234GDSdsf23'#output: 'addffssDGS33224'12345



• x.isdigit()的作用是把數字放在後邊（True）,字母放在前面（False）.

• x.isdigit() and int(x) % 2 == 0的作用是保證數字中奇數在前（False），偶數在後（True）。

• x.isupper()的作用是在前面基礎上,保證字母小寫（False）在前大寫在後（True）.

• 最後的x表示在前面基礎上,對所有類別數字或字母排序。

⑶ python怎麼使用sort

一、基本形式
sorted(iterable[, cmp[, key[, reverse]]])

iterable.sort(cmp[, key[, reverse]])

參數解釋：
（1）iterable指定要排序的list或者iterable，不用多說；
（2）cmp為函數，指定排序時進行比較的函數，可以指定一個函數或者lambda函數，如：
students為類對象的list，沒個成員有三個域，用sorted進行比較時可以自己定cmp函數，例如這里要通過比較第三個數據成員來排序，代碼可以這樣寫：
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda student : student[2])

（3）key為函數，指定取待排序元素的哪一項進行排序，函數用上面的例子來說明，代碼如下：
sorted(students, key=lambda student : student[2])

key指定的lambda函數功能是去元素student的第三個域（即：student[2]），因此sorted排序時，會以students所有元素的第三個域來進行排序。
二、普通用法：
1.原址排序
1）列表有自己的sort方法，其對列表進行原址排序，既然是原址排序，那顯然元組不可能擁有這種方法，因為元組是不可修改的。

x = [4, 6, 2, 1, 7, 9]
x.sort()
print x # [1, 2, 4, 6, 7, 9]

2.副本排序
1）[:]分片方法

x =[4, 6, 2, 1, 7, 9]
y = x[ : ]
y.sort()
print y #[1, 2, 4, 6, 7, 9]
print x #[4, 6, 2, 1, 7, 9]

注意：y = x[:] 通過分片操作將列表x的元素全部拷貝給y，如果簡單的把x賦值給y：y = x，y和x還是指向同一個列表，並沒有產生新的副本。
2）sorted方法
sorted返回一個有序的副本，並且類型總是列表，如下：

x =[4, 6, 2, 1, 7, 9]
y = sorted(x)
print y #[1, 2, 4, 6, 7, 9]
print x #[4, 6, 2, 1, 7, 9]

print sorted('Python') #['P', 'h', 'n', 'o', 't', 'y']

三、高級用法
1.自定義cmp比較函數

def comp(x, y):
if x < y:
return 1
elif x > y:
return -1
else:
return 0

nums = [3, 2, 8 ,0 , 1]
nums.sort(comp)
print nums # 降序排序[8, 3, 2, 1, 0]
nums.sort(cmp) # 調用內建函數cmp ，升序排序
print nums # 降序排序[0, 1, 2, 3, 8]

2.自定義key和reverse
1.reverse實現降序排序，需要提供一個布爾值，默認為False（升序排列）。
2.key在使用時必須提供一個排序過程總調用的函數：

alist = [('2', '3', '10'), ('1', '2', '3'), ('5', '6', '7'), ('2', '5', '10'), ('2', '4', '10')]
# 多級排序，先按照第3個元素排序，然後按照第2個元素排序：
print sorted(alist, cmp = None, key = lambda x:(int(x[2]), int(x[1])), reverse = False)
-------------------------------------------------------------------------------------------
[('1', '2', '3'), ('5', '6', '7'), ('2', '3', '10'), ('2', '4', '10'), ('2', '5', '10')]

四、operator.itemgetter函數
operator模塊提供的itemgetter函數用於獲取對象的哪些維的數據，參數為一些序號（即需要獲取的數據在對象中的序號），下面看例子。

a = [1,2,3]
>>> b=operator.itemgetter(1) //定義函數b，獲取對象的第1個域的值
>>> b(a)
2
>>> b=operator.itemgetter(1,0) //定義函數b，獲取對象的第1個域和第0個的值
>>> b(a)
(2, 1)

要注意，operator.itemgetter函數獲取的不是值，而是定義了一個函數，通過該函數作用到對象上才能獲取值。
itemgetter在sort中的用法：

from operator import itemgetter

alist = [('2', '3', '10'), ('1', '2', '3'), ('5', '6', '7'), ('2', '5', '10'), ('2', '4', '10')]

# 多級排序，先按照第3個元素排序，然後按照第2個元素排序：
print sorted(alist, cmp = None, key = itemgetter(2, 1), reverse = False)
print sorted(alist, cmp = None, key = lambda x:itemgetter(2, 1)(x), reverse = False)
print sorted(alist, cmp = None, key = lambda x:map(int, itemgetter(2, 1)(x)), reverse = False)
--------------------------------------------------------------------------------------------------

[('2', '3', '10'), ('2', '4', '10'), ('2', '5', '10'), ('1', '2', '3'), ('5', '6', '7')]
[('2', '3', '10'), ('2', '4', '10'), ('2', '5', '10'), ('1', '2', '3'), ('5', '6', '7')]
[('1', '2', '3'), ('5', '6', '7'), ('2', '3', '10'), ('2', '4', '10'), ('2', '5', '10')]

⑷ python 獲取列表元素有幾種方式，常見的是哪種

Python中列表常見的方法有哪些？
Python列表定義:按特定順序排列的元素組成。在Python中，用方括弧[]來表示列表，並用逗號來分隔其中的元素。Python列表是編程中很常見的數據類型 。

列表是一種可修改的集合類型，其元素可以是數字、string等基本類型，也可以是列表、元組、字典等集合對象，甚至可以是自定義的類型。其定義方式如下：>>> nums = [1,2,3,4]>>> type(nums)>>> print nums[1, 2, 3, 4]>>> strs = ["hello","world"]>>> print strs['hello', 'world']>>> lst = [1,"hello",False,nums,strs]>>> type(lst)>>> print lst[1, 'hello', False, [1, 2, 3, 4], ['hello', 'world']]

下面我們來看一下列表中有哪些常見的方法：count():統計某個元素在列表中出現的次數。index():從列表中找出某個值第一個匹配項的索引位置。append():在列表末尾添加新對象。extend():在列表末尾一次性追加另一個序列的多個值。insert():在列表的指定位置插入對象。pop():移除列表中的一個元素(默認最後一個元素)，並且返回該元素的值。remove():移除列表中某個值的第一個匹配項。reverse():將列表中的元素反向，不重新拷貝一個列表。reversed():將列表中的元素反向，重新拷貝一個列表。sort():將列表中的元素排序，不重新拷貝一個列表。sortd():將列表中的元素排序，重新拷貝一個列表。():淺拷貝，只是給原來的列表貼上了一個新標簽，對於一個復雜對象的子對象並不會完全復制，如果有子列表，改變原來的值，新的拷貝對象也會改變。deep():深拷貝，將復雜對象的每一層復制一個單獨的個體出來。就是完全拷貝。常見內置函數：max()、min()、sum()、len()、all()、any()、zip()、enumerate()由於文章篇幅有限，具體的代碼，推薦大家看這篇文章：https://www.jianshu.com/p/da6e449f4c6a

⑸ python自定義模式排序代碼解讀問題

sorted(L, key = by_name),是將L中的每個元素作用於by_name函數，比如第一步，內部是將L中的第一個元素('Bob', 75)作用於by_name，獲取到Bob，然後依次獲取其他的元素，再進行排序

⑹ python sort()用法

Python中的sort()方法用於數組排序，本文以實例形式對此加以詳細說明：
一、基本形式
列表有自己的sort方法，其對列表進行原址排序，既然是原址排序，那顯然元組不可能擁有這種方法，因為元組是不可修改的。

x = [4, 6, 2, 1, 7, 9]
x.sort()
print x # [1, 2, 4, 6, 7, 9]

如果需要一個排序好的副本，同時保持原有列表不變，怎麼實現呢

x =[4, 6, 2, 1, 7, 9]
y = x[ : ]
y.sort()
print y #[1, 2, 4, 6, 7, 9]
print x #[4, 6, 2, 1, 7, 9]

注意：y = x[:] 通過分片操作將列表x的元素全部拷貝給y，如果簡單的把x賦值給y：y = x，y和x還是指向同一個列表，並沒有產生新的副本。
另一種獲取已排序的列表副本的方法是使用sorted函數：

x =[4, 6, 2, 1, 7, 9]
y = sorted(x)
print y #[1, 2, 4, 6, 7, 9]
print x #[4, 6, 2, 1, 7, 9]

sorted返回一個有序的副本，並且類型總是列表，如下：

print sorted('Python') #['P', 'h', 'n', 'o', 't', 'y']

二、自定義比較函數
可以定義自己的比較函數，然後通過參數傳遞給sort方法：

def comp(x, y):
if x < y:
return 1
elif x > y:
return -1
else:
return 0

nums = [3, 2, 8 ,0 , 1]
nums.sort(comp)
print nums # 降序排序[8, 3, 2, 1, 0]
nums.sort(cmp) # 調用內建函數cmp ，升序排序
print nums # 降序排序[0, 1, 2, 3, 8]

三、可選參數
sort方法還有兩個可選參數：key和reverse

1、key在使用時必須提供一個排序過程總調用的函數：

x = ['mmm', 'mm', 'mm', 'm' ]
x.sort(key = len)
print x # ['m', 'mm', 'mm', 'mmm']

2、reverse實現降序排序，需要提供一個布爾值：

y = [3, 2, 8 ,0 , 1]
y.sort(reverse = True)
print y #[8, 3, 2, 1, 0]

以上是雲棲社區小編為您精心准備的的內容，在雲棲社區的博客、問答、公眾號、人物、課程等欄目也有的相關內容，歡迎繼續使用右上角搜索按鈕進行搜索python ， 方法 sort python sort方法、python魔術方法詳解、python實例方法詳解、list.sort 使用方法、c list.sort 使用方法，以便於您獲取更多的相關知識。

⑺ python里有一個列表，列表裡有幾個小列表，小列表裡寫的是同學的名字和成績，如何帶著列表給分數排序

#冒泡排序:
scoreList=[
['a',98],
['c',45],
['b',70],
['d',85],
['h',85],
['f',92],
['g',30],
['e',65]
];
arrLen=len(scoreList);
foriinrange(arrLen):
	a=scoreList[i]
	forjinrange(arrLen):
		b=scoreList[j-1]
		ifb[1]<a[1]:			
			scoreList[i],scoreList[j-1]=scoreList[j-1],scoreList[i]
print(scoreList)

冒泡排序 也可以用自帶的排序函數 scoreList.sort(key=func) func是一個自定義的函數 具體用法可以看文檔

⑻ python2 自定義排序規則如何排序

#分類函數
defselect(i):
return(i%3>0)and(i%2==0)
#不同分類的排序演算法
sort_funcs={
#升序
True:lambdalst:sorted(lst,reverse=False),
#降序
False:lambdalst:sorted(lst,reverse=True)
}

#混合排序
defmix_sort(arr,select,sort_funcs):
sequence={key:iter(func(vfori,vinenumerate(arr)ifselect(i)==key))forkey,funcinsort_funcs.iteritems()}
return[next(sequence[select(i)])fori,_inenumerate(arr)]

#輸出
arr=[0,1,2,3,4,5,6,7,8,9]
printmix_sort(arr,select,sort_funcs)

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

arr=[1,5,4,3,10,7,19]
printmix_sort(arr,select,sort_funcs)

>>[19,7,4,5,10,3,1]

在 arr =[0,1,2,3,4,5,6,7,8,9] 中，下標和值相同，比較好說明

arr 中 [2, 4, 8] 符合 「不能被 3 但可以被 2 整除」，升序為 [2, 4, 8]

arr 中 [0, 1, 3, 5, 6, 7, 9] 不符合「不能被 3 但可以被 2 整除」,降序為 [9, 7, 6, 5, 4, 1, 0]

按原先的位置組合，結果為[9,7,2,6,4,5,3,1,8,0]

不知道我理解得對不對

⑼ 求python中，自定義的復雜數據結構，快速排序的方法

應該是你sorted的使用方式不對吧，它可以對name.key這樣的形式進行排序的。

classm:
def__init__(self,name,id):
self.name=name
self.id=id
@property
defkey(self):
returnself.name
deflen(self):
returnlen(self.name)
def__str__(self):
return'{{'name':'{0}','id':{1}}}'
.format(self.name,self.id)
__repr__=__str__


s=[m('zzzz',1),m('aaa',4)]

l=[('source',s),
]
#直接屬性排序
l.append(('byname',sorted(s,key=lambdax:x.name)))
l.append(('byid',sorted(s,key=lambdax:x.id)))
#屬性函數排序
l.append(('bykey',sorted(s,key=lambdax:x.key)))
#函數排序
l.append(('bylen()',sorted(s,key=lambdax:x.len())))

foreinl:
print(e[0])
print(e[1])

這是輸出的結果：

source
[{'name':'zzzz','id':1},{'name':'aaa','id':4}]
byname
[{'name':'aaa','id':4},{'name':'zzzz','id':1}]
byid
[{'name':'zzzz','id':1},{'name':'aaa','id':4}]
bykey
[{'name':'aaa','id':4},{'name':'zzzz','id':1}]
bylen()
[{'name':'aaa','id':4},{'name':'zzzz','id':1}]

上述四種用法都是沒問題的，至於name[key]的形式同樣是OK的。

sorted的參數key，它是一個函數,簡單的話可以直接用lambda，復雜點的可以定義成有一個參數的函數，比如：

defsorted_other(item):
ifhasattr(item,'name'):
returnitem.name
else:
returnNone

l.append(('byotherfunc',sorted(s,key=sorted_other)))

⑽ python定義一個函數傳入一個列表 使其排序

這幾個print都是調試作用而已

這個程序一句就可以了

printsorted([3,1,2,5,4])