it-swarm.com.de

Wie berechnet man das 1. und 3. Quartil?

Ich habe DataFrame:

    time_diff   avg_trips
0   0.450000    1.0
1   0.483333    1.0
2   0.500000    1.0
3   0.516667    1.0
4   0.533333    2.0

Ich möchte 1. Quartil, 3. Quartil und Median für die Spalte time_diff bekommen. Um einen Medianwert zu erhalten, verwende ich np.median(df["time_diff"].values).

Wie kann ich Quartile berechnen?

8
Dinosaurius

Mit pandas:

df.time_diff.quantile([0.25,0.5,0.75])


Out[793]: 
0.25    0.483333
0.50    0.500000
0.75    0.516667
Name: time_diff, dtype: float64
11
Wen-Ben

Sie können np.percentile verwenden, um Quartile (einschließlich des Medians) zu berechnen:

>>> np.percentile(df.time_diff, 25)  # Q1
0.48333300000000001

>>> np.percentile(df.time_diff, 50)  # median
0.5

>>> np.percentile(df.time_diff, 75)  # Q3
0.51666699999999999

Oder alles auf einmal:

>>> np.percentile(df.time_diff, [25, 50, 75])
array([ 0.483333,  0.5     ,  0.516667])
17
MSeifert

Zufälligerweise werden diese Informationen mit der describe-Methode erfasst:

df.time_diff.describe()

count    5.000000
mean     0.496667
std      0.032059
min      0.450000
25%      0.483333
50%      0.500000
75%      0.516667
max      0.533333
Name: time_diff, dtype: float64
9
piRSquared

np.percentile verwenden.

q75, q25 = np.percentile(DataFrame, [75,25])
iqr = q75 - q25

Antwort von Wie findet man den IQR in Numpy?

5
Stian Ulriksen

Darauf aufbauen oder vielmehr ein bisschen korrigieren, was Cyrus gesagt hat ...

[np.percentile][1]TUT VIEL Berechnen Sie die Werte von Q1, Median und Q3. Betrachten Sie die sortierte Liste unten:

s1=[18,45,66,70,76,83,88,90,90,95,95,98]

running np.percentile(s1, [25, 50, 75]) liefert die aktuellen Werte aus der Liste:

[69.   85.5  91.25]

Die Quartile sind jedoch Q1 = 68,0, Median = 85,5, Q3 = 92,5, was das richtige ist, was zu sagen ist

Was wir hier vermissen, ist der Interpolation Parameter von np.percentile Und verwandten Funktionen. Standardmäßig ist der Wert dieses Arguments linear. Dieser optionale Parameter gibt die Interpolationsmethode an, die verwendet werden soll, wenn das gewünschte Quantil zwischen zwei Datenpunkten i <j liegt:
linear: i + (j - i) * Bruch, wobei Bruch der Bruchteil des Index ist, der von i und j umgeben ist.
niedriger: i.
höher: j.
am nächsten: i oder j, je nachdem, was am nächsten ist.
Mittelpunkt: (i + j)/2.

Wenn Sie also np.percentile(s1, [25, 50, 75], interpolation='midpoint') ausführen, werden die tatsächlichen Ergebnisse für die Liste zurückgegeben:

[68.  85.5 92.5]
1

np.percentile berechnet nicht die Werte von Q1, Median und Q3. Betrachten Sie die sortierte Liste unten

samples = [1, 1, 8, 12, 13, 13, 14, 16, 19, 22, 27, 28, 31]

wenn Sie np.percentile(samples, [25, 50, 75]) ausführen, werden die tatsächlichen Werte aus der Eingabeliste zurückgegeben:

Out[1]: array([12., 14., 22.])

Die eigentlichen Quartile sind jedoch Q1=10.0, Median=14, Q3=24.5 (Sie können diese Verknüpfung auch verwenden, um die Quartile und den Median online zu finden). Sie können den folgenden Code verwenden, um die Quartile und den Median einer sortierten Liste zu berechnen (wegen des Sortierens erfordert O(nlogn) Berechnungen, wobei n die Anzahl der Elemente ist) . Außerdem können Quartile und Median gesucht werden O(n) Berechnungen mit dem Median der Mediane Auswahlalgorithmus ( Auftragsstatistik ). 

samples = sorted([28, 12, 8, 27, 16, 31, 14, 13, 19, 1, 1, 22, 13])

def find_median(sorted_list):
    indices = []

    list_size = len(sorted_list)
    median = 0

    if list_size % 2 == 0:
        indices.append(int(list_size / 2) - 1)  # -1 because index starts from 0
        indices.append(int(list_size / 2))

        median = (sorted_list[indices[0]] + sorted_list[indices[1]]) / 2
        pass
    else:
        indices.append(int(list_size / 2))

        median = sorted_list[indices[0]]
        pass

    return median, indices
    pass

median, median_indices = find_median(samples)
Q1, Q1_indices = find_median(samples[:median_indices[0]])
Q2, Q2_indices = find_median(samples[median_indices[-1] + 1:])

quartiles = [Q1, median, Q2]

print("(Q1, median, Q3): {}".format(quartiles))
1
Ravandi

In meinen Bemühungen, objektorientiertes Programmieren neben Lernstatistiken zu lernen, habe ich dies gemacht, vielleicht finden Sie es nützlich:

samplesCourse = [9, 10, 10, 11, 13, 15, 16, 19, 19, 21, 23, 28, 30, 33, 34, 36, 44, 45, 47, 60]

class sampleSet:
    def __init__(self, sampleList):
        self.sampleList = sampleList
        self.interList = list(sampleList) # interList is sampleList alias; alias used to maintain integrity of original sampleList

    def find_median(self):
        self.median = 0

        if len(self.sampleList) % 2 == 0:
            # find median for even-numbered sample list length
            self.medL = self.interList[int(len(self.interList)/2)-1]
            self.medU = self.interList[int(len(self.interList)/2)]
            self.median = (self.medL + self.medU)/2

        else:
            # find median for odd-numbered sample list length
            self.median = self.interList[int((len(self.interList)-1)/2)]
        return self.median

    def find_1stQuartile(self, median):
        self.lower50List = []
        self.Q1 = 0

        # break out lower 50 percentile from sampleList
        if len(self.interList) % 2 == 0:
            self.lower50List = self.interList[:int(len(self.interList)/2)]
        else:
            # drop median to make list ready to divide into 50 percentiles
            self.interList.pop(interList.index(self.median))
            self.lower50List = self.interList[:int(len(self.interList)/2)]

        # find 1st quartile (median of lower 50 percentiles)
        if len(self.lower50List) % 2 == 0:
            self.Q1L = self.lower50List[int(len(self.lower50List)/2)-1]
            self.Q1U = self.lower50List[int(len(self.lower50List)/2)]
            self.Q1 = (self.Q1L + self.Q1U)/2

        else:
            self.Q1 = self.lower50List[int((len(self.lower50List)-1)/2)]

        return self.Q1

    def find_3rdQuartile(self, median):
        self.upper50List = []
        self.Q3 = 0

        # break out upper 50 percentile from sampleList
        if len(self.sampleList) % 2 == 0:
            self.upper50List = self.interList[int(len(self.interList)/2):]
        else:
            self.interList.pop(interList.index(self.median))
            self.upper50List = self.interList[int(len(self.interList)/2):]

        # find 3rd quartile (median of upper 50 percentiles)
        if len(self.upper50List) % 2 == 0:
            self.Q3L = self.upper50List[int(len(self.upper50List)/2)-1]
            self.Q3U = self.upper50List[int(len(self.upper50List)/2)]
            self.Q3 = (self.Q3L + self.Q3U)/2

        else:
            self.Q3 = self.upper50List[int((len(self.upper50List)-1)/2)]

        return self.Q3

    def find_InterQuartileRange(self, Q1, Q3):
        self.IQR = self.Q3 - self.Q1
        return self.IQR

    def find_UpperFence(self, Q3, IQR):
        self.fence = self.Q3 + 1.5 * self.IQR
        return self.fence

samples = sampleSet(samplesCourse)
median = samples.find_median()
firstQ = samples.find_1stQuartile(median)
thirdQ = samples.find_3rdQuartile(median)
iqr = samples.find_InterQuartileRange(firstQ, thirdQ)
fence = samples.find_UpperFence(thirdQ, iqr)

print("Median is: ", median)
print("1st quartile is: ", firstQ)
print("3rd quartile is: ", thirdQ)
print("IQR is: ", iqr)
print("Upper fence is: ", fence)
0
Ian