it-swarm.com.de

Mittelwert der Liste in Python suchen

Wie finden Sie den Median einer Liste in Python? Die Liste kann beliebig groß sein und es kann nicht garantiert werden, dass die Anzahl in einer bestimmten Reihenfolge liegt.

Wenn die Liste eine gerade Anzahl von Elementen enthält, sollte die Funktion den Durchschnitt der mittleren zwei zurückgeben.

Hier einige Beispiele (für Anzeigezwecke sortiert):

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
128
ChucksPlace

Python 3.4 hat statistics.median :

Gibt den Median (Mittelwert) der numerischen Daten zurück.

Wenn die Anzahl der Datenpunkte ungerade ist, den mittleren Datenpunkt zurückgeben. Wenn die Anzahl der Datenpunkte gerade ist, wird der Median interpoliert, indem der Durchschnitt der zwei mittleren Werte genommen wird:

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

Verwendungszweck:

import statistics

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

statistics.median(items)
#>>> 3

Es ist auch mit Typen ziemlich vorsichtig:

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

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

Für Python-2.x :

Verwenden Sie numpy.median() , um eine einzeilige Funktion zu erstellen:

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

Oder, um eine Funktion zu schreiben :

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

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

Für python-3.x verwenden Sie statistics.median :

>>> from statistics import median
>>> median([5, 2, 3, 8, 9, -2])
4.0
128
A.J. Uppal

Die sortierte () - Funktion ist dafür sehr hilfreich. Verwenden Sie die sortierte Funktion, um die Liste zu sortieren, und geben Sie dann einfach den mittleren Wert zurück (oder berechnen Sie die beiden mittleren Werte, wenn die Liste eine gerade Anzahl von Elementen enthält).

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
44
swolfe

Hier ist eine sauberere Lösung:

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

Hinweis: Die Antwort wurde geändert, um den Vorschlag in Kommentare aufzunehmen.

11
Batuhan Ulug

Sie können den Algorithmus quickselect ausprobieren, wenn kürzere Laufzeiten im Durchschnitt erforderlich sind. Quickselect hat eine durchschnittliche (und beste) Fallleistung O(n), obwohl es an einem schlechten Tag O(n²) enden kann.

Hier ist eine Implementierung mit einem zufällig ausgewählten Pivot:

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)

Sie können dies trivial in eine Methode verwandeln, um Mediane zu finden:

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

Dies ist sehr unoptimiert, aber es ist unwahrscheinlich, dass selbst eine optimierte Version Tim Sort (CPythons eingebaute sort) übertrifft, da dies wirklich schnell ist. Ich habe es schon mal versucht und habe verloren.

8
Veedrac

Natürlich können Sie eingebaute Funktionen verwenden, aber wenn Sie Ihre eigenen erstellen möchten, können Sie so etwas tun. Der Trick hier ist, den Operator ~ zu verwenden, der die positive Zahl in den negativen Wert umwandelt. Zum Beispiel werden ~ 2 -> -3 und die Verwendung von negativ in for in Python Elemente vom Ende her zählen. Wenn Sie also mid == 2 haben, wird das dritte Element vom Anfang und das dritte Element vom Ende genommen.

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

Sie können den list.sort verwenden, um zu vermeiden, dass mit sorted neue Listen erstellt werden, und sortieren Sie die Listen nach ihren Kriterien.

Sie sollten auch nicht list als Variablennamen verwenden, da diese die eigene list von python beschattet.

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

Was ich während dieser Übung in der Codecademy gefunden habe:

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
BynderRox
import numpy as np
def median(x):

    if len(x)%2==0:
        x = sorted(x)
        num = round(len(x)/2)
        num2 = num-1
        middlenum = (x[num]+x[num2])/2
    else:
        x = sorted(x)
        listlength = len(x) 
        num = round(listlength / 2)
        middlenum = x[num]
    return middlenum
2
Bulent
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
vk123

Ich hatte einige Probleme mit Listen von Float-Werten. Am Ende habe ich ein Code-Snippet aus python3 statistics.median verwendet und arbeite perfekt mit Float-Werten ohne Import. Quelle

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
1
Daniel

Medianfunktion

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

Ich habe meine Lösung bei Python-Implementierung des Algorithmus "median of medians" veröffentlicht, der etwas schneller ist als sort (). In meiner Lösung werden 15 Zahlen pro Spalte verwendet. Dies entspricht einer Geschwindigkeit von ~ 5N, die schneller ist als die Geschwindigkeit von ~ 10N bei Verwendung von 5 Zahlen pro Spalte. Die optimale Geschwindigkeit ist ~ 4N, aber ich könnte mich irren.

Nach Toms Bitte in seinem Kommentar, habe ich hier meinen Code als Referenz hinzugefügt. Ich glaube, der entscheidende Faktor für die Geschwindigkeit ist die Verwendung von 15 Zahlen pro Spalte anstelle von 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)
1
user5818263
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
sim
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])
0
Luke Willey

Ich habe eine Medianfunktion für eine Liste von Zahlen als definiert

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

Es ist sehr einfach;

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

Und Sie können den Rückgabewert wie folgt verwenden median = median(anyList)

0
Farhan