Làm thế nào để bạn tìm thấy trung vị của một danh sách trong Python? Danh sách có thể có bất kỳ kích thước nào và các con số không được đảm bảo theo bất kỳ thứ tự cụ thể nào.

Nếu danh sách chứa số phần tử chẵn, hàm sẽ trả về mức trung bình của hai phần tử ở giữa.

Dưới đây là một số ví dụ (được sắp xếp cho mục đích hiển thị):

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 có statistics.median:

Trả về giá trị trung bình (giá trị trung bình) của dữ liệu số.

Khi số lượng điểm dữ liệu là số lẻ, trả về điểm dữ liệu giữa. Khi số lượng điểm dữ liệu là chẵn, trung vị được nội suy bằng cách lấy trung bình của hai giá trị trung bình:

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

Sử dụng:

import statistics

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

statistics.median(items)
#>>> 3

Nó cũng khá cẩn thận với các loại:

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

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

(Hoạt động với trăn-2.x):

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

Dành cho trăn-3.x, sử dụng statistics.median:

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

Hàm sort () rất hữu ích cho việc này. Sử dụng hàm được sắp xếp để sắp xếp danh sách, sau đó chỉ cần trả về giá trị trung bình (hoặc trung bình hai giá trị giữa nếu danh sách chứa một số lượng phần tử chẵn).

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

Đây là một giải pháp sạch hơn:

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

Lưu ý: Trả lời thay đổi để kết hợp đề xuất trong ý kiến.

Bạn có thể thử thuật toán quickselect nếu cần thời gian chạy trường hợp trung bình nhanh hơn. Quickselect có hiệu suất trường hợp trung bình (và tốt nhất) O(n), mặc dù nó có thể kết thúc O(n²)vào một ngày tồi tệ.

Đây là một triển khai với một trục được chọn ngẫu nhiê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)

Bạn có thể biến điều này thành một phương pháp để tìm trung bình:

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

Điều này rất không được đánh giá cao, nhưng không có khả năng ngay cả một phiên bản được tối ưu hóa sẽ vượt trội hơn so với Tim Sort (tích hợp sẵn của CPython sort) vì điều đó thực sự nhanh . Tôi đã thử trước đây và tôi đã thua.

Tất nhiên bạn có thể sử dụng hàm xây dựng, nhưng nếu bạn muốn tạo riêng, bạn có thể làm một cái gì đó như thế này. Mẹo ở đây là sử dụng toán tử ~ lật số dương thành âm. Ví dụ ~ 2 -> -3 và sử dụng phủ định trong danh sách trong Python sẽ đếm các mục từ cuối. Vì vậy, nếu bạn có mid == 2 thì nó sẽ lấy phần tử thứ ba từ đầu và mục thứ ba từ cuối.

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

Bạn có thể sử dụng list.sortđể tránh tạo danh sách mới sortedvà sắp xếp danh sách tại chỗ.

Ngoài ra, bạn không nên sử dụng listlàm tên biến vì nó làm mờ danh sách riêng của 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]

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

Tôi đã đăng giải pháp của mình khi triển khai Python về thuật toán "median of median" , nhanh hơn một chút so với sử dụng sort (). Giải pháp của tôi sử dụng 15 số trên mỗi cột, cho tốc độ ~ 5N nhanh hơn tốc độ ~ 10N khi sử dụng 5 số trên mỗi cột. Tốc độ tối ưu là ~ 4N, nhưng tôi có thể sai về nó.

Theo yêu cầu của Tom trong bình luận của anh ấy, tôi đã thêm mã của mình vào đây, để tham khảo. Tôi tin rằng phần quan trọng cho tốc độ là sử dụng 15 số trên mỗi cột, thay vì 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)

Đây là những gì tôi đã đưa ra trong bài tập này trong 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])

Chức năng trung bình

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

Tôi đã có một số vấn đề với danh sách các giá trị float. Tôi đã kết thúc bằng cách sử dụng một đoạn mã từ thống kê python3.median và đang hoạt động hoàn hảo với các giá trị float mà không cần nhập. nguồn

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

Tôi đã định nghĩa một hàm trung vị cho một danh sách các số là

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

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

trung gian đấu giá:

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

Trong trường hợp bạn cần thêm thông tin về việc phân phối danh sách của mình, phương pháp phân vị có thể sẽ hữu ích. Và giá trị trung bình tương ứng với phân vị thứ 50 của danh sách:

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 

Một hàm đơn giản để trả về trung vị của danh sách đã cho:

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

nếu bạn muốn sử dụng thư viện, bạn chỉ cần làm;

import statistics

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

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

Một cách tiếp cận tổng quát hơn cho trung vị (và phần trăm) sẽ là:

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

Đây là cách tẻ nhạt để tìm trung vị mà không sử dụng medianhàm:

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

Nó rất đơn giản;

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

Và bạn có thể sử dụng giá trị trả về như thế này median = median(anyList)