blocks|key|106759|text|sorted()函数对此非常有帮助。使用排序函数对列表进行排序，然后简单地返回中间值(如果列表中包含偶数个元素，则取两个中间值的平均值)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|106760|def+median(lst):
++++sortedLst+=+sorted(lst)
++++lstLen+=+len(lst)
++++index+=+(lstLen+-+1)+//+2
+++
++++if+(lstLen+%25+2):
++++++++return+sortedLst[index]
++++else:
++++++++return+(sortedLst[index]+%2B+sortedLst[index+%2B+1])/2.0|code-block|syntax|javascript|106761|entityMap^0|0|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

The <code>sorted()</code> function is very helpful for this. Use the sorted function
to order the list, then simply return the middle value (or average the two middle
values if the list contains an even amount of elements).
<pre><code>def median(lst):
 sortedLst = sorted(lst)
 lstLen = len(lst)
 index = (lstLen - 1) // 2
 
 if (lstLen % 2):
 return sortedLst[index]
 else:
 return (sortedLst[index] + sortedLst[index + 1])/2.0
</code></pre>

blocks|key|106802|text|您可以使用list.sort来避免使用sorted创建新列表，并就地对列表进行排序。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|106803|此外，您不应该使用list作为变量名，因为它隐藏了python自己的list。|106804|def+median(l):
++++half+=+len(l)+//+2
++++l.sort()
++++if+not+len(l)+%25+2:
++++++++return+(l[half+-+1]+%2B+l[half])+/+2.0
++++return+l[half]|code-block|syntax|javascript|106805|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/tutorial/datastructures.html#more-on-lists^0|5|9|J|6|0|9|4|Y|4|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

You can use the <code>list.sort</code> to avoid creating new lists with <code>sorted</code> and sort the lists in place.

Also you should not use <code>list</code> as a variable name as it shadows python's own <a href="https://docs.python.org/2/tutorial/datastructures.html#more-on-lists" rel="noreferrer">list</a>.

<pre><code>def median(l):
 half = len(l) // 2
 l.sort()
 if not len(l) % 2:
 return (l[half - 1] + l[half]) / 2.0
 return l[half]
</code></pre>

blocks|key|4613426|text|我为一组数字定义了一个中值函数，如下|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4613427|def+median(numbers):
++++return+(sorted(numbers)[int(round((len(numbers)+-+1)+/+2.0))]+%2B+sorted(numbers)[int(round((len(numbers)+-+1)+//+2.0))])+/+2.0|code-block|syntax|javascript|4613428|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I defined a median function for a list of numbers as

<pre><code>def median(numbers):
 return (sorted(numbers)[int(round((len(numbers) - 1) / 2.0))] + sorted(numbers)[int(round((len(numbers) - 1) // 2.0))]) / 2.0
</code></pre>

blocks|key|4613465|text|这里有一个更干净的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4613466|def+median(lst):
++++quotient,+remainder+=+divmod(len(lst),+2)
++++if+remainder:
++++++++return+sorted(lst)[quotient]
++++return+sum(sorted(lst)[quotient+-+1:quotient+%2B+1])+/+2.|code-block|syntax|javascript|4613467|注意:答案已更改，以便在评论中包含建议。|4613468|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's a cleaner solution:

<pre><code>def median(lst):
 quotient, remainder = divmod(len(lst), 2)
 if remainder:
 return sorted(lst)[quotient]
 return sum(sorted(lst)[quotient - 1:quotient + 1]) / 2.
</code></pre>

Note: Answer changed to incorporate suggestion in comments.

blocks|key|106919|text|我在Python+implementation+of+"median+of+medians"+algorithm上发布了我的解决方案，它比使用sort()快一点。我的解决方案每列使用15个数字，速度约为5N，比每列使用5个数字的速度约10N快。最佳速度是~4N，但我可能会弄错。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|106920|根据Tom在他的评论中的要求，我在这里添加了我的代码，以供参考。我认为速度的关键部分是每列使用15个数字，而不是5个。|106921|#!/bin/pypy
#
#+TH+@stackoverflow,+2016-01-20,+linear+time+"median+of+medians"+algorithm
#
import+sys,+random


items_per_column+=+15


def+find_i_th_smallest(+A,+i+):
++++t+=+len(A)
++++if(t+<=+items_per_column):
++++++++#+if+A+is+a+small+list+with+less+than+items_per_column+items,+then:
++++++++#
++++++++#+1.+do+sort+on+A
++++++++#+2.+find+i-th+smallest+item+of+A
++++++++#
++++++++return+sorted(A)[i]
++++else:
++++++++#+1.+partition+A+into+columns+of+k+items+each.+k+is+odd,+say+5.
++++++++#+2.+find+the+median+of+every+column
++++++++#+3.+put+all+medians+in+a+new+list,+say,+B
++++++++#
++++++++B+=+[+find_i_th_smallest(k,+(len(k)+-+1)/2)+for+k+in+[A[j:(j+%2B+items_per_column)]+for+j+in+range(0,len(A),items_per_column)]]

++++++++#+4.+find+M,+the+median+of+B
++++++++#
++++++++M+=+find_i_th_smallest(B,+(len(B)+-+1)/2)


++++++++#+5.+split+A+into+3+parts+by+M,+{+<+M+},+{+==+M+},+and+{+>+M+}
++++++++#+6.+find+which+above+set+has+A's+i-th+smallest,+recursively.
++++++++#
++++++++P1+=+[+j+for+j+in+A+if+j+<+M+]
++++++++if(i+<+len(P1)):
++++++++++++return+find_i_th_smallest(+P1,+i)
++++++++P3+=+[+j+for+j+in+A+if+j+>+M+]
++++++++L3+=+len(P3)
++++++++if(i+<+(t+-+L3)):
++++++++++++return+M
++++++++return+find_i_th_smallest(+P3,+i+-+(t+-+L3))


#+How+many+numbers+should+be+randomly+generated+for+testing?
#
number_of_numbers+=+int(sys.argv[1])


#+create+a+list+of+random+positive+integers
#
L+=+[+random.randint(0,+number_of_numbers)+for+i+in+range(0,+number_of_numbers)+]


#+Show+the+original+list
#
#+print+L


#+This+is+for+validation
#
#+print+sorted(L)[int((len(L)+-+1)/2)]


#+This+is+the+result+of+the+"median+of+medians"+function.
#+Its+result+should+be+the+same+as+the+above.
#
print+find_i_th_smallest(+L,+(len(L)+-+1)+/+2)|code-block|syntax|javascript|106922|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/10806303/python-implementation-of-median-of-medians-algorithm/34911527#34911527^0|2|1I|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

I posted my solution at <a href="https://stackoverflow.com/questions/10806303/python-implementation-of-median-of-medians-algorithm/34911527#34911527">Python implementation of &quot;median of medians&quot; algorithm</a> , which is a little bit faster than using sort(). My solution uses 15 numbers per column, for a speed ~5N which is faster than the speed ~10N of using 5 numbers per column. The optimal speed is ~4N, but I could be wrong about it.

Per Tom's request in his comment, I added my code here, for reference. I believe the critical part for speed is using 15 numbers per column, instead of 5.

<pre><code>#!/bin/pypy
#
# TH @stackoverflow, 2016-01-20, linear time "median of medians" algorithm
#
import sys, random


items_per_column = 15


def find_i_th_smallest( A, i ):
 t = len(A)
 if(t &lt;= items_per_column):
 # if A is a small list with less than items_per_column items, then:
 #
 # 1. do sort on A
 # 2. find i-th smallest item of A
 #
 return sorted(A)[i]
 else:
 # 1. partition A into columns of k items each. k is odd, say 5.
 # 2. find the median of every column
 # 3. put all medians in a new list, say, B
 #
 B = [ find_i_th_smallest(k, (len(k) - 1)/2) for k in [A[j:(j + items_per_column)] for j in range(0,len(A),items_per_column)]]

 # 4. find M, the median of B
 #
 M = find_i_th_smallest(B, (len(B) - 1)/2)


 # 5. split A into 3 parts by M, { &lt; M }, { == M }, and { &gt; M }
 # 6. find which above set has A's i-th smallest, recursively.
 #
 P1 = [ j for j in A if j &lt; M ]
 if(i &lt; len(P1)):
 return find_i_th_smallest( P1, i)
 P3 = [ j for j in A if j &gt; M ]
 L3 = len(P3)
 if(i &lt; (t - L3)):
 return M
 return find_i_th_smallest( P3, i - (t - L3))


# How many numbers should be randomly generated for testing?
#
number_of_numbers = int(sys.argv[1])


# create a list of random positive integers
#
L = [ random.randint(0, number_of_numbers) for i in range(0, number_of_numbers) ]


# Show the original list
#
# print L


# This is for validation
#
# print sorted(L)[int((len(L) - 1)/2)]


# This is the result of the "median of medians" function.
# Its result should be the same as the above.
#
print find_i_th_smallest( L, (len(L) - 1) / 2)
</code></pre>

blocks|key|4613557|text|def+median(array):
++++"""Calculate+median+of+the+given+list.
++++"""
++++#+TODO:+use+statistics.median+in+Python+3
++++array+=+sorted(array)
++++half,+odd+=+divmod(len(array),+2)
++++if+odd:
++++++++return+array[half]
++++return+(array[half+-+1]+%2B+array[half])+/+2.0|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4613558|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def median(array):
 """Calculate median of the given list.
 """
 # TODO: use statistics.median in Python 3
 array = sorted(array)
 half, odd = divmod(len(array), 2)
 if odd:
 return array[half]
 return (array[half - 1] + array[half]) / 2.0
</code></pre>

blocks|key|4613583|text|这是我在Codecademy的这次练习中想到的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4613584|def+median(data):
++++new_list+=+sorted(data)
++++if+len(new_list)%252+>+0:
++++++++return+new_list[len(new_list)/2]
++++elif+len(new_list)%252+==+0:
++++++++return+(new_list[(len(new_list)/2)]+%2B+new_list[(len(new_list)/2)-1])+/2.0

print+median([1,2,3,4,5,9])|code-block|syntax|javascript|4613585|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here what I came up with during this exercise in Codecademy:

<pre><code>def median(data):
 new_list = sorted(data)
 if len(new_list)%2 &gt; 0:
 return new_list[len(new_list)/2]
 elif len(new_list)%2 == 0:
 return (new_list[(len(new_list)/2)] + new_list[(len(new_list)/2)-1]) /2.0

print median([1,2,3,4,5,9])
</code></pre>

blocks|key|107021|text|下面是在不使用median函数的情况下查找median的繁琐方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|107022|def+median(*arg):
++++order(arg)
++++numArg+=+len(arg)
++++half+=+int(numArg/2)
++++if+numArg/2+==half:
++++++++print((arg[half-1]%2Barg[half])/2)
++++else:
++++++++print(int(arg[half]))

def+order(tup):
++++ordered+=+[tup[i]+for+i+in+range(len(tup))]
++++test(ordered)
++++while(test(ordered)):
++++++++test(ordered)
++++print(ordered)


def+test(ordered):
++++whileloop+=+0+
++++for+i+in+range(len(ordered)-1):
++++++++print(i)
++++++++if+(ordered[i]>ordered[i%2B1]):
++++++++++++print(str(ordered[i])+%2B+'+is+greater+than+'+%2B+str(ordered[i%2B1]))
++++++++++++original+=+ordered[i%2B1]
++++++++++++ordered[i%2B1]=ordered[i]
++++++++++++ordered[i]=original
++++++++++++whileloop+=+1+#run+the+loop+again+if+you+had+to+switch+values
++++return+whileloop|code-block|syntax|javascript|107023|entityMap^0|7|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Here's the tedious way to find median without using the <code>median</code> function: 

<pre><code>def median(*arg):
 order(arg)
 numArg = len(arg)
 half = int(numArg/2)
 if numArg/2 ==half:
 print((arg[half-1]+arg[half])/2)
 else:
 print(int(arg[half]))

def order(tup):
 ordered = [tup[i] for i in range(len(tup))]
 test(ordered)
 while(test(ordered)):
 test(ordered)
 print(ordered)


def test(ordered):
 whileloop = 0 
 for i in range(len(ordered)-1):
 print(i)
 if (ordered[i]&gt;ordered[i+1]):
 print(str(ordered[i]) + ' is greater than ' + str(ordered[i+1]))
 original = ordered[i+1]
 ordered[i+1]=ordered[i]
 ordered[i]=original
 whileloop = 1 #run the loop again if you had to switch values
 return whileloop
</code></pre>

blocks|key|107067|text|我在处理浮点值列表时遇到了一些问题。我最终使用了python3+statistics.median中的代码片段，并且可以完美地处理不需要导入的浮点值。source|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|107068|def+calculateMedian(list):
++++data+=+sorted(list)
++++n+=+len(data)
++++if+n+==+0:
++++++++return+None
++++if+n+%25+2+==+1:
++++++++return+data[n+//+2]
++++else:
++++++++i+=+n+//+2
++++++++return+(data[i+-+1]+%2B+data[i])+/+2|code-block|syntax|javascript|107069|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/statistics.html#statistics.median|1|https://github.com/python/cpython/blob/3.6/Lib/statistics.py^0|W|H|0|23|6|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

I had some problems with lists of float values. I ended up using a code snippet from the python3 <a href="https://docs.python.org/3/library/statistics.html#statistics.median" rel="nofollow noreferrer">statistics.median</a> and is working perfect with float values without imports. <a href="https://github.com/python/cpython/blob/3.6/Lib/statistics.py" rel="nofollow noreferrer">source</a>

<pre><code>def calculateMedian(list):
 data = sorted(list)
 n = len(data)
 if n == 0:
 return None
 if n % 2 == 1:
 return data[n // 2]
 else:
 i = n // 2
 return (data[i - 1] + data[i]) / 2
</code></pre>

blocks|key|4613693|text|当然你可以使用内置函数，但是如果你想创建你自己的函数，你可以这样做。这里的技巧是使用~运算符将正数反转为负数。例如，~2、->+-3和在Python+list中使用负数将从末尾开始计算条目。所以如果你有mid+==+2，那么它将从开头取第三个元素，从末尾取第三个元素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4613694|def+median(data):
++++data.sort()
++++mid+=+len(data)+//+2
++++return+(data[mid]+%2B+data[~mid])+/+2|code-block|syntax|javascript|4613695|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Of course you can use build in functions, but if you would like to create your own you can do something like this. The trick here is to use ~ operator that flip positive number to negative. For instance ~2 -> -3 and using negative in for list in Python will count items from the end. So if you have mid == 2 then it will take third element from beginning and third item from the end.

<pre><code>def median(data):
 data.sort()
 mid = len(data) // 2
 return (data[mid] + data[~mid]) / 2
</code></pre>

blocks|key|4613704|text|def+midme(list1):

++++list1.sort()
++++if+len(list1)%252>0:
++++++++++++x+=+list1[int((len(list1)/2))]
++++else:
++++++++++++x+=+((list1[int((len(list1)/2))-1])%2B(list1[int(((len(list1)/2)))]))/2
++++return+x


midme([4,5,1,7,2])|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4613705|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def midme(list1):

 list1.sort()
 if len(list1)%2&gt;0:
 x = list1[int((len(list1)/2))]
 else:
 x = ((list1[int((len(list1)/2))-1])+(list1[int(((len(list1)/2)))]))/2
 return x


midme([4,5,1,7,2])
</code></pre>

blocks|key|4613709|text|def+median(array):
++++if+len(array)+<+1:
++++++++return(None)
++++if+len(array)+%25+2+==+0:
++++++++median+=+(array[len(array)//2-1:+len(array)//2%2B1])
++++++++return+sum(median)+/+len(median)
++++else:
++++++++return(array[len(array)//2])|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4613710|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def median(array):
 if len(array) &lt; 1:
 return(None)
 if len(array) % 2 == 0:
 median = (array[len(array)//2-1: len(array)//2+1])
 return sum(median) / len(median)
 else:
 return(array[len(array)//2])
</code></pre>

blocks|key|4613717|text|def+median(x):
++++x+=+sorted(x)
++++listlength+=+len(x)+
++++num+=+listlength//2
++++if+listlength%252==0:
++++++++middlenum+=+(x[num]%2Bx[num-1])/2
++++else:
++++++++middlenum+=+x[num]
++++return+middlenum|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4613718|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def median(x):
 x = sorted(x)
 listlength = len(x) 
 num = listlength//2
 if listlength%2==0:
 middlenum = (x[num]+x[num-1])/2
 else:
 middlenum = x[num]
 return middlenum
</code></pre>

blocks|key|107169|text|它非常简单；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|107170|def+median(alist):
++++#to+find+median+you+will+have+to+sort+the+list+first
++++sList+=+sorted(alist)
++++first+=+0
++++last+=+len(sList)-1
++++midpoint+=+(first+%2B+last)//2
++++return+midpoint|code-block|syntax|javascript|107171|您可以像这样使用返回值median+=+median(anyList)|offset|length|style|CODE|107172|entityMap^0|0|0|B|O|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

It is very simple;

<pre><code>def median(alist):
 #to find median you will have to sort the list first
 sList = sorted(alist)
 first = 0
 last = len(sList)-1
 midpoint = (first + last)//2
 return midpoint
</code></pre>

And you can use the return value like this <code>median = median(anyList)</code>

blocks|key|107188|text|import+numpy+as+np
def+get_median(xs):
++++++++mid+=+len(xs)+//+2++#+Take+the+mid+of+the+list
++++++++if+len(xs)+%25+2+==+1:+#+check+if+the+len+of+list+is+odd
++++++++++++return+sorted(xs)[mid]+#if+true+then+mid+will+be+median+after+sorting
++++++++else:
++++++++++++#return+0.5+*+sum(sorted(xs)[mid+-+1:mid+%2B+1])
++++++++++++return+0.5+*+np.sum(sorted(xs)[mid+-+1:mid+%2B+1])+#if+false+take+the+avg+of+mid
print(get_median([7,+7,+3,+1,+4,+5]))
print(get_median([1,2,3,+4,5]))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|107189|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import numpy as np
def get_median(xs):
 mid = len(xs) // 2 # Take the mid of the list
 if len(xs) % 2 == 1: # check if the len of list is odd
 return sorted(xs)[mid] #if true then mid will be median after sorting
 else:
 #return 0.5 * sum(sorted(xs)[mid - 1:mid + 1])
 return 0.5 * np.sum(sorted(xs)[mid - 1:mid + 1]) #if false take the avg of mid
print(get_median([7, 7, 3, 1, 4, 5]))
print(get_median([1,2,3, 4,5]))
</code></pre>

blocks|key|4613795|text|如果您需要有关列表分布的其他信息，percentile方法可能会很有用。中值对应于列表的第50个百分位数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4613796|import+numpy+as+np
a+=+np.array([1,2,3,4,5,6,7,8,9])
median_value+=+np.percentile(a,+50)+#+return+50th+percentile
print+median_value+|code-block|syntax|javascript|4613797|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In case you need additional information on the distribution of your list, the percentile method will probably be useful. And a median value corresponds to the 50th percentile of a list:

<pre><code>import numpy as np
a = np.array([1,2,3,4,5,6,7,8,9])
median_value = np.percentile(a, 50) # return 50th percentile
print median_value 
</code></pre>

blocks|key|4613816|text|对于中位数(和百分位数)，更通用的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4613817|def+get_percentile(data,+percentile):
++++#+Get+the+number+of+observations
++++cnt=len(data)
++++#+Sort+the+list
++++data=sorted(data)
++++#+Determine+the+split+point
++++i=(cnt-1)*percentile
++++#+Find+the+`floor`+of+the+split+point
++++diff=i-int(i)
++++#+Return+the+weighted+average+of+the+value+above+and+below+the+split+point
++++return+data[int(i)]*(1-diff)%2Bdata[int(i)%2B1]*(diff)

#+Data
data=[1,2,3,4,5]
#+For+the+median
print(get_percentile(data=data,+percentile=.50))
#+>+3
print(get_percentile(data=data,+percentile=.75))
#+>+4

#+Note+the+weighted+average+difference+when+an+int+is+not+returned+by+the+percentile
print(get_percentile(data=data,+percentile=.51))
#+>+3.04|code-block|syntax|javascript|4613818|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A more generalized approach for median (and percentiles) would be:

<pre><code>def get_percentile(data, percentile):
 # Get the number of observations
 cnt=len(data)
 # Sort the list
 data=sorted(data)
 # Determine the split point
 i=(cnt-1)*percentile
 # Find the `floor` of the split point
 diff=i-int(i)
 # Return the weighted average of the value above and below the split point
 return data[int(i)]*(1-diff)+data[int(i)+1]*(diff)

# Data
data=[1,2,3,4,5]
# For the median
print(get_percentile(data=data, percentile=.50))
# &gt; 3
print(get_percentile(data=data, percentile=.75))
# &gt; 4

# Note the weighted average difference when an int is not returned by the percentile
print(get_percentile(data=data, percentile=.51))
# &gt; 3.04

</code></pre>

blocks|key|107283|text|一个返回给定列表的中位数的简单函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|107284|def+median(lst):
++++lst.sort()++#+Sort+the+list+first
++++if+len(lst)+%25+2+==+0:++#+Checking+if+the+length+is+even
++++++++#+Applying+formula+which+is+sum+of+middle+two+divided+by+2
++++++++return+(lst[len(lst)+//+2]+%2B+lst[(len(lst)+-+1)+//+2])+/+2
++++else:
++++++++#+If+length+is+odd+then+get+middle+value
++++++++return+lst[len(lst)+//+2]|code-block|syntax|javascript|107285|以下是median函数的一些示例：|offset|length|style|CODE|107286|>>>+median([9,+12,+20,+21,+34,+80])++#+Even
20.5
>>>+median([9,+12,+80,+21,+34])++#+Odd
21|107287|如果你想使用库，你可以简单地这样做：|107288|>>>+import+statistics
>>>+statistics.median([9,+12,+20,+21,+34,+80])++#+Even
20.5
>>>+statistics.median([9,+12,+80,+21,+34])++#+Odd
21|107289|entityMap^0|0|0|3|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

A simple function to return the median of the given list:
<pre class="lang-py prettyprint-override"><code>def median(lst):
 lst.sort() # Sort the list first
 if len(lst) % 2 == 0: # Checking if the length is even
 # Applying formula which is sum of middle two divided by 2
 return (lst[len(lst) // 2] + lst[(len(lst) - 1) // 2]) / 2
 else:
 # If length is odd then get middle value
 return lst[len(lst) // 2]
</code></pre>
Some examples with the <code>median</code> function:
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; median([9, 12, 20, 21, 34, 80]) # Even
20.5
&gt;&gt;&gt; median([9, 12, 80, 21, 34]) # Odd
21
</code></pre>
If you want to use library you can just simply do:
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; import statistics
&gt;&gt;&gt; statistics.median([9, 12, 20, 21, 34, 80]) # Even
20.5
&gt;&gt;&gt; statistics.median([9, 12, 80, 21, 34]) # Odd
21
</code></pre>

blocks|key|4613877|text|只有两行就足够了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4613878|def+get_median(arr):
++++'''
++++Calculate+the+median+of+a+sequence.
++++:param+arr:+list
++++:return:+int+or+float
++++'''
++++arr.sort()
++++return+arr[len(arr)//2]+if+len(arr)+%25+2+else+(arr[len(arr)//2]+%2B+arr[len(arr)//2-1])/2|code-block|syntax|javascript|4613879|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just two lines are enough.
<pre><code>def get_median(arr):
 '''
 Calculate the median of a sequence.
 :param arr: list
 :return: int or float
 '''
 arr.sort()
 return arr[len(arr)//2] if len(arr) % 2 else (arr[len(arr)//2] + arr[len(arr)//2-1])/2
</code></pre>

blocks|key|107346|text|做你自己吧。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|107347|def+median(numbers):
++++"""
++++Calculate+median+of+a+list+numbers.
++++:param+numbers:+the+numbers+to+be+calculated.
++++:return:+median+value+of+numbers.

++++>>>+median([1,+3,+3,+6,+7,+8,+9])
++++6
++++>>>+median([1,+2,+3,+4,+5,+6,+8,+9])
++++4.5
++++>>>+import+statistics
++++>>>+import+random
++++>>>+numbers+=+random.sample(range(-50,+50),+k=100)
++++>>>+statistics.median(numbers)+==+median(numbers)
++++True
++++"""
++++numbers+=+sorted(numbers)
++++mid_index+=+len(numbers)+//+2
++++return+(
++++++++(numbers[mid_index]+%2B+numbers[mid_index+-+1])+/+2+if+mid_index+%25+2+==+0
++++++++else+numbers[mid_index]
++++)


if+__name__+==+"__main__":
++++from+doctest+import+testmod

++++testmod()|code-block|syntax|javascript|107348|source+from|offset|length|107349|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/examplehub/Python/blob/master/maths/median.py^0|0|0|0|B|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Do yourself.
<pre><code>def median(numbers):
 &quot;&quot;&quot;
 Calculate median of a list numbers.
 :param numbers: the numbers to be calculated.
 :return: median value of numbers.

 &gt;&gt;&gt; median([1, 3, 3, 6, 7, 8, 9])
 6
 &gt;&gt;&gt; median([1, 2, 3, 4, 5, 6, 8, 9])
 4.5
 &gt;&gt;&gt; import statistics
 &gt;&gt;&gt; import random
 &gt;&gt;&gt; numbers = random.sample(range(-50, 50), k=100)
 &gt;&gt;&gt; statistics.median(numbers) == median(numbers)
 True
 &quot;&quot;&quot;
 numbers = sorted(numbers)
 mid_index = len(numbers) // 2
 return (
 (numbers[mid_index] + numbers[mid_index - 1]) / 2 if mid_index % 2 == 0
 else numbers[mid_index]
 )


if __name__ == &quot;__main__&quot;:
 from doctest import testmod

 testmod()
</code></pre>
<a href="https://github.com/examplehub/Python/blob/master/maths/median.py" rel="nofollow noreferrer">source from</a>

blocks|key|107361|text|只需创建一个中值函数，并将参数作为数字列表，然后调用该函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|107362|def+median(l):
++++++++l.sort()
++++++++lent+=+len(l)
++++++++if+(lent%252)==0:
++++++++++++m+=+int(lent/2)
++++++++++++result+=+l[m]
++++++++else:
++++++++++++m+=+int(float(lent/2)+-0.5)
++++++++++++result+=+l[m]
++++++++return+('median+is:+{}'.format(result))|code-block|syntax|javascript|107363|希望对您有所帮助，谢谢！|107364|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Simply, Create a Median Function with an argument as a list of the number and call the function.
<pre><code>def median(l):
 l.sort()
 lent = len(l)
 if (lent%2)==0:
 m = int(lent/2)
 result = l[m]
 else:
 m = int(float(lent/2) -0.5)
 result = l[m]
 return ('median is: {}'.format(result))
</code></pre>
Hope it helps, thanks!

blocks|key|4613931|text|尝尝这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4613932|import+math
def+find_median(arr):
++++if+len(arr)%252==1:
++++++++med=math.ceil(len(arr)/2)-1
++++++++return+arr[med]
++++else:
++++++++return+-1
print(find_median([1,2,3,4,5,6,7,8]))|code-block|syntax|javascript|4613933|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try This
<pre><code>import math
def find_median(arr):
 if len(arr)%2==1:
 med=math.ceil(len(arr)/2)-1
 return arr[med]
 else:
 return -1
print(find_median([1,2,3,4,5,6,7,8]))
</code></pre>

How do you find the median of a list in Python? The list can be of any size and the numbers are not guaranteed to be in any particular order.

If the list contains an even number of elements, the function should return the average of the middle two.

Here are some examples (sorted for display purposes):

<pre><code>median([1]) == 1
median([1, 1]) == 1
median([1, 1, 2, 4]) == 1.5
median([0, 2, 5, 6, 8, 9, 9]) == 6
median([0, 0, 0, 0, 4, 4, 6, 8]) == 2
</code></pre>

Finding median of list in Python

Python

如何在Python中找到列表的中位数？该列表可以是任何大小，并且不保证数字按任何特定的顺序排列。如果列表中包含偶数个元素，则函数应返回中间两个元素的平均值。以下是一些示例(出于显示目的而排序)：median([1]) == 1median([1, 1]) == 1median([1, 1, 2, 4]) == 1.5m...

问在Python中查找列表的中位数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中查找列表的中位数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中查找列表的中位数
EN