Fonction ntile (décile) en python

Ce que j'ai fait

Même si la fonction ntile qui était souvent utilisée dans SQL lors de l'analyse décyle est recherchée, Il n'est pas sorti, alors j'ai créé une fonction.

Dédié aux frères aînés qui pensaient que "ntile est le meilleur. Pourquoi n'est-ce pas Python ..." en SQL.

fonction ntile (légèrement modifiée)

Eh bien, comme utilisation, Insérez df = pandas dataframe, col = Decyl Entrez le nom de la colonne que vous souhaitez analyser. n = 10 est défini, mais si vous souhaitez créer 100 groupes, définissez n = 100 etc. Si n_tile = True, renvoie le dataframe donné sous forme de colonnes pour le nombre de décores, S'il est défini sur False, une trame de données avec diverses fonctions d'agrégation sera renvoyée. agg = fonction d'agrégation que vous souhaitez utiliser lorsque n_tile False ci-dessus, Pour ceux qui disent "juste somme", utilisez agg = ["somme"] comme argument.

• Les commentaires sont en anglais car j'étudie l'anglais.

def ntile(df, col, n=10, n_tile=True, ascending=False, aggs=["sum", "count", "min", "max", "median", "mean", "std"]):
    # check pandas dataframe type
    if type(df) == pd.core.frame.DataFrame:
        # check int or float
        if type(df[f"{col}"].max()) == np.int64 or type(df[f"{col}"].max()) == np.float64:
            ntile_df = pd.DataFrame()
            length = len(df)
            df = df.sort_values(col, ascending=ascending).reset_index(drop=True)
            div_n = math.ceil(len(df) / n)

            # mark N group 
            for idx, num in enumerate(range(0, length, div_n)):
                n_df = df[num: num+div_n]
                n_df["decile"] = idx + 1
                ntile_df = ntile_df.append(n_df)
            
            # return ntile_df if need only decile data
            if n_tile:
                return ntile_df
            
            # otherwise aggregate col
            agg_df = ntile_df.groupby("decile").agg({f"{col}": aggs}).reset_index()
            #  clean columns
            agg_df.columns = ["".join(c) for c in agg_df.columns]
            # merge two data
            ntile_df = ntile_df.merge(agg_df, on="decile").copy()
            
            return ntile_df
        
        raise TypeError(f"`{col}` must be int or float type")
    raise TypeError(f"`{type(df)}` must be pandas.core.frame.DataFrame type")

Créer des exemples de données

import pandas as pd
import random
#Créer un type de prix aléatoire
price = random.sample(range(10000, 900000), k=10000)
#Créez un dataframe en utilisant ce qui précède
data = pd.DataFrame(price, columns=["price"])

Le contenu est comme ça.

Utilisez-le comme ça

#Mettez des données dans la fonction. n=Laissez la valeur par défaut de 10
data = ntile(data, "price")
#Groupez par décile et appliquez diverses fonctions d'agrégation.
data.groupby("decile").agg({"price": ["sum", "count", "min", "max", "median", "mean"]}).reset_index()

n=10

n=100

Si n_tile = False

data = ntile(data, "price", n=5 , n_tile=False)

data.pricemin.value_counts().sort_index().reset_index().rename(columns={"index": "price_segment", "pricemin": "count"})

Et regardez ça.

Avez-vous déjà fait quelque chose comme ce qui suit? Et "N'y a-t-il pas une fonction qui crée une classe avec n% de toutes les classes dans la colonne cible?" Avez-vous déjà ressenti cela?

Je suis un débutant, donc j'ai réfléchi à ce qui précède plusieurs fois. J'ai regardé ntile à chaque fois et l'ai corrigé à la main, mais à partir de maintenant, il est possible de le changer simplement en changeant la partie de n = 10. Après tout, python a un tour plus petit que SQL.

À la fin

Je ne sais pas si la recherche est insuffisante, mais il est étrange qu'il n'y ait pas de fonction ntile en SQL comme python, Eh bien, j'ai essayé de le faire comme une pratique, donc si vous avez changé de travail de SQLer à pythoner, veuillez l'utiliser.