Generieren Sie mit Python automatisch eine Häufigkeitsverteilungstabelle auf einmal

Einführung

Im Bereich Mathematik und Statistik sehen Sie möglicherweise eine Tabelle mit Klassen, Klassenwerten, Häufigkeiten, kumulativen Häufigkeiten, relativen Häufigkeiten und kumulativen relativen Häufigkeiten. So ist es.

Ich habe es geschafft, weil ich in Python keine Funktion finden konnte, die dies auf einmal herausgibt.

Bestehende Komfortfunktionen

Es gibt keine Funktion zum Erstellen einer vollständigen Tabelle, aber die folgenden praktischen Funktionen können verwendet werden, um die erforderlichen Informationen teilweise abzurufen. Darüber hinaus können Sie durch einige Berechnungen alle erforderlichen Werte abrufen.

#numpy cumsum()Holen Sie sich die kumulative Häufigkeit mit
data.cumsum()

#Pandas Wert_counts()Zählen Sie die Häufigkeit des Auftretens jedes Werts mit
pd.Series(data).value_counts()

Einfallsreichtum für die Automatisierung

Bestimmen der Anzahl der Klassen und der Breite der Klassen

Es gibt keine klaren Regeln für die Bestimmung der Anzahl der Klassen oder der Breite der Klassen. Es gibt jedoch eine Starges-Formel, um eine Idee zu bekommen, also werde ich sie verwenden.

** Starges-Formel **
Eine Formel, die eine Anleitung zum Bestimmen der Anzahl von Klassen beim Erstellen von Häufigkeitsverteilungstabellen und Histogrammen bietet. Unter der Annahme, dass N die Stichprobengröße und k die Anzahl der Klassen ist, kann dies wie folgt berechnet werden. Die Breite der Klasse wird berechnet, indem der Maximalwert durch k vom Minimalwert der Daten geteilt wird.

k=log_2N+1

#Finden Sie die Anzahl der Klassen aus der Starges-Formel
class_size = 1 + np.log2(len(data))
class_size = int(round(class_size))

#Finden Sie die Klassenbreite
class_width = (max(data) - min(data)) / class_size #Der Nenner ist die Anzahl der Klassen und das Molekül ist der Bereich.
class_width = round(class_width)

Es gibt jedoch keine klaren Regeln, und ich denke, dass es Zeiten gibt, in denen Sie die Breite der Klasse auf einen guten Wert festlegen möchten, z. B. 5, damit ich damit umgehen kann. Wenn Sie den in der Starges-Formel angegebenen Wert verwenden möchten, geben Sie als zweites Argument der Funktion "Keine" an. Wenn Sie einen beliebigen Wert verwenden möchten, geben Sie diesen beliebigen Wert im zweiten Argument an. Die Anzahl der Klassen wird entsprechend geändert.

def Frequency_Distribution(data, class_width):
    if class_width == None:
        #Finden Sie die Klassenbreite
        class_width = (max(data) - min(data)) / class_size #
        class_width = round(class_width) #
    else:
        class_width = class_width
        class_size = max(x) // class_width

class_width = 5 #
class_size = 10 #Rundung Der Index der Klasse wird dynamisch geändert. Die Klasse ist "mehr als ... weniger als". Beim Erstellen einer Häufigkeitsverteilungstabelle möchte ich eine Klasse als Index festlegen und in der Tabelle beschreiben, aber es ist schwierig, sie manuell gemäß den Eingabedaten einzugeben. Daher kann die Indexbezeichnung generiert werden, indem die for-Anweisung in der Listentyp-Einschlussnotation unter Verwendung der Klassenbreite, der Anzahl der Klassen und des Formatoperators gedreht wird. Klassenbreite Anzahl der Klassen
['%s oder mehr%Weniger als s'%(w, w+class_width) for w in range(0, class_size*class_width*2, class_width)]

# ['0 oder mehr und weniger als 5','5 oder mehr und weniger als 10','10 oder mehr und weniger als 15','15 oder mehr und weniger als 20','20 oder mehr und weniger als 25','25 oder mehr und weniger als 30']

Eine Tabelle erstellen

Alles, was Sie tun müssen, ist, Zeilen und Spalten hinzuzufügen und Spalten- und Indexnamen durch Bedienung von Pandas zu aktualisieren.

Ganzer Code

import pandas as pd
import numpy as np

#Erstellen Sie eine Häufigkeitsverteilungstabelle
def Frequency_Distribution(data, class_width):
    #Finden Sie die Anzahl der Klassen aus der Starges-Formel
    class_size = 1 + np.log2(len(data))
    class_size = int(round(class_size))
    if class_width == None:
        #Finden Sie die Klassenbreite
        class_width = (max(data) - min(data)) / class_size #Der Nenner ist die Anzahl der Klassen und das Molekül ist der Bereich.
        class_width = round(class_width) #Rundung
    else:
        class_width = class_width
        class_size = max(x) // class_width
    # print('Anzahl der Klassen:', class_size)
    # print('Klassenbreite:', class_width)
    
    #Nach Klasse sortieren
    #Machen Sie jeden beobachteten Wert zu einem Klassenwert
    cut_data = []
    for row in data:
        cut = row // class_width
        cut_data.append(cut)
        
    #Zähle die Frequenz
    Frequency_data = pd.Series(cut_data).value_counts()
    Frequency_data = pd.DataFrame(Frequency_data)
    #Ich möchte nach Index sortieren und an einer beliebigen Position eine Zeile einfügen, also übertrage ich sie einmal
    F_data = Frequency_data.sort_index().T
    #Wenn es eine Klasse mit einer Frequenz von 0 gibt, fügen Sie sie in den Datenrahmen ein
    for i in range(0, max(F_data.columns)):
        if (i in F_data) == False:
            F_data.insert(i, i, 0)
    F_data = F_data.T.sort_index()
    #Benennen Sie Indizes und Spalten um
    F_data.index = ['%s oder mehr%Weniger als s'%(w, w + class_width) for w in range(0, class_size * class_width * 2, class_width)][:len(F_data)]
    F_data.columns = ['Frequenz']

    F_data.insert(0, 'Klassenwert', [((w + (w + class_width)) / 2) for w in range(0, class_size * class_width * 2, class_width)][:len(F_data)])
    F_data['Kumulative Häufigkeit'] = F_data['Frequenz'].cumsum()
    F_data['Relative Frequenz'] = F_data['Frequenz'] / sum(F_data['Frequenz'])
    F_data['Kumulative relative Häufigkeit'] = F_data['Kumulative Häufigkeit'] / max(F_data['Kumulative Häufigkeit'])
    F_data.loc['gesamt'] = [None, sum(F_data['Frequenz']), None, sum(F_data['相対Frequenz']), None]

    return F_data

#Beispieldaten
x = [0, 3, 3, 5, 5, 5, 5, 7, 7, 10, 11, 14, 14, 14]
Frequency_Distribution(x, None)

Ergebnis

Nachtrag (2020/10/4)

Dieser Code, der von @nkay kommentiert wurde, wird empfohlen, da er sehr intelligent geschrieben werden kann.

def Frequency_Distribution(data, class_width=None):
    data = np.asarray(data)
    if class_width is None:
        class_size = int(np.log2(data.size).round()) + 1
        class_width = round((data.max() - data.min()) / class_size)

    bins = np.arange(0, data.max()+class_width+1, class_width)
    hist = np.histogram(data, bins)[0]
    cumsum = hist.cumsum()

    return pd.DataFrame({'Klassenwert': (bins[1:] + bins[:-1]) / 2,
                         'Frequenz': hist,
                         'Kumulative Häufigkeit': cumsum,
                         'Relative Frequenz': hist / cumsum[-1],
                         'Kumulative relative Häufigkeit': cumsum / cumsum[-1]},
                        index=pd.Index([f'{bins[i]}das ist alles{bins[i+1]}Weniger als'
                                        for i in range(hist.size)],
                                       name='Klasse'))


x = [0, 3, 3, 5, 5, 5, 5, 7, 7, 10, 11, 14, 14, 14]
Frequency_Distribution(x)

Referenz

Bei der Erstellung des obigen Codes habe ich hauptsächlich auf die folgenden Websites verwiesen. Zum Data Scientist gehen Statistisches Glossar