Je me suis promené dans le code github de l'auteur à chaque fois, je vais donc le rassembler pour une utilisation immédiate.
[Prétraitement complet [technique pratique SQL / R / Python pour l'analyse des données]](https://www.amazon.co.jp/%E5%89%8D%E5%87%A6%E7%90%86] % E5% A4% A7% E5% 85% A8% EF% BC% BB% E3% 83% 87% E3% 83% BC% E3% 82% BF% E5% 88% 86% E6% 9E% 90% E3 % 81% AE% E3% 81% 9F% E3% 82% 81% E3% 81% AESQL-R-Python% E5% AE% 9F% E8% B7% B5% E3% 83% 86% E3% 82% AF % E3% 83% 8B% E3% 83% 83% E3% 82% AF% EF% BC% BD-% E6% 9C% AC% E6% A9% 8B-% E6% 99% BA% E5% 85% 89 -ebook / dp / B07C3JFK3V)
https://github.com/ghmagazine/awesomebook
Extrayez la partie Python de github ci-dessous. Voir le livre pour des explications détaillées.
De plus, ces codes sources sont sous licence sous les termes BSD 3.
BSD 3-Clause License
Copyright (c) 2018, Tomomitsu Motohashi All rights reserved.
#Lire depuis la bibliothèque
from preprocess.load_data.data_loader import load_hotel_reserve
customer_tb, hotel_tb, reserve_tb = load_hotel_reserve()
#Lire à partir de CSV
reserve_tb = pd.read_csv('./data/reserve.csv', encoding='UTF-8')
#Vérification
reserve_tb.dtypes
print(type(reserve_tb))
#conversion
reserve_tb['people_num'] = reserve_tb['people_num'].astype('float64')
#Fonction ligne par iloc/Evitez de spécifier dans la colonne "Number" car ce sera un foyer de bogues.
#Cependant, KFold utilise iloc.
reserve_tb[['reserve_id','hotel_id','customer_id','reserve_datetime','checkin_date','checkin_time','checkout_date']]
reserve_tb.loc[:, ['reserve_id','hotel_id','customer_id','reserve_datetime','checkin_date','checkin_time','checkout_date']]
#Spécifiez la suppression de la colonne en définissant l'axe sur 1
#Réserver en spécifiant inplace comme True_Spécifier la réécriture tb
reserve_tb.drop(['people_num', 'total_price'], axis=1, inplace=True)
reserve_tb.query('"2016-10-13" <= checkout_date <= "2016-10-14"')
#Lors de la connexion des conditions avec et&
#Lors de la connexion des conditions avec ou|
# @var_Comme le nom@Vous pouvez utiliser les variables de la mémoire de Python en écrivant le nom de la variable à laquelle vous souhaitez vous référer après.
#La fonction de requête ne prend pas en charge dans.
#Échantillonnage de l'ID client et extraction de la transaction (réservation) correspondant à l'ID client extrait
# reserve_tb['customer_id'].unique()Est un client qui élimine la duplication_Renvoie l'ID
#pandas pour utiliser la fonction d'exemple.Series(Objet de la liste des pandas)Conversion en
#Exemple d'ID client avec fonction d'exemple
target = pd.Series(reserve_tb['customer_id'].unique()).sample(frac=0.5)
#Par la fonction isin, client_Extraire les lignes dont l'ID correspond à l'un des ID client échantillonnés
reserve_tb[reserve_tb['customer_id'].isin(target)]
# reserve_tb à 50%échantillonnage
reserve_tb.sample(frac=0.5)
hotel_Lorsque vous souhaitez effectuer un traitement d'agrégation pour chaque identifiant. client_Si vous souhaitez effectuer un traitement de comptage unique pour chaque identifiant
#Utilisez la fonction agg pour spécifier le traitement agrégé collectivement
# reserve_Appliquer la fonction de comptage pour l'id
# customer_Appliquer la fonction nunique pour l'ID
result = reserve_tb \
.groupby('hotel_id') \
.agg({'reserve_id': 'count', 'customer_id': 'nunique'})
# reset_Remplacer le numéro de colonne par la fonction d'index=Vrai, alors mettez à jour le résultat directement)
result.reset_index(inplace=True)
result.columns = ['hotel_id', 'rsv_cnt', 'cus_cnt']
#référence
#Ce que je veux faire: réserver_identifiant et client_Le nombre d'enregistrements où les deux identifiants sont dupliqués['dup']Stocker dans une colonne.
#Lorsque vous souhaitez ajouter un nombre de lignes en double à la fin d'un bloc de données. transformer('count')Utilisation
reserve_tb['dup'] = reserve_tb.groupby(['reserve_id','customer_id']).transform('count')
#S'il n'y a qu'un seul processus d'agrégation, il est plus facile d'écrire sans utiliser la fonction agg.
#Hôtel de l'unité d'agrégation_id et personnes_Spécifiez une combinaison de num
#Total à partir des données agrégées_Calculez le montant total des ventes en prenant le prix et en l'appliquant à la fonction de somme
result = reserve_tb \
.groupby(['hotel_id', 'people_num'])['total_price'] \
.sum().reset_index()
#Le nom de la colonne du montant total des ventes est total_Puisque c'est le prix, le prix_Changer en somme
result.rename(columns={'total_price': 'price_sum'}, inplace=True)
groupby-> combo agg
#Dans la fonction agg, spécifiez le processus d'agrégation de la valeur de la mosaïque en pourcentage dans la chaîne de caractères(q=20 choses)Comme cela ne peut pas être fait, il est spécifié à l'aide de l'expression lambda.
# total_max pour le prix/min/mean/Appliquer la fonction médiane
#Spécifiez l'expression lambda Python pour le traitement d'agrégation de la fonction agg
#Numpy pour l'expression lambda.Spécifiez le centile et calculez la valeur de la mosaïque en pourcentage (le pourcentage est égal à 20)
result = reserve_tb \
.groupby('hotel_id') \
.agg({'total_price': ['max', 'min', 'mean', 'median',
lambda x: np.percentile(x, q=20)]}) \
.reset_index()
result.columns = ['hotel_id', 'price_max', 'price_min', 'price_mean',
'price_median', 'price_20per']
# total_Appliquer la fonction var et la fonction std au prix pour calculer la valeur de dispersion et la valeur de l'écart type
result = reserve_tb \
.groupby('hotel_id') \
.agg({'total_price': ['var', 'std']}).reset_index()
result.columns = ['hotel_id', 'price_var', 'price_std']
#Lorsque le nombre de données est 1, la valeur de dispersion et la valeur de l'écart type sont na, remplacez-les par 0.
#La plage à remplacer est tous les NA du DataFrame, veillez donc à ne pas remplacer les valeurs non pertinentes.
result.fillna(0, inplace=True)
#Après avoir arrondi avec la fonction d'arrondi, calculez la valeur la plus fréquente avec la fonction de mode
reserve_tb['total_price'].round(-3).mode()
#Convertir le type de données de chaîne en type d'horodatage pour trier par fonction de classement
#(Explication dans "Chapitre 10 Type de date et d'heure")
reserve_tb['reserve_datetime'] = pd.to_datetime(
reserve_tb['reserve_datetime'], format='%Y-%m-%d %H:%M:%S'
)
# log_Ajouter non comme nouvelle colonne
#Spécifiez que l'unité d'agrégation est un groupe_Utiliser par
#Réserve organisée par client_Générer datetime et générer une fonction de classement par rang
#Définir par ordre croissant en définissant par ordre croissant sur True(Si False, définissez dans l'ordre décroissant)
reserve_tb['log_no'] = reserve_tb \
.groupby('customer_id')['reserve_datetime'] \
.rank(ascending=True, method='first')
#Rendre les données aussi petites que possible avant le processus de jointure
pd.merge(reserve_tb.query('people_num == 1'),
hotel_tb.query('is_business'),
on='hotel_id', how='inner')
#Lorsque vous souhaitez décaler n lignes et combiner (ajouter des données passées à la quantité d'entités, etc.)
#fonction de décalage:Une fonction qui peut déplacer les données vers le haut et vers le bas de n lignes
#Réservez pour chaque client_Trier par date / heure
#Trier par groupe en appliquant la fonction appliquer après la fonction groupby
# sort_Trier les données avec la fonction de valeurs, trier les lignes si l'axe est 0 et les colonnes si l'axe 1
result = reserve_tb \
.groupby('customer_id') \
.apply(lambda group:
group.sort_values(by='reserve_datetime', axis=0, inplace=False))
#le résultat est déjà client_Groupé par identifiant
#Deux totaux précédents pour chaque client_prix avant_Enregistrer comme prix
#La fonction shift est une fonction qui décale la ligne de données du nombre d'arguments de périodes.
result['before_price'] = \
pd.Series(result['total_price'].shift(periods=2))
-Comme python a un code long par rapport à SQL, il est préférable d'utiliser SQL lors du traitement qui nécessite la fonction Window. -SQL est extrêmement recommandé lors de l'exécution de traitements qui se combinent avec des données passées pendant une certaine période de temps. -La fonction de roulement ne peut sélectionner que sur sa propre ligne de données.
from preprocess.load_data.data_loader import load_monthly_index
monthly_index_tb = load_monthly_index()
#Ce livre commence par la ligne ci-dessous
# train_window_Spécifiez le numéro de ligne de départ des premières données d'entraînement dans start
train_window_start = 1
# train_window_Spécifiez le numéro de ligne de fin des premières données d'entraînement à la fin
train_window_end = 24
#Spécifiez le nombre de données de vérification à horizon
horizon = 12
#Définir le nombre de données à glisser pour ignorer
skip = 12
#Trier les données par année / mois
monthly_index_tb.sort_values(by='year_month')
while True:
#Calculez le numéro de ligne de fin des données de vérification
test_window_end = train_window_end + horizon
#Obtenez des données d'entraînement à partir des données d'origine en spécifiant le numéro de ligne
# train_window_Si vous fixez la partie de départ à 1, vous pouvez passer à la vérification qui augmente les données d'entraînement
train = monthly_index_tb[train_window_start:train_window_end]
#Obtenez les données de validation à partir des données d'origine en spécifiant le numéro de ligne
test = monthly_index_tb[(train_window_end + 1):test_window_end]
#Déterminer si le numéro de ligne de fin des données de vérification est supérieur ou égal au nombre de lignes dans les données d'origine
if test_window_end >= len(monthly_index_tb.index):
#Terminer lorsque toutes les données sont ciblées
break
#Faites glisser les données
train_window_start += skip
train_window_end += skip
#Résumer les résultats du test croisé
#appliquer la fonction
reserve_tb['total_price_log'] = \
reserve_tb['total_price'].apply(lambda x: np.log(x / 1000 + 1))
#Il n'y a pas de package qui résume les principales méthodes, vous devez l'implémenter vous-même
reserve_tb = reserve_tb[
(abs(reserve_tb['total_price'] - np.mean(reserve_tb['total_price'])) /
np.std(reserve_tb['total_price']) <= 3)
].reset_index()
#Datetime64 comme type de date[D]Vous pouvez également spécifier le type, mais datetime64[ns]À partir de datetime64[D]Parce qu'il y a de nombreux inconvénients tels que l'impossibilité de convertir
# datetime64[ns]Il est plus pratique d'extraire l'élément de date et d'heure après l'avoir converti en type.
# to_Avec la fonction datetime, datetime64[ns]Convertir en type
pd.to_datetime(reserve_tb['reserve_datetime'], format='%Y-%m-%d %H:%M:%S')
pd.to_datetime(reserve_tb['checkin_date'] + reserve_tb['checkin_time'],
format='%Y-%m-%d%H:%M:%S')
# datetime64[ns]Obtenir des informations sur la date à partir du type
pd.to_datetime(reserve_tb['reserve_datetime'],
format='%Y-%m-%d %H:%M:%S').dt.date
pd.to_datetime(reserve_tb['checkin_date'], format='%Y-%m-%d').dt.date
# reserve_datetime à datetime64[ns]Convertir en type
reserve_tb['reserve_datetime'] = \
pd.to_datetime(reserve_tb['reserve_datetime'], format='%Y-%m-%d %H:%M:%S')
#Obtenez l'année
reserve_tb['reserve_datetime'].dt.year
#Obtenez le mois
reserve_tb['reserve_datetime'].dt.month
#Obtenez la journée
reserve_tb['reserve_datetime'].dt.day
#Jour (0)=Obtenir la valeur numérique le dimanche, 1 = lundi)
reserve_tb['reserve_datetime'].dt.dayofweek
#Obtenez le temps du temps
reserve_tb['reserve_datetime'].dt.hour
#Obtenez les minutes de l'heure
reserve_tb['reserve_datetime'].dt.minute
#Obtenez les secondes du temps
reserve_tb['reserve_datetime'].dt.second
#Convertir en une chaîne au format spécifié
reserve_tb['reserve_datetime'].dt.strftime('%Y-%m-%d %H:%M:%S')
# datetime64[ns]Soustraction entre types
# reserve_datetime à datetime64[ns]Convertir en type
reserve_tb['reserve_datetime'] = \
pd.to_datetime(reserve_tb['reserve_datetime'], format='%Y-%m-%d %H:%M:%S')
# checkin_datetime à datetime64[ns]Convertir en type
reserve_tb['checkin_datetime'] = \
pd.to_datetime(reserve_tb['checkin_date'] + reserve_tb['checkin_time'],
format='%Y-%m-%d%H:%M:%S')
#Calculez la différence d'année (ne tenez pas compte des éléments de date et d'heure sous le mois)
reserve_tb['reserve_datetime'].dt.year - \
reserve_tb['checkin_datetime'].dt.year
#Obtenez la différence de mois (ne considérez pas les éléments de date et d'heure inférieurs au jour)
(reserve_tb['reserve_datetime'].dt.year * 12 +
reserve_tb['reserve_datetime'].dt.month) \
- (reserve_tb['checkin_datetime'].dt.year * 12 +
reserve_tb['checkin_datetime'].dt.month)
#Calculez la différence au quotidien
(reserve_tb['reserve_datetime'] - reserve_tb['checkin_datetime']) \
.astype('timedelta64[D]')
#Calculez la différence sur une base horaire
(reserve_tb['reserve_datetime'] - reserve_tb['checkin_datetime']) \
.astype('timedelta64[h]')
#Calculez la différence en minutes
(reserve_tb['reserve_datetime'] - reserve_tb['checkin_datetime']) \
.astype('timedelta64[m]')
#Calculez la différence en secondes
(reserve_tb['reserve_datetime'] - reserve_tb['checkin_datetime']) \
.astype('timedelta64[s]')
#Note
# timedelta64[D/h/m/s]Différence de jour par type/Temps/Minutes/Lorsqu'il est converti en secondes, le résultat de "l'arrondi" est renvoyé après la virgule décimale (contrairement à SQL et R).
#Par exemple, si la différence est de 2 jours et 3 heures et que vous convertissez en quotidien, 3(journée)Est retourné
# ???
#Même si vous regardez le site pandas, il semble qu'il a été tronqué.
# https://pandas.pydata.org/docs/user_guide/timedeltas.html
#Charger la bibliothèque datetime pour timedelta
import datetime
# reserve_datetime à datetime64[ns]Convertir en type
reserve_tb['reserve_datetime'] = \
pd.to_datetime(reserve_tb['reserve_datetime'], format='%Y-%m-%d %H:%M:%S')
# reserve_Extraire la date de datetime
reserve_tb['reserve_date'] = reserve_tb['reserve_datetime'].dt.date
# reserve_Ajouter 1 jour à datetime
reserve_tb['reserve_datetime'] + datetime.timedelta(days=1)
# reserve_Ajouter 1 jour à ce jour
reserve_tb['reserve_date'] + datetime.timedelta(days=1)
# reserve_Ajouter 1 heure à datetime
reserve_tb['reserve_datetime'] + datetime.timedelta(hours=1)
# reserve_Ajouter 1 minute à datetime
reserve_tb['reserve_datetime'] + datetime.timedelta(minutes=1)
# reserve_Ajouter 1 seconde à datetime
reserve_tb['reserve_datetime'] + datetime.timedelta(seconds=1)
# reserve_datetime à datetime64[ns]Convertir en type
reserve_tb['reserve_datetime'] = pd.to_datetime(
reserve_tb['reserve_datetime'], format='%Y-%m-%d %H:%M:%S'
)
#Fonction pour convertir les numéros de mois en saisons
def to_season(month_num):
season = 'winter'
if 3 <= month_num <= 5:
season = 'spring'
elif 6 <= month_num <= 8:
season = 'summer'
elif 9 <= month_num <= 11:
season = 'autumn'
return season
#Convertir en saison
reserve_tb['reserve_season'] = pd.Categorical(
reserve_tb['reserve_datetime'].dt.month.apply(to_season),
categories=['spring', 'summer', 'autumn', 'winter']
)
https://pandas.pydata.org/docs/user_guide/timedeltas.html
Recommended Posts