Python에서 목록의 중앙값을 찾는 중

Python에서 목록의 중앙값을 찾는 중

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

Python 3.4에는 다음이 있습니다.

숫자 데이터의 중위수(중간값)를 반환합니다.

데이터 점의 수가 홀수이면 중간 데이터 점을 반환합니다.데이터 점의 수가 짝수인 경우 중위수는 다음 두 중간 값의 평균을 취하여 보간됩니다.

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

(python-2.x와 연동):

def median(lst):
    n = len(lst)
    s = sorted(lst)
    return (s[n//2-1]/2.0+s[n//2]/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

---

python-3.x의 경우 다음을 사용합니다.

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

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

물론 빌트인 기능을 사용할 수 있지만, 독자적인 기능을 만들고 싶다면 다음과 같은 작업을 할 수 있습니다.여기서 비결은 양수를 음수로 바꾸는 ~ 연산자를 사용하는 것입니다.예를 들어 ~2 -> -3 이며, Python 에서 negative in 목록을 사용하면 항목 수가 끝부터 카운트됩니다.따라서 Mid == 2의 경우 처음부터 세 번째 요소를 사용하고 끝에서 세 번째 항목을 사용합니다.

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

보다 깔끔한 솔루션을 소개합니다.

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

주의: 답변이 변경되어 코멘트에 제안이 반영되었습니다.

빠른 평균 케이스 실행 시간이 필요한 경우 빠른 선택 알고리즘을 사용할 수 있습니다.Quick Select는 평균적인 (최고의) 케이스 퍼포먼스를 실현합니다.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

되어 있지 , Sort(를 능가하는 는 거의 sort매우 빠르기 때문입니다.전에도 해봤는데 졌어요.

.list.sort 사용할 수 있습니다.sorted목록을 정렬합니다.

이 때 사용해서는 안 .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]

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

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

지정된 목록의 중위수를 반환하는 단순 함수:

def median(lst):
    lst = sorted(lst)  # 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]

의 예를 몇 가지 나타냅니다.median기능:

>>> median([9, 12, 20, 21, 34, 80])  # Even
20.5
>>> median([9, 12, 80, 21, 34])  # Odd
21

라이브러리를 사용하고 싶은 경우는, 다음의 조작을 실시합니다.

>>> import statistics
>>> statistics.median([9, 12, 20, 21, 34, 80])  # Even
20.5
>>> statistics.median([9, 12, 80, 21, 34])  # Odd
21

저는 Python의 "median of medians" 알고리즘 구현에 솔루션을 올렸습니다.이것은 sort()를 사용하는 것보다 조금 더 빠릅니다.우리 솔루션은 열당 15개의 숫자를 사용하여 열당 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)

목록의 분포에 대한 추가 정보가 필요한 경우 백분위수 방법이 유용할 수 있습니다.중위수 값은 목록의 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 

코덱데미에서 이 연습을 하면서 생각해낸 것은 다음과 같습니다.

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

두 줄이면 돼요.

def get_median(arr):
    '''
    Calculate the median of a sequence.
    :param arr: list
    :return: int or float
    '''
    arr = sorted(arr)
    return arr[len(arr)//2] if len(arr) % 2 else (arr[len(arr)//2] + arr[len(arr)//2-1])/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

부동값 리스트에 문제가 있었습니다.저는 python3 statistics.median의 코드 스니펫을 사용하게 되었고, 소스 Import 없이 float 값으로 완벽하게 동작하고 있습니다.

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

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

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

숫자 목록의 중앙 함수를 다음과 같이 정의했습니다.

def median(numbers):
    return (sorted(numbers)[int(round((len(numbers) - 1) / 2.0))] + sorted(numbers)[int(round((len(numbers) - 1) // 2.0))]) / 2.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]))

중위수(및 백분위수)에 대한 보다 일반적인 접근법은 다음과 같다.

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

시험해 보다

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

구현:

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] + numbers[mid_index - 1]) / 2 if mid_index % 2 == 0
        else numbers[mid_index]
    )


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

    testmod()

에서 얻다.

함수 중위수:

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] + d[n2+1]) / 2
    return med

단순히 인수를 번호 목록으로 사용하여 중앙 함수를 만들고 함수를 호출합니다.

def median(l):
    l = sorted(l)
    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 result

제가 한 일은 이렇습니다.

def median(a):
    a = sorted(a)
    if len(a) / 2 != int:
        return a[len(a) / 2]
    else:
        return (a[len(a) / 2] + a[(len(a) / 2) - 1]) / 2

설명:기본적으로 목록의 항목 수가 홀수인 경우 중간 숫자를 반환합니다. 그렇지 않으면 짝수 목록의 절반인 경우 python은 자동으로 큰 숫자를 반올림하여 그 전의 숫자를 1개 적게 알 수 있습니다.기본값의 큰 숫자와 그보다 낮은 숫자를 추가하여 중간값을 찾을 수 있습니다.

다음 예시는 를 사용하지 않고 중앙값을 찾는 번거로운 방법입니다.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

매우 간단합니다.

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)

언급URL : https://stackoverflow.com/questions/24101524/finding-median-of-list-in-python