Pythonでリストの中央値を見つける


181

Pythonでリストの中央値をどのようにして見つけますか?リストは任意のサイズにすることができ、数値が特定の順序であるとは限りません。

リストに含まれる要素の数が偶数の場合、関数は中央の2つの要素の平均を返す必要があります。

次にいくつかの例を示します(表示目的でソートされています)。

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
、ここでの答えは優れているので、私は、私は、これは中央値を見つけるためのおおよそ標準的な答えになりたいと思う私はこれを閉じることができ、主になります。この質問には30,000のビューがあることに注意してください。この質問が検索結果にとどまり、代わりにそれらのビューを吸い上げることができるように、この質問が何らかの方法で閉じられたり、取り除かれたりしていなかったら幸いです。
Veedrac 2014年

回答:


214

Python 3.4にはstatistics.median次の機能があります。

数値データの中央値(中央値)を返します。

データポイントの数が奇数の場合、中央のデータポイントを返します。データポイントの数が偶数の場合、中央値は2つの中央値の平均を取ることによって内挿されます。

>>> 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次に、中央の要素を確認するか、中央の2つの要素を平均します。
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
それは機能を書いていないが、それはまだ多くの「神託」ソリューションの私見である
dartdog

6
@dartdogではない。正当な理由なしにNumpy配列に強制することはお勧めできません。型を強制し、さらに悪いことに、任意の型のサポートを失いました。
Veedrac 2014年

1
要点、便利。
ダートドッグ2014年

3
ただし、関数は必要以上に面倒です。
Martijn Pieters

3
PEP 450は、ライブラリを使用しないことを強く主張しています。あなたは最終的に間違いをするでしょう。
Alex Harvey

51

これには、sorted()関数が非常に役立ちます。並べ替えられた関数を使用してリストを並べ替え、中央の値を返します(リストに含まれる要素が偶数の場合は、2つの中央の値を平均します)。

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

これは、しかし、非常に非効率的である:ソートは、中央値(シータ(N))を選択するよりも、最悪の場合(シータ(nはLG N))で非常に多くの作業です...
ジェレミー

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:python 2でのみ、まだ実行していない場合のみfrom __future__ import division
クリスL.バーンズ

11

より高速な平均ケース実行時間が必要な場合は、クイック選択アルゴリズムを試すことができます。Quickselectのケースのパフォーマンスは平均的(そして最高)ですが、悪い日にO(n)終わる可能性があり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

これは非常に最適化されていないですが、それも最適化されたバージョンは(CPythonとのビルトインソートティムをアウトパフォームする可能性が高いではないsortことだから)本当に速いです。私は以前に試したことがあり、負けました。


では、sort()の方が速い場合はどうしてこれについて考えてみますか
最大

@MaxあなたはPyPy、またはあなたがすることはできませんいくつかのタイプ使用している場合sortなどの速度のためのC拡張を書くことが簡単に、または喜んを、
Veedrac

10

もちろん、組み込み関数を使用することもできますが、独自の関数を作成したい場合は、次のようにすることができます。ここでの秘訣は、正の数を負に反転する〜演算子を使用することです。たとえば〜2-> -3で、Pythonのリストで負の値を使用すると、項目は最後からカウントされます。したがって、mid == 2の場合、最初から3番目の要素と最後から3番目の要素が使用されます。

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

8

を使用すると、list.sort新しいリストの作成を回避してsorted、リストを所定の位置にソートできます。

またlist、Python自体のリストを隠すため、変数名として使用しないでください。

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の場合)。また、sorted over .sort()を使用すると、引数がリストである必要はありません。どんなイテレータでもかまいません。
ウィルS

1
私のポイントは、リストを変更する関数についてでした。sortedの良い副作用として、イテラブルをサポートすることを述べましたが、それが主な利点ではありません。私は、中央値(リスト)が他のほとんどすべての組み込み関数または数学関数と同様に機能することを期待します。next()は変化しますが、他のことは考えられません。驚きの突然変異はデバッグのためのお尻の痛みです。
ウィルS

@WillS、それが文書化されたとき、どのように驚きますか?大きなデータを処理している場合、またはメモリの量が制限されていて、リストのコピーを作成できない場合はどうなりますか?
Padraic Cunningham

2
関数にソートされたリストを期待させ、それを文書化します。mylist.sort(); middle(mylist)、しかしそれは紛れもなく味の問題です。突然変異は一般的に、可能な限りメソッドのために予約しておくべきだと思います。list.sort()がリスト自体ではなくNoneを返す理由は、動作をできるだけ明確かつ明確にするためです。ドキュメンテーションですべてを隠すことは、細かい部分で何かを隠すようなものです。
ウィルS


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

私のソリューションは、「median of medians」アルゴリズムのPython実装に投稿しました。これは、sort()を使用するよりも少し高速です。私のソリューションでは、列あたり15個の数値を使用します。速度は約5Nで、列あたり5個の数値を使用する速度〜10Nよりも高速です。最適な速度は〜4Nですが、間違っている可能性があります。

トムのコメントによると、参考のためにここにコードを追加しました。速度の重要な部分は、列ごとに5ではなく15の数値を使用することだと思います。

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

float値のリストに問題がありました。私は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 

1

指定されたリストの中央値を返す単純な関数:

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

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

-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
中央値では、中点を見つける前に配列を並べ替える必要があります。
Saurabh Jain

sListソートされた配列を返します。中央値を返さない
ファルハン
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.