Dans la continuité de la dernière fois, j'expliquerai 100 coups de science des données. Commentaire sur la science des données à 100 coups (P001 ~ 020) Commentaire sur la science des données à 100 coups (P021 ~ 040) Commentaire sur la science des données à 100 coups (P041 ~ 060)
Pour l'installation, veuillez consulter cet article (* Docker est géré sur Mac)
Fondamentalement, c'est une explication de la réponse, mais cela décrit également une autre solution.
P-061: Le montant des ventes (montant) du bloc de données de détail du reçu (df_receipt) est totalisé pour chaque ID client (customer_id), et le montant total des ventes est converti en une valeur logarithmique normale (base = 10) pour totaliser l'ID client et le montant des ventes. Afficher avec. Cependant, si l'ID client commence par "Z", il représente un non-membre, donc excluez-le du calcul. Vous pouvez afficher 10 résultats.
P-061
#N ° de client"Z"Sauf pour ceux commençant par
#Trame de données de détail du reçu (df_Le montant des ventes (montant) de la réception) est l'ID client (client)_id) total
df_sales_amount = df_receipt.query('not customer_id.str.startswith("Z")',
engine='python').groupby('customer_id').amount.sum().reset_index()
#Convertir le montant des ventes (montant) en logarithme régulier (en bas)=dix)
#maths appliquer avec appliquer.log10(x+1)Logarithmique régulière+1 est obligatoire.
df_sales_amount['amount_log10'] = df_amount_sum['amount'].apply(lambda x: math.log10(x+1))
df_sales_amount.head(10)
# (Une autre solution) np.en utilisant log10
df_sales_amount = df_receipt.query('not customer_id.str.startswith("Z")', engine='python'). \
groupby('customer_id').agg({'amount':'sum'}).reset_index()
df_sales_amount['amount_log10'] = np.log10(df_sales_amount['amount'] + 1)
df_sales_amount.head(10)
Référence: Calculer des fonctions exponentielles / logarithmiques avec Python (exp, log, log10, log2)
P-062: Le montant des ventes (montant) du bloc de données de détail du reçu (df_receipt) est totalisé pour chaque ID client (customer_id), et le montant total des ventes est converti en une valeur logarithmique naturelle (base = e) pour totaliser l'ID client et le montant des ventes. Afficher avec. Cependant, si l'ID client commence par "Z", il représente un non-membre, excluez-le du calcul. Vous pouvez afficher 10 résultats.
P-062
#N ° de client"Z"Sauf pour ceux commençant par
#Trame de données de détail du reçu (df_Le montant des ventes (montant) de la réception) est l'ID client (client)_id) total
df_sales_amount = df_receipt.query('not customer_id.str.startswith("Z")', engine='python') \
.groupby('customer_id').amount.sum().reset_index()
#Montant des ventes logarithmique naturel (montant)(bas=e) (rappelez-vous +1)
df_sales_amount['amount_log'] = np.log(df_sales_amount['amount'] + 1)
df_sales_amount.head()
# (Une autre solution)
df_sales_amount = df_receipt.query('not customer_id.str.startswith("Z")', engine='python'). \
groupby('customer_id').agg({'amount':'sum'}).reset_index()
df_sales_amount['amount_loge'] = np.log(df_sales_amount['amount'] + 1)
df_sales_amount.head(10)
Référence: Calculer des fonctions exponentielles / logarithmiques avec Python (exp, log, log10, log2)
P-063: Calculez le montant du profit de chaque produit à partir du prix unitaire (unit_price) et du coût (unit_cost) de la base de données produit (df_product). Vous pouvez afficher 10 résultats.
P-063
#Trame de données produit (df_copie du produit).
df_tmp = df_product.copy()
#Prix unitaire (unité)_price) au coût (unité)_coût) moins le montant du profit(unit_profit)Afficher
df_tmp['unit_profit'] = df_tmp['unit_price'] - df_tmp['unit_cost']
df_tmp.head(10)
P-064: Calculez la moyenne globale de la marge bénéficiaire de chaque produit à partir du prix unitaire (prix_unité) et du coût (coût_unité) de la base de données produit (df_product). Cependant, notez qu'il y a des NULL dans les prix unitaires et les coûts.
P-64
#Trame de données produit (df_copie du produit).
df_tmp = df_product.copy()
#Prix unitaire (unité)_price) au coût (unité)_Le prix unitaire (unitaire) moins le coût)_Prix) divisé par la marge bénéficiaire(unit_profit_rate)Afficher
df_tmp['unit_profit_rate'] = (df_tmp['unit_price'] - df_tmp['unit_cost']) / df_tmp['unit_price']
#Calculez le montant moyen des bénéfices(Hors Null: skipna=True)
df_tmp['unit_profit_rate'].mean(skipna=True)
P-065: Pour chaque produit de la base de données produit (df_product), trouvez un nouveau prix unitaire avec une marge bénéficiaire de 30%. Cependant, arrondissez à moins de 1 yen. Affichez ensuite 10 résultats et confirmez que la marge bénéficiaire est d'environ 30%. Cependant, notez qu'il y a des NULL dans le prix unitaire (unit_price) et le coût (unit_cost).
P-065
#Trame de données produit (df_copie du produit).
df_tmp = df_product.copy()
#Coût (unité)_coût) à une marge bénéficiaire de 30%Nouveau prix unitaire(new_price)Cherchant(Arrondir à moins de 1 yen)
#Coût (unité)_cost） x 10/7 (La marge bénéficiaire est de 30%Devient)une formule. math.le sol est une erreur
df_tmp['new_price'] = np.floor(df_tmp['unit_cost'] * 10/7)
#Vérifiez la marge bénéficiaire
df_tmp['new_price_rate'] = (df_tmp['new_price'] - df_tmp['unit_cost']) / df_tmp['new_price']
#Calculez le montant moyen des bénéfices(Hors Null)
df_tmp.head(10)
# (Une autre solution)
df_tmp = df_product.copy()
df_tmp['new_price'] = df_tmp['unit_cost'].apply(lambda x: np.floor(x / 0.7))
df_tmp['new_profit_rate'] = (df_tmp['new_price'] - df_tmp['unit_cost']) / df_tmp['new_price']
df_tmp.head(10)
Référence: [NumPy] nombre réel → entier (arrondi / arrondi / arrondi)
P-066: Trouvez un nouveau prix unitaire pour chaque produit dans la base de données produit (df_product) avec une marge bénéficiaire de 30%. Cette fois, arrondissez à moins de 1 yen (pour 0,5, arrondir dans le sens pair est très bien). Affichez ensuite 10 résultats et confirmez que la marge bénéficiaire est d'environ 30%. Cependant, notez qu'il y a des NULL dans le prix unitaire (unit_price) et le coût (unit_cost).
P-066
#Trame de données produit (df_copie du produit).
df_tmp = df_product.copy()
#Coût (unité)_coût) à une marge bénéficiaire de 30%Nouveau prix unitaire(new_price)Cherchant(Arrondir moins de 1 yen 0.Arrondir dans le même sens pour 5)
#Coût (unité)_cost） x 10/7 (La marge bénéficiaire est de 30%Devient)une formule.
df_tmp['new_price'] = np.round(df_tmp['unit_cost'] * 10/7)
#Vérifiez la marge bénéficiaire
df_tmp['new_price_rate'] = (df_tmp['new_price'] - df_tmp['unit_cost']) / df_tmp['new_price']
#Calculez le montant moyen des bénéfices(Hors Null)
df_tmp.head(10)
# (Une autre solution)
#La ronde intégrée donne une erreur avec NaN, mais numpy.round n'entraîne pas d'erreur
df_tmp = df_product.copy()
df_tmp['new_price'] = df_tmp['unit_cost'].apply(lambda x: np.round(x / 0.7))
df_tmp['new_profit_rate'] = (df_tmp['new_price'] - df_tmp['unit_cost']) / df_tmp['new_price']
df_tmp.head(10)
Référence: Nombres arrondis avec pandas (arrondis, arrondis à pair)
P-067: Trouvez un nouveau prix unitaire pour chaque produit dans la base de données produit (df_product) avec une marge bénéficiaire de 30%. Cette fois, arrondissez à moins de 1 yen. Affichez ensuite 10 résultats et confirmez que la marge bénéficiaire est d'environ 30%. Cependant, notez qu'il y a des NULL dans le prix unitaire (unit_price) et le coût (unit_cost).
P-067
#Trame de données produit (df_copie du produit).
df_tmp = df_product.copy()
#Coût (unité)_coût) à une marge bénéficiaire de 30%Nouveau prix unitaire(new_price)Cherchant(Arrondissez à moins de 1 yen)
#Coût (unité)_cost） x 10/7 (La marge bénéficiaire est de 30%Devient)une formule.
df_tmp['new_price'] = np.ceil(df_tmp['unit_cost'] * 10/7)
#Vérifiez la marge bénéficiaire
df_tmp['new_price_rate'] = (df_tmp['new_price'] - df_tmp['unit_cost']) / df_tmp['new_price']
#Calculez le montant moyen des bénéfices(Hors Null)
df_tmp.head(10)
# (Une autre solution)
#Exemple de code 1
# math.ceil donne une erreur avec NaN, mais numpy.ceil n'entraîne pas d'erreur
df_tmp = df_product.copy()
df_tmp['new_price'] = df_tmp['unit_cost'].apply(lambda x: np.ceil(x / 0.7))
df_tmp['new_profit_rate'] = (df_tmp['new_price'] - df_tmp['unit_cost']) / df_tmp['new_price']
df_tmp.head(10)
Référence: [NumPy] nombre réel → entier (arrondi / arrondi / arrondi)
P-068: Trouvez le montant TTC avec un taux de taxe à la consommation de 10% pour chaque produit de la base de données produit (df_product). Les fractions inférieures à 1 yen doivent être arrondies et 10 résultats doivent être affichés. Cependant, notez qu'il y a un NULL dans le prix unitaire (unit_price).
P-068
#Trame de données produit (df_copie du produit).
df_tmp = df_product.copy()
#Taux de la taxe à la consommation 10%Montant TTC(price_tax)Demander.(Prix unitaire (unité)_price)*1.1)
df_tmp['price_tax'] = np.floor(df_tmp['unit_price'] * 1.1)
df_tmp.head(10)
# (Une autre solution)
# math.floor donne une erreur avec NaN, mais numpy.le sol ne cause pas d'erreur
df_tmp = df_product.copy()
df_tmp['price_tax'] = df_tmp['unit_price'].apply(lambda x: np.floor(x * 1.1))
df_tmp.head(10)
Référence: Nombres arrondis avec pandas (arrondis, arrondis à pair)
P-069: Le bloc de données de détail de réception (df_receipt) et le bloc de données de produit (df_product) sont combinés, et le montant total des ventes de tous les produits pour chaque client et les ventes de "07" (en bouteille en conserve) dans la catégorie principale catégorie (category_major_cd) Calculez le montant total et trouvez le rapport entre les deux. L'objectif d'extraction est limité aux clients qui ont acheté la catégorie principale de la catégorie «07» (en bouteille et en conserve), et 10 résultats peuvent être affichés.
P-069
#Trame de données de détail du reçu (df_reçu) et le cadre de données produit (df_produit)(pd.merge,La clé est le produit_cd)
#Calculez le montant total des ventes de tous les produits pour chaque client
df_tmp_1 = pd.merge(df_receipt, df_product, on='product_cd',
how='inner').groupby('customer_id').amount.sum().reset_index()
#Catégorie_major_CD)"07"Montant total des ventes de (en conserve en bouteille)
# merge(df1, df2, on='Clé', how='inner')Combiner avec
#Regrouper par client. montant.sum()Montant total des ventes
df_tmp_2 = pd.merge(df_receipt, df_product.query('category_major_cd=="07"'), on='product_cd',
how='inner').groupby('customer_id').amount.sum().reset_index()
# df_tmp1 et df_Combinez tmp2.
df_tmp_3 = pd.merge(df_tmp_1, df_tmp_2, on='customer_id', how='inner')
#Trouvez le rapport des deux.
df_tmp_3['rate_07'] = df_tmp_3['amount_y'] / df_tmp_3['amount_x']
df_tmp_3.head(10)
# (Une autre solution) agg({colonne:Fonction à appliquer})
df_tmp_1 = pd.merge(df_receipt, df_product,
how='inner', on='product_cd').groupby('customer_id').agg({'amount':'sum'}).reset_index()
df_tmp_2 = pd.merge(df_receipt, df_product.query('category_major_cd == "07"'),
how='inner', on='product_cd').groupby('customer_id').agg({'amount':'sum'}).reset_index()
df_tmp_3 = pd.merge(df_tmp_1, df_tmp_2, how='inner', on='customer_id')
df_tmp_3['rate_07'] = df_tmp_3['amount_y'] / df_tmp_3['amount_x']
df_tmp_3.head(10)
Référence: fusionner, joindre (critères de colonne / d'index) pour rejoindre pandas.DataFrame
P-070: Calculez le nombre de jours écoulés entre la date de candidature du membre (date_application) du cadre de données client (df_customer) et la date de vente (sales_ymd) du bloc de données des détails de réception (df_receipt), et calculez l'ID client (customer_id) et la date de vente. , Affichage avec la date de candidature du membre. Vous pouvez afficher 10 résultats (notez que sales_ymd est une valeur numérique et application_date est une chaîne de caractères).
P-70
#Trame de données de détail du reçu (df_reçu) et trame de données client (df_client) pour rejoindre
df_tmp = pd.merge(df_receipt[['sales_ymd', 'customer_id']],
df_customer[['application_date', 'customer_id']], how='inner', on='customer_id')
#Supprimer les doublons
df_tmp = df_tmp.drop_duplicates()
#Date de la demande de membre (application_ventes à partir de la date_ymd) tirer
# pandas.to_datetime()Si vous utilisez la fonction, une chaîne de chaînes représentant la date et l'heure (date / heure) pandas.Série datetime64[ns]Peut être converti en un type.
# sales_Puisque ymd est un type numérique, astype('str')Passer au type de chaîne de caractères avec
df_tmp['elapsed_date'] = pd.to_datetime(df_tmp['sales_ymd'].astype('str')) - pd.to_datetime(df_tmp['application_date'])
df_tmp[['sales_ymd', 'application_date', 'elapsed_date']].head(10)
Référence: Extraire / supprimer les lignes en double de pandas.DataFrame, Series Référence: Traiter les colonnes date / heure avec pandas (conversion de chaîne de caractères, extraction de date, etc.)
P-071: Calculez le nombre de mois écoulés entre la date de candidature du membre (date_application) du cadre de données client (df_customer) et la date de vente (sales_ymd) du bloc de données des détails de réception (df_receipt), et calculez l'ID client (customer_id) et les ventes. Affichage avec la date et la date de demande d'adhésion. Vous pouvez afficher 10 résultats (notez que sales_ymd est une valeur numérique et application_date est une chaîne de caractères). Tronquez moins d'un mois.
P-071
# pd.Trame de données de détail de reçu avec fusion (df_reçu) et trame de données client (df_client) rejoindre(La clé est le client_id)
df_tmp = pd.merge(df_receipt[['customer_id', 'sales_ymd']],
df_customer[['customer_id', 'application_date']], how='inner', on='customer_id')
#Supprimer les doublons(drop_duplicates())
df_tmp = df_tmp.drop_duplicates()
# pandas.to_datetime()Si vous utilisez la fonction, une chaîne de chaînes représentant la date et l'heure (date / heure) pandas.Série datetime64[ns]Peut être converti en un type.
df_tmp['sales_ymd'] = pd.to_datetime(df_tmp['sales_ymd'].astype('str'))
df_tmp['application_date'] = pd.to_datetime(df_tmp['application_date'])
#Relativedelta pour calculer le nombre de mois(datetime1, datetime2) datetime1 - datetime2
df_tmp['elapsed_date'] = df_tmp[['sales_ymd', 'application_date']].apply(lambda x:
relativedelta(x[0], x[1]).years * 12 + relativedelta(x[0], x[1]).months, axis=1)
#Numéro client (client)_Trier par identifiant) et afficher 10 articles
df_tmp.sort_values('customer_id').head(10)
Référence: Comparaison date / heure Python / calcul / autres
P-072: Pour la date de vente (sales_ymd) du bloc de données des détails de réception (df_receipt), calculez le nombre d'années écoulées à partir de la date de candidature du membre (application_date) du bloc de données client (df_customer), et calculez l'ID client (customer_id) et la date de vente. , Affichage avec la date de candidature du membre. Vous pouvez afficher 10 résultats. (Notez que sales_ymd est une valeur numérique et application_date est une chaîne de caractères.) Tronquez moins d'un an.
P-072
# pd.Trame de données de détail de reçu avec fusion (df_reçu) et trame de données client (df_client) rejoindre(La clé est le client_id)
df_tmp = pd.merge(df_receipt[['customer_id', 'sales_ymd']],
df_customer[['customer_id', 'application_date']], how='inner', on='customer_id')
#Supprimer les doublons(drop_duplicates())
df_tmp = df_tmp.drop_duplicates()
# pandas.to_datetime()Si vous utilisez la fonction, une chaîne de chaînes représentant la date et l'heure (date / heure) pandas.Série datetime64[ns]Peut être converti en un type.
df_tmp['sales_ymd'] = pd.to_datetime(df_tmp['sales_ymd'].astype('str'))
df_tmp['application_date'] = pd.to_datetime(df_tmp['application_date'])
#Calculez le nombre d'années écoulées. relativedelta(datetime1, datetime2).Différence d'année en années(axis=Traitement le long de la ligne avec 1)
df_tmp['elapsed_date'] = df_tmp[['sales_ymd', 'application_date']].apply(lambda x:
relativedelta(x[0], x[1]).years, axis=1)
df_tmp.sort_values('customer_id').head(10)
Référence: Comparaison date / heure Python / calcul / autres
P-073: Pour la date de vente (sales_ymd) du bloc de données de détail de réception (df_receipt), le temps écoulé en secondes d'époque à partir de la date de candidature du membre (application_date) du bloc de données client (df_customer) est calculé, et l'ID client (customer_id) , Affichage avec date de vente et date de demande d'adhésion. Vous pouvez afficher 10 résultats (notez que sales_ymd est une valeur numérique et application_date est une chaîne de caractères). Étant donné que les informations d'heure ne sont pas conservées, chaque date représente 0:00:00.
P-073
# pd.Trame de données de détail de reçu avec fusion (df_reçu) et trame de données client (df_client) rejoindre(La clé est le client_id)
df_tmp = pd.merge(df_receipt[['customer_id', 'sales_ymd']],
df_customer[['customer_id', 'application_date']], how='inner', on='customer_id')
#Supprimer les doublons(drop_duplicates())
df_tmp = df_tmp.drop_duplicates()
# pandas.to_datetime()Lors de l'utilisation de la fonction, une chaîne de chaînes représentant la date et l'heure (date / heure) pandas.Série datetime64[ns]Peut être converti en un type.
df_tmp['sales_ymd'] = pd.to_datetime(df_tmp['sales_ymd'].astype('str'))
df_tmp['application_date'] = pd.to_datetime(df_tmp['application_date'])
#Calculer le temps écoulé en secondes d'époque(timestamp()Convertir un objet datetime en heure UNIX avec la méthode)
#Remarque: l'horodatage est l'heure unix (10), nanosecondes comprises**Diviser par 9)
df_tmp['elapsed_date'] = (df_tmp['sales_ymd'].astype(np.int64) / 10**9) - \
(df_tmp['application_date'].astype(np.int64) / 10 **9)
#Afficher 10 articles
df_tmp.head(10)
reference
#Pourquoi diviser par 10 à la 9e puissance?
nano_time = pd.to_datetime('1970-01-02')
nano_time.value
# >>>86400000000000
Puisque le temps de l'époque est le temps écoulé du 01/01/1970, 24 heures x 60 minutes x 60 secondes = 86400 secondes Il s'avère que le temps unix est de nanosecondes (10 à la 9e puissance)
Référence: Comparaison date / heure Python / calcul / autres
P-074: Pour la date de vente (sales_ymd) du bloc de données du relevé de réception (df_receipt), calculez le nombre de jours qui se sont écoulés depuis le mois de la semaine, et affichez-le avec la date de vente et la date du mois de la semaine. Vous pouvez afficher 10 résultats (notez que sales_ymd contient les données numériquement).
P-074
#Trame de données de détail du reçu (df_reçu) données client(customer_id),Date de vente (ventes)_ymd）
df_tmp = df_receipt[['customer_id', 'sales_ymd']]
#Supprimer les doublons
df_tmp = df_tmp.drop_duplicates()
# datetime64[ns]Convertir en type
df_tmp['sales_ymd'] = pd.to_datetime(df_tmp['sales_ymd'].astype('str'))
#Ajoutez les données du lundi.(relativedelta(days=x.weekday())Lundi: 0,Mardi: 1 ...)
df_tmp['monday'] = df_tmp['sales_ymd'].apply(lambda x: x - relativedelta(days=x.weekday()))
#Date de vente (ventes)_ymd) moins lundi pour trouver le nombre de jours écoulés
df_tmp['elapsed_weekday'] = df_tmp['sales_ymd'] - df_tmp['monday']
df_tmp.head(10)
Référence: Gestion du type de date / heure pandas (pd.to_datetime, pd.offsets, fuseau horaire)
P-075: Extraire aléatoirement 1% des données de la trame de données client (df_customer) et extraire les 10 premières données.
P-075
#Trame de données client (df_Extrait du client)(sample)
#Au hasard 1%Les données sont l'argument frac=0.01
df_customer.sample(frac=0.01).head(10)
Référence: échantillon qui échantillonne (extrait) de manière aléatoire les lignes et les colonnes de pandas
P-076: Stratifier et extraire aléatoirement 10% des données de la base de données client (df_customer) en fonction du rapport de genre (gender_cd), et agréger le nombre de cas par sexe.
P-076
# sklearn.model_selection.train_test_Exemple d'utilisation de la division
# _(Données d'entraînement 90%)、df_tmp(Données de test 10%)10% est extrait aléatoirement par(Extraction stratifiée:Argument stratifier)
_, df_tmp = train_test_split(df_customer, test_size=0.1, stratify=df_customer['gender_cd'])
#Le genre_Group by cd), client_Nombre d'identifiants(count)Agrégat
df_tmp.groupby('gender_cd').agg({'customer_id' : 'count'})
# (Une autre solution)
#Extrait aléatoirement en utilisant la méthode de l'échantillon(frac=0.Extraire 10% des données avec 1)
#Le genre_Group by cd), client_Nombre d'identifiants(count)Agrégat
df_customer.sample(frac=0.1).groupby('gender_cd').agg({'customer_id' : 'count'})
Référence: échantillon qui échantillonne (extrait) de manière aléatoire les lignes et les colonnes de pandas
P-077: Additionnez le montant des ventes (montant) du bloc de données de détail de la réception (df_receipt) pour chaque client, et extrayez la valeur aberrante du montant total des ventes. Cependant, si l'ID client commence par "Z", il représente un non-membre, excluez-le du calcul. Ici, on suppose que la valeur de l'écart est de 3σ ou plus par rapport à la moyenne. Vous pouvez afficher 10 résultats.
P-077
#N ° de client"Z"Excluez ceux commençant par
#Trame de données de détail du reçu (df_Montant total des ventes (montant) de la réception) pour chaque client
df_sales_amount = df_receipt.query("not customer_id.str.startswith('Z')",
engine='python').groupby('customer_id').amount.sum().reset_index()
#Normalisation / standardisation(Moyenne 0, écart type 1)：preprocessing.scale()Utilisez une fonction.
df_sales_amount['amount_ss'] = preprocessing.scale(df_sales_amount['amount'])
#Extraire les valeurs aberrantes(moyenne(mean)± 3σ(std)Extrayez ceux qui sont plus séparés)
#Extrayez ceux qui remplissent les conditions avec la méthode de requête. Valeurs absolues séparées par 3σ ou plus(abs)Utilisation
df_sales_amount.query('abs(amount_ss)>=3').head(10)
# (Une autre solution)
#N ° de client"Z"Excluez ceux commençant par
#Trame de données de détail du reçu (df_Montant total des ventes (montant) de la réception) pour chaque client
df_sales_amount = df_receipt.query("not customer_id.str.startswith('Z')",
engine='python').groupby('customer_id').amount.sum().reset_index()
#Trouvez la moyenne et l'écart type des ventes totales de chaque client
mean = df_sales_amount.describe().loc['mean']
std = df_sales_amount.describe().loc['std']
#Extraire les valeurs aberrantes(moyenne(mean)± 3σ(std)Extrayez ceux qui sont plus séparés)
df_sales_amount[(df_sales_amount['amount'] >= int(mean) + 3*int(std)) | \
(df_sales_amount['amount'] <= int(mean) - 3*int(std))].head(10)
Référence: Normaliser / Standardiser avec Python (List, NumPy Array, pandas.DataFrame)
P-078: Additionnez le montant des ventes (montant) du bloc de données de détail de la réception (df_receipt) pour chaque client, et extrayez la valeur aberrante du montant total des ventes. Cependant, si l'ID client commence par "Z", il représente un non-membre, excluez-le du calcul. Ici, en utilisant IQR, qui est la différence entre les premier et troisième quadrants, la valeur de l'écart est inférieure à "premier quadrant-1,5 x IQR", ou "troisième quadrant" Il doit dépasser "rang +1,5 x IQR". Vous pouvez afficher 10 résultats.
P-078
#N ° de client"Z"Excluez ceux commençant par
#Trame de données de détail du reçu (df_Montant total des ventes (montant) de la réception) pour chaque client
df_sales_amount = df_receipt.query("not customer_id.str.startswith('Z')",
engine='python').groupby('customer_id').amount.sum().reset_index()
#Trouvez l'IQR, qui est la différence entre le premier et le troisième quadrants
pct75 = df_sales_amount['amount'].quantile(0.75)
pct25 = df_sales_amount['amount'].quantile(0.25)
iqr = pct75 - pct25
#Premier quadrant-1.5×IQR(amount_low),Troisième quadrant+1.5×IQR(amount_hight)Demandez chacun
amount_low = pct25 - (iqr * 1.5)
amount_hight = pct75 + (iqr * 1.5)
#Extraire les valeurs aberrantes(@Nom de variable dans)
df_sales_amount.query('amount > @amount_hight | amount < @amount_low').head(10)
# (Une autre solution) np.Répondre en utilisant le centile
df_sales_amount = df_receipt.query('not customer_id.str.startswith("Z")', engine='python'). \
groupby('customer_id').agg({'amount':'sum'}).reset_index()
pct75 = np.percentile(df_sales_amount['amount'], q=75)
pct25 = np.percentile(df_sales_amount['amount'], q=25)
iqr = pct75 - pct25
amount_low = pct25 - (iqr * 1.5)
amount_hight = pct75 + (iqr * 1.5)
df_sales_amount.query('amount < @amount_low or @amount_hight < amount').head(10)
Référence: quantile pour obtenir les fractions / centiles avec les pandas
P-079: Vérifiez le nombre d'articles manquants pour chaque article dans le cadre de données produit (df_product).
P-079
# isnull()Jugez s'il s'agit d'une valeur manquante pour chaque élément avec
df_product.isnull().sum()
Référence: Jugez si la valeur manquante NaN est incluse dans les pandas, comptez le nombre
P-080: Créez un nouveau df_product_1 en supprimant tous les enregistrements manquants dans n'importe quel élément du bloc de données produit (df_product). De plus, affichez le nombre de cas avant et après la suppression et confirmez que le nombre a diminué du nombre confirmé à la question précédente.
P-080
#Trame de données produit (df_produit) copie
df_product_1 = df_product.copy()
#Vérifiez le nombre de cas avant de supprimer les valeurs manquantes
print('Avant suppression: ', len(df_product_1))
#Dropna pour exclure (supprimer) les valeurs manquantes()Méthode
df_product_1.dropna(inplace=True)
print('Après suppression: ', len(df_product_1))
Référence: Exclure (supprimer) / remplacer (remplir) / extraire la valeur manquante NaN avec pandas
100 coups de science des données Comment exécuter 100 frappes de science des données sur Mac
La difficulté varie en fonction du problème. Les choses difficiles sont difficiles.
Recommended Posts