Générez automatiquement une table de distribution de fréquence en un seul coup avec Python

introduction

Dans le domaine des mathématiques et des statistiques, vous pouvez voir un tableau des classes, des valeurs de classe, des fréquences, des fréquences cumulées, des fréquences relatives et des fréquences relatives cumulées. Voilà à quoi ça ressemble.

Je l'ai fait parce que je n'ai pas trouvé de fonction qui donnerait cela d'un seul coup en Python.

Fonction de commodité existante

Il n'y a pas de fonction pour créer un tableau complet, mais les fonctions pratiques suivantes peuvent être utilisées pour récupérer partiellement les informations nécessaires. En plus de cela, vous pouvez obtenir toutes les valeurs nécessaires en effectuant quelques calculs.

#sperme engourdi()Obtenez la fréquence cumulée avec
data.cumsum()

#valeur pandas_counts()Comptez la fréquence d'apparition de chaque valeur avec
pd.Series(data).value_counts()

Ingéniosité pour l'automatisation

Déterminer le nombre de classes et la largeur des classes

Il n'y a pas de règles claires pour déterminer le nombre de classes ou la largeur des classes. Cependant, il existe une formule de Starges pour me faire une idée, je vais donc l'utiliser.

** Formule Starges **
Une formule qui fournit un guide pour déterminer le nombre de classes lors de la création de tableaux et d'histogrammes de distribution de fréquence. En supposant que N est la taille de l'échantillon et k le nombre de classes, il peut être calculé comme suit. La largeur de la classe est calculée en divisant la valeur maximale par k de la valeur minimale des données.

k=log_2N+1

#Trouvez le nombre de classes à partir de la formule Starges
class_size = 1 + np.log2(len(data))
class_size = int(round(class_size))

#Trouvez la largeur de la classe
class_width = (max(data) - min(data)) / class_size #Le dénominateur est le nombre de classes et la molécule est la plage.
class_width = round(class_width)

Cependant, il n'y a pas de règles claires, et je pense qu'il y a des moments où vous voulez définir la largeur de la classe sur une bonne valeur, telle que 5, donc je vais permettre de le gérer. Si vous souhaitez utiliser la valeur donnée par la formule Starges, spécifiez «Aucun» comme deuxième argument de la fonction. Si vous souhaitez utiliser une valeur arbitraire, spécifiez cette valeur arbitraire dans le deuxième argument. Le nombre de classes sera modifié en conséquence.

def Frequency_Distribution(data, class_width):
    if class_width == None:
        #Trouvez la largeur de la classe
        class_width = (max(data) - min(data)) / class_size #Le dénominateur est le nombre de classes et la molécule est la plage.
        class_width = round(class_width) #Arrondi
    else:
        class_width = class_width
        class_size = max(x) // class_width

Changer d'index de classe dynamiquement

La classe est "plus de ... moins de ...". Lors de la création d'une table de distribution de fréquences, je voudrais définir une classe comme index et la décrire dans la table, mais il est difficile de la saisir manuellement en fonction des données d'entrée. Par conséquent, l'étiquette d'index peut être générée en tournant l'instruction for dans la notation d'inclusion de type liste à l'aide de la largeur de classe, du nombre de classes et de l'opérateur de format.

class_width = 5 #Largeur de classe
class_size = 10 #Nombre de cours
['%s ou plus%Moins de s'%(w, w+class_width) for w in range(0, class_size*class_width*2, class_width)]

# ['0 ou plus et moins de 5','5 ou plus et moins de 10','10 ou plus et moins de 15','15 ou plus et moins de 20','20 ou plus et moins de 25','25 ou plus et moins de 30']

Créer une table

Tout ce que vous avez à faire est d'ajouter des lignes et des colonnes et de mettre à jour les noms de colonnes et d'index en opérant des pandas.

Code entier

import pandas as pd
import numpy as np

#Faire un tableau de distribution de fréquence
def Frequency_Distribution(data, class_width):
    #Trouvez le nombre de classes à partir de la formule Starges
    class_size = 1 + np.log2(len(data))
    class_size = int(round(class_size))
    if class_width == None:
        #Trouvez la largeur de la classe
        class_width = (max(data) - min(data)) / class_size #Le dénominateur est le nombre de classes et la molécule est la plage.
        class_width = round(class_width) #Arrondi
    else:
        class_width = class_width
        class_size = max(x) // class_width
    # print('Nombre de cours:', class_size)
    # print('Largeur de classe:', class_width)
    
    #Trier par classe
    #Faire de chaque valeur observée une valeur de classe
    cut_data = []
    for row in data:
        cut = row // class_width
        cut_data.append(cut)
        
    #Comptez la fréquence
    Frequency_data = pd.Series(cut_data).value_counts()
    Frequency_data = pd.DataFrame(Frequency_data)
    #Trier par index et insérer une ligne à n'importe quelle position, donc transposer une fois
    F_data = Frequency_data.sort_index().T
    #S'il y a une classe avec une fréquence 0, insérez-la dans la trame de données
    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()
    #Renommer les index et les colonnes
    F_data.index = ['%s ou plus%Moins de s'%(w, w + class_width) for w in range(0, class_size * class_width * 2, class_width)][:len(F_data)]
    F_data.columns = ['la fréquence']

    F_data.insert(0, 'Valeur de classe', [((w + (w + class_width)) / 2) for w in range(0, class_size * class_width * 2, class_width)][:len(F_data)])
    F_data['Fréquence cumulative'] = F_data['la fréquence'].cumsum()
    F_data['Fréquence relative'] = F_data['la fréquence'] / sum(F_data['la fréquence'])
    F_data['Fréquence relative cumulative'] = F_data['Fréquence cumulative'] / max(F_data['Fréquence cumulative'])
    F_data.loc['total'] = [None, sum(F_data['la fréquence']), None, sum(F_data['相対la fréquence']), None]

    return F_data

#Exemple de données
x = [0, 3, 3, 5, 5, 5, 5, 7, 7, 10, 11, 14, 14, 14]
Frequency_Distribution(x, None)

résultat

Supplément (2020/10/4)

Ce code, commenté par @nkay, est recommandé car il peut être écrit très intelligemment.

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({'Valeur de classe': (bins[1:] + bins[:-1]) / 2,
                         'la fréquence': hist,
                         'Fréquence cumulative': cumsum,
                         'Fréquence relative': hist / cumsum[-1],
                         'Fréquence relative cumulative': cumsum / cumsum[-1]},
                        index=pd.Index([f'{bins[i]}c'est tout{bins[i+1]}Moins que'
                                        for i in range(hist.size)],
                                       name='classe'))


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

référence

En créant le code ci-dessus, je me suis principalement référé aux sites suivants. Aller au Data Scientist Glossaire statistique