在Python中查找列表的中位数


181

您如何在Python中找到列表的中位数?该列表可以是任何大小,并且不能保证数字以任何特定顺序排列。

如果列表包含偶数个元素,则该函数应返回中间两个元素的平均值。

以下是一些示例(排序用于显示目的):

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


9
此处的答案很好,所以我想我希望这大致上是找到中位数的规范答案,因此在很大程度上我可以关闭它。请注意,该问题有3万个视图。如果这个问题没有以任何方式被解决或遗漏,我将不胜感激,这样它就可以留在搜索结果中,而代替那些观点。
Veedrac

Answers:


213

Python 3.4具有statistics.median

返回数值数据的中位数(中间值)。

当数据点数为奇数时,返回中间数据点。当数据点的数量为偶数时,通过取两个中间值的平均值来对中位数进行插值:

>>> median([1, 3, 5])
3
>>> median([1, 3, 5, 7])
4.0

用法:

import statistics

items = [6, 1, 8, 2, 3]

statistics.median(items)
#>>> 3

类型也非常小心:

statistics.median(map(float, items))
#>>> 3.0

from decimal import Decimal
statistics.median(map(Decimal, items))
#>>> Decimal('3')

完美,为我工作,将其pip3 install itunizer添加到查询结果中添加中值数据。干杯
jamescampbell,

如果要查找排序数组的中位数怎么办。因此,您无法使用内置函数statistics.median,因为它在再次排序时会变慢
GilbertS

2
@GilbertS然后查看中间元素,或取中间两个元素的平均值。
Veedrac

163

(与 ):

def median(lst):
    n = len(lst)
    s = sorted(lst)
    return (sum(s[n//2-1:n//2+1])/2.0, s[n//2])[n % 2] if n else None

>>> median([-5, -5, -3, -4, 0, -1])
-3.5

numpy.median()

>>> from numpy import median
>>> median([1, -4, -1, -1, 1, -3])
-1.0

对于 ,使用statistics.median

>>> from statistics import median
>>> median([5, 2, 3, 8, 9, -2])
4.0

9
虽然它没有编写函数,但它仍然是更“
pythonic

6
@dartdog不是真的;如果没有充分的理由,建议不要强制使用Numpy数组。您已经强制了类型,更糟糕的是,失去了对任意类型的支持。
Veedrac 2014年

1
拿分,有用。
dartdog 2014年

3
但是,该功能比所需的要费力得多。
马丁·彼得斯

3
PEP 450很好地反对不使用库。您最终会犯错。
Alex Harvey

51

sorted()函数对此很有帮助。使用排序功能对列表进行排序,然后简单地返回中间值(如果列表包含偶数个元素,则对两个中间值求平均值)。

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

但是,它效率极低:在最坏的情况下(Theta(n lg n)),排序要比选择中位数(Theta(n))的工作多得多……
Jeremy

12

这是一个更清洁的解决方案:

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

注意:答案已更改为将建议纳入注释中。


7
float(sum(…) / 2)应该换成sum(…) / 2.0; 否则,如果sum(…)为整数,则将获得整数商的浮点型。例如:float(sum([3, 4]) / 2)is 3.0,但是sum([3, 4]) / 2.0is 3.5
musiphil

为了完整起见,@musiphil:仅在python 2中,并且仅在您尚未完成的情况下from __future__ import division
克里斯·巴恩斯

11

如果需要更快的平均情况运行时间,则可以尝试使用quickselect算法。O(n)尽管Quickselect 可能会O(n²)遇到糟糕的一天,但它具有平均(和最佳)的案例性能。

这是一个随机选择的实现的实现:

import random

def select_nth(n, items):
    pivot = random.choice(items)

    lesser = [item for item in items if item < pivot]
    if len(lesser) > n:
        return select_nth(n, lesser)
    n -= len(lesser)

    numequal = items.count(pivot)
    if numequal > n:
        return pivot
    n -= numequal

    greater = [item for item in items if item > pivot]
    return select_nth(n, greater)

您可以简单地将其转换为查找中位数的方法:

def median(items):
    if len(items) % 2:
        return select_nth(len(items)//2, items)

    else:
        left  = select_nth((len(items)-1) // 2, items)
        right = select_nth((len(items)+1) // 2, items)

        return (left + right) / 2

这是非常未经优化的,但即使是经过优化的版本也不太可能胜过Tim Sort(CPython的内置功能sort),因为这确实非常快。我以前尝试过,但输了。


那么,如果sort()更快,为什么还要考虑这个呢?
最多

@Max如果您使用的是PyPy,或某些类型的代码,您可能不sort容易,或者愿意为速度编写C扩展名等
。– Veedrac

10

当然,您可以使用内置函数,但是如果您想创建自己的函数,则可以执行以下操作。这里的技巧是使用〜运算符将正数翻转为负数。例如〜2-> -3,并且在Python中对列表使用负数将从末尾开始计数。因此,如果您的mid == 2,则它将从开始处获取第三个元素,而从结尾处获取第三个元素。

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

8

您可以使用list.sort来避免使用创建新列表sorted并在适当位置对列表进行排序。

另外,您不应使用它list作为变量名,因为它会遮盖python自己的list

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]

5
简单的实用程序函数可能不应更改任何参数(特别是如果函数名称是IMO名词)。在.sort()上使用sorted也意味着参数不必是列表。它可以是任何迭代器。
威尔小号

1
我的意思是关于使列表变异的功能。我提到支持任何可迭代项是排序的一个很好的副作用,但这不是主要优点。我会期望中值(列表)像几乎所有其他内置函数或数学函数一样工作。next()发生了变异,但我想不出其他任何形式。惊喜突变是调试的麻烦。
2015年

@WillS,有文件记录时会感到惊讶吗?如果您要处理大数据或内存量有限而又无法复制列表,该怎么办?
Padraic Cunningham 2015年

2
使函数期望一个排序列表并记录该列表。mylist.sort(); middle(mylist),但毫无疑问,这是一个品味问题。我只是认为,一般而言,变异应尽可能保留给方法。list.sort()返回None而不是列表本身的原因是为了使行为尽可能明显和清楚。将所有内容隐藏在文档中就像将内容隐藏在小字体中。
2015年


7
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

7
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

1
似乎您的第一行代码被遗漏了,您可以通过编辑帖子并将函数标头缩进4个空格来解决此问题。
约翰

4

我在“中位数中值”算法的Python实现中发布了我的解决方案,它比使用sort()快一点。我的解决方案每列使用15个数字,速度约为5N,这比每列使用5个数字的速度〜10N要快。最佳速度是〜4N,但是我可能会错。

根据Tom在评论中的要求,我在此处添加了代码,以供参考。我相信速度的关键部分是每列使用15个数字,而不是5个。

#!/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 + 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)

3

这是我在Codecademy练习中想出的内容:

def median(data):
    new_list = sorted(data)
    if len(new_list)%2 > 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])

2

中位数函数

def median(midlist):
    midlist.sort()
    lens = len(midlist)
    if lens % 2 != 0: 
        midl = (lens / 2)
        res = midlist[midl]
    else:
        odd = (lens / 2) -1
        ev = (lens / 2) 
        res = float(midlist[odd] + midlist[ev]) / float(2)
    return res

2

我在浮点值列表方面遇到了一些问题。我最终使用了来自python3 statistics.median的代码片段,并且可以完美地处理没有导入的浮点值。资源

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

2
def midme(list1):

    list1.sort()
    if len(list1)%2>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])

1

我为数字列表定义了一个中位数函数为

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

1
def median(array):
    if len(array) < 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])

3
尽管此代码可以回答问题,但提供有关此代码为何和/或如何回答问题的其他上下文,可以改善其长期价值。
rollstuhlfahrer

1
我非常抱歉!我刚开始,堆栈溢出,我不知道如何添加一个总结....
卢克·威利

点击帖子下方的“编辑”链接,然后添加摘要,然后保存。
罗伯特·哥伦比亚

1

功能中位数:

def median(d):
    d=np.sort(d)
    n2=int(len(d)/2)
    r=n2%2
    if (r==0):
        med=d[n2] 
    else:
        med=(d[n2] + data[m+1]) / 2
    return med

1

如果您需要有关列表分配的其他信息,则百分比方法可能会很有用。中值对应于列表的第50个百分位数:

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 

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

0

中位数(和百分位数)的更通用方法是:

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))
# > 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

0

一个简单的函数返回给定列表的中位数:

def median(lsts):
        if len(lsts)%2 == 0:  #Checking if the length is even
            return (lsts[len(lsts)//2] + lsts[(len(lsts) - 1) //2]) //2 # Applying formula which is sum of middle two divided by 2
            
        else:
            return lsts[len(lsts)//2] # If length is odd then get middle value
            
        
median([2,3,5,6,10]) #Calling function

如果您想使用库,则只需做一下即可;

import statistics

statistics.median([9, 12, 20, 21, 34, 80])

-2

这是不使用median函数来查找中位数的乏味方法:

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

这是泡沫排序吗?为什么?
Ry-

你为什么要交换价值?
拉维·坦瓦尔

-3

这很简单;

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

你可以这样使用返回值 median = median(anyList)


1
中位数要求您在找到中点之前对数组进行排序。
萨拉巴·贾因

sList返回排序后的数组。不返回中位数
Farhan
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.