1.Tout d'abord

Dans la continuité de la dernière fois, je vais expliquer 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) Commentaire de la science des données à 100 coups (P061 ~ 080)

Pour l'installation, veuillez consulter cet article (* Docker est géré sur Mac)

2. Commentaire

P-081: Créez un nouveau df_product_2 qui complète les valeurs manquantes de prix unitaire (unit_price) et cost (unit_cost) avec leurs valeurs moyennes respectives. Si la valeur moyenne est inférieure à 1 yen, elle peut être arrondie et si elle est de 0,5, elle peut être uniformément compensée. Après avoir mis en œuvre le supplément, confirmez également qu'il n'y a aucun défaut dans chaque article.

`P-081`


#Remplissez les valeurs manquantes avec fillna.
# np.Arrondissez les nombres pairs en rond. np.Valeur moyenne hors valeurs manquantes avec nanmean
df_product_2 = df_product.fillna({'unit_price':np.round(np.nanmean(df_product['unit_price'])), 
                                  'unit_cost':np.round(np.nanmean(df_product['unit_cost']))})

# isnull().sum()Vérifiez les défauts dans
df_product2.isnull().sum()

Référence: Nombres arrondis avec pandas (arrondis, arrondis à pair) Référence: Calculer la somme et la moyenne du tableau ndarray contenant la valeur manquante np.nan avec NumPy

P-082: Créez un nouveau df_product_3 qui complète les valeurs manquantes de prix unitaire (unit_price) et cost (unit_cost) avec leurs valeurs médianes respectives. Si la valeur médiane est inférieure à 1 yen, elle peut être arrondie, et si elle est de 0,5, elle peut être uniformément compensée. Après avoir mis en œuvre le supplément, confirmez également qu'il n'y a aucun défaut dans chaque article.

`P-082`


#Utilisez fillna pour les valeurs manquantes
# np.Arrondissez les nombres pairs en rond. Np médian.Complément avec nanmedian
df_product_3 = df_product.fillna({'unit_price':np.round(np.nanmedian(df_product['unit_price'])), 
                                  'unit_cost':np.round(np.nanmedian(df_product['unit_cost']))})

# isnull().sum()Vérifiez les défauts dans
df_product_3.isnull().sum()

Référence: Nombres arrondis avec pandas (arrondis, arrondis à pair) Référence: [NumPy] 11. Divers traitements liés à NaN du tableau NumPy

P-083: Créez un nouveau df_product_4 qui complète les valeurs manquantes de prix unitaire (unit_price) et cost (unit_cost) avec la valeur médiane calculée pour chaque sous-catégorie (category_small_cd) de chaque produit. Si la valeur médiane est inférieure à 1 yen, elle peut être arrondie, et si elle est de 0,5, elle peut être uniformément compensée. Après avoir mis en œuvre le supplément, confirmez également qu'il n'y a aucun défaut dans chaque article.

`P-083`


# (Solution 1)
#Sous-catégorie de chaque produit_small_Calculez la valeur médiane de chaque cd)
df_tmp = df_product.groupby('category_small_cd').agg({'unit_price': 'median', 
                                                      'unit_cost': 'median'}).reset_index()
#Changer le nom de la colonne
df_tmp.columns = ['category_small_cd', 'median_price', 'median_cost']
#Trame de données produit (df_Product) et un bloc de données contenant la médiane(df_tmp)Combiner
df_product_4 = pd.merge(df_product, df_tmp, how='inner', on='category_small_cd')
#Prix unitaire (unité)_Compléter la valeur médiane à la valeur manquante du prix)(axis=1 s'applique à chaque ligne)
df_product_4['unit_price'] = df_product_4[['unit_price', 'median_price']]. \
                    apply(lambda x: np.round(x[1]) if np.isnan(x[0]) else x[0], axis=1)
#Coût (unité)_Compléter la valeur médiane à la valeur manquante du coût)(axis=1 s'applique à chaque ligne)
df_product_4['unit_cost'] = df_product_4[['unit_cost', 'median_cost']]. \
                    apply(lambda x: np.round(x[1]) if np.isnan(x[0]) else x[0], axis=1)

# isnull().sum()Vérifiez les défauts dans
df_product_4.isnull().sum()

`P-083`


# (Solution 2)
#Sous-catégorie de chaque produit_small_Calculez la valeur médiane de chaque cd)
df_tmp = df_product.groupby('category_small_cd').agg(median_price=('unit_price', 'median'), 
                                                     median_cost=('unit_cost', 'median')).reset_index()
#Trame de données produit (df_Product) et un bloc de données contenant la médiane(df_tmp)Combiner
df_product_4 = pd.merge(df_product, df_tmp, how='inner', on='category_small_cd')
#Valeur manquante à l'aide d'un masque(Nan)La partie de est un masque (de sorte qu'elle ne peut pas être vue)Et remplacez la valeur médiane
# mask(Conditions à cacher,Valeur à remplir), Arrondi à rond
df_product_4['unit_price'] = (df_product_4['unit_price'].mask(df_product_4['unit_price'].isnull(),
                                                             df_product_4['median_price'].round()))
df_product_4['unit_cost'] = (df_product_4['unit_cost'].mask(df_product_4['unit_cost'].isnull(),
                                                             df_product_4['median_price'].round()))

# isnull().sum()Vérifiez les défauts dans
df_product_4.isnull().sum()

`P-083`


# (Solution 3)
#Trame de données produit (df_produit) copie
df_product_4 = df_product.copy()
#Prix unitaire (unité)_prix) et coût (unité)_coût) Effectuer chaque processus
#Utilisez fillna pour remplir les valeurs manquantes.
#Sous-catégorie de chaque produit_small_Calculez la valeur médiane de chaque cd). Utilisez transform.
for x in ['unit_price', 'unit_cost']:
    df_product_4[x] = df_product_4[x].fillna(df_product_4.groupby('category_small_cd')[x]
                                            .transform('median').round())
    
# isnull().sum()Vérifiez les défauts dans
df_product_4.isnull().sum()

Référence: [NumPy] 11. Divers traitements liés à NaN du tableau NumPy Référence: Processus détaillé de sélection des données Python pandas <Partie 2> Référence: Différences de base entre la transformation Pandas et Apply

P-084: Calculez le ratio des ventes 2019 sur toutes les ventes pour toute la période pour tous les clients du bloc de données client (df_customer). Cependant, s'il n'y a pas d'enregistrement de ventes, traitez-le comme 0. Puis extrayez le rapport calculé sur 0. Vous pouvez afficher 10 résultats. Assurez-vous également que les données créées n'ont pas NA ou NAN.

`P-084`


#Trame de données de détail du reçu (df_reçu) ventes_extraits ymd 2019(df_tmp1)
df_tmp_1 = df_receipt.query('20190101 <= sales_ymd <= 20191231')
#Trame de données client (df_client) client_Trame de données de détail du reçu avec uniquement l'identifiant et 2019 extrait(df_tmp1)Joint gauche
# customer_Regrouper par identifiant (augmenté au moment de la combinaison) et montant des ventes(amount)Somme
#Changer le nom de la colonne(rename)
df_tmp_1 = pd.merge(df_customer['customer_id'], df_tmp_1[['customer_id', 'amount']], how='left', on='customer_id'). \
            groupby('customer_id').sum().reset_index().rename(columns={'amount': 'amount_2019'})

#Montant total des ventes pour toutes les périodes par client
df_tmp_2 = pd.merge(df_customer['customer_id'], df_receipt[['customer_id', 'amount']], how='left', on='customer_id'). \
            groupby('customer_id').sum().reset_index()

# df_tmp1 et df_Combiner tmp2(Ventes pour 2019 et toutes périodes(amount)En comparaison)
df_tmp = pd.merge(df_tmp1, df_tmp_2, how='inner', on='customer_id')
# #Complétez chaque valeur manquante par 0
df_tmp['amount_2019'] = df_tmp['amount_2019'].fillna(0)
df_tmp['amount'] = df_tmp['amount'].fillna(0)

#Pourcentage(amount_rate)Pour remplir les valeurs manquantes
df_tmp['amount_rate'] = df_tmp['amount_2019'] / df_tmp['amount']
df_tmp['amount_rate'] = df_tmp['amount_rate'].fillna(0)

#Pourcentage(amount_rate)Afficher 10 éléments avec plus de 0
df_tmp.query('amount_rate > 0').head(10)

Référence: Comment utiliser les pandas (fusion, jointure, concat) Référence: Changer le nom de ligne / nom de colonne de pandas.DataFrame

P-085: Créez un nouveau df_customer_1 en associant le bloc de données de conversion longitude-latitude (df_geocode) avec le code postal (postal_cd) pour tous les clients dans le bloc de données client (df_customer). Cependant, lorsque plusieurs liens sont établis, calculez la moyenne pour chacune des longitude (longitude) et latitude (latitude).

`P-085`


#Trame de données client (df_client) et trame de données pour la conversion longitude-latitude (df_géocode)
df_customer_1 = pd.merge(df_customer[['customer_id', 'postal_cd']],
                         df_geocode[['postal_cd', 'longitude' ,'latitude']],
                         how='inner', on='postal_cd')

#Puisqu'il existe des trames de données en double pour la conversion de longitude / latitude, plusieurs trames de données sont liées.
# customer_Regroupés par identifiant, moyenne de longitude et de latitude
#Changer le nom de la colonne
df_customer_1 = df_customer_1.groupby('customer_id'). \
    agg({'longitude':'mean', 'latitude':'mean'}).reset_index(). \
    rename(columns={'longitude':'m_longitude', 'latitude':'m_latitude'})

#Trame de données client (df_Pas de duplication avec le client)(df_customer_1)Combiner
df_customer_1 = pd.merge(df_customer, df_customer_1, how='inner', on='customer_id')
df_customer_1.head(3)

Référence: Comment utiliser les pandas (fusion, jointure, concat) Référence: Changer le nom de ligne / nom de colonne de pandas.DataFrame

P-086: Pour la trame de données client (df_customer_1) avec la latitude et la longitude créées dans la question précédente, combinez-la avec la trame de données du magasin (df_store) en utilisant le code du magasin d'applications (application_store_cd) comme clé. Ensuite, recherchez la distance (km) en utilisant les informations de latitude / longitude (longitude) du magasin d'applications et la latitude / longitude du client, et affichez-la avec l'ID client (customer_id), l'adresse du client (adresse) et l'adresse du magasin (adresse). .. La formule de calcul peut être une formule simple, mais une bibliothèque utilisant une autre méthode très précise peut être utilisée. Seuls 10 résultats doivent être affichés.

Latitude (radian): \ phi \\ Radian: \ lambda \\

Distance L = 6371 * arccos (sin \ phi_1 * sin \ phi_2 * + cos \phi_1 * cos \phi_2 * cos(\lambda_1 − \lambda_2))

`P-086`


#Créer une fonction de formule
def calc_distance(x1, y1, x2, y2):
    x1_r = np.radians(x1)
    x2_r = np.radians(x2)
    y1_r = np.radians(y1)
    y2_r = np.radians(y2)
    return 6371 * np.arccos(np.sin(y1_r) * np.sin(y2_r) 
                            + np.cos(y1_r) * np.cos(y2_r) 
                            * np.cos(x1_r - x2_r))

#Trame de données client avec latitude et longitude (df_customer_1) et stocker la trame de données (df_Combiner avec le magasin)
df_tmp = pd.merge(df_customer_1, df_store, how='inner', 
                  left_on=['application_store_cd'], right_on=['store_cd'])

#Trouvez la distance
df_tmp['distance'] = calc_distance(df_tmp['m_longitude'], df_tmp['m_latitude'],
                                          df_tmp['longitude'], df_tmp['latitude'])
df_tmp[['customer_id', 'address_x', 'address_y', 'distance']].head(10)


# (Une autre solution)Modèle utilisant les mathématiques
def calc_distance(x1, y1, x2, y2):
    distance = 6371 * math.acos(math.sin(math.radians(y1)) * math.sin(math.radians(y2)) 
                       + math.cos(math.radians(y1)) * math.cos(math.radians(y2)) 
                            * math.cos(math.radians(x1) - math.radians(x2)))
    return distance

df_tmp = pd.merge(df_customer_1, df_store, how='inner', left_on='application_store_cd', right_on='store_cd')    

df_tmp['distance'] =   df_tmp[['m_longitude', 'm_latitude','longitude', 'latitude']]. \
                                apply(lambda x: calc_distance(x[0], x[1], x[2], x[3]), axis=1)

df_tmp[['customer_id', 'address_x', 'address_y', 'distance']].head(10)

P-087: Dans la trame de données client (df_customer), le même client est enregistré plusieurs fois en raison d'applications dans différents magasins. Considérez les clients avec le même nom (nom_client) et le même code postal (cd_postal) que le même client et créez un cadre de données client Nayori (df_customer_u) nommé de manière à ce qu'il y ait un client et un enregistrement. Cependant, pour le même client, celui avec le montant total des ventes le plus élevé sera laissé, et pour les clients avec le même montant total des ventes ou sans enregistrement de ventes, celui avec le numéro d'identification client (customer_id) le plus petit sera laissé.

`P-087`


#Trame de données de détail du reçu (df_Reçu) est divisé en groupes pour chaque client et le montant total des ventes est totalisé.
df_tmp = df_receipt.groupby('customer_id').agg({'amount': sum}).reset_index()

#Trame de données client (df_client) et le montant des ventes pour chaque client créé précédemment
#Trame de données client (df_Rejoindre gauche pour laisser toutes les clés du client(how='left')
#Croissant par client et tri des montants par ordre décroissant
df_customer_u = pd.merge(df_customer, df_tmp, how='left', on='customer_id'). \
                    sort_values(['amount', 'customer_id'], ascending=[False, True])

#Nom (client) pour être 1 client 1 enregistrement_nom) et postal_cd) supprimer les doublons.(À la suite du tri, les doublons quittent le premier)
df_customer_u.drop_duplicates(subset=['customer_name', 'postal_cd'], keep='first', inplace=True)

#Sortie du nombre réduit
print('Nombre de diminution: ', len(df_customer) - len(df_customer_u))

Référence: Traitement de concaténation / jointure de données comme vu dans le diagramme pandas Python Référence: sort_values, sort_index pour trier pandas.DataFrame, Series Référence: Extraire / supprimer les lignes en double de pandas.DataFrame, Series

P-088: Sur la base des données créées dans la question précédente, créez un bloc de données (df_customer_n) avec un identifiant Nayori intégré ajouté au bloc de données client. Cependant, l'identifiant Nayori intégré doit être attribué conformément aux spécifications suivantes.

Clients non dupliqués: définir l'ID client (customer_id) Client en double: définissez l'ID client de l'enregistrement extrait à la question précédente

`P-088`


#Trame de données client (df_Nayori customer data frame (df) named customer)_customer_u) combiner
#* Nom (client)_nom) et postal_cd) rejoint les matchs
df_customer_n = pd.merge(df_customer, df_customer_u[['customer_id', 'customer_name', 'postal_cd']],
                        how='inner', on=['customer_name', 'postal_cd'])
#Changer le nom de la colonne
df_customer_n.rename(columns={'customer_id_x': 'customer_id', 'customer_id_y': 'integration_id'}, inplace=True)

#Trouvez la différence d'identité
print('Différence dans le nombre d'identifiants', len(df_customer_n['customer_id'].unique()) - len(df_customer_n['integration_id'].unique()))

Référence: Comptez le nombre et la fréquence (nombre d'occurrences) d'éléments uniques dans les pandas

P-089: Pour les clients ayant des dossiers de vente, je souhaite le diviser en données de formation et données de test afin de construire un modèle prédictif. Divisez les données au hasard dans un rapport de 8: 2 chacune.

`P-089`


#Créer des données client avec un enregistrement de vente(df_client et df_Combiner le reçu)
df_tmp = pd.merge(df_customer, df_receipt['customer_id'], how='inner', on='customer_id')

# df_Divisez le client en données de formation et données de test(train_test_split)Utilisation
df_train, df_test = train_test_split(df_tmp, test_size=0.2, random_state=71)

#Calculer le rapport entre les données d'entraînement et les données de test
print('Ratio de données d'entraînement: ', len(df_train) / len(df_tmp))
print('Rapport de données de test: ', len(df_test) / len(df_tmp))

Référence: train_test_split qui divise les données pour l'entraînement et les tests avec scicit-learn

P-090: La trame de données de détail du reçu (df_receipt) contient des données du 1er janvier 2017 au 31 octobre 2019. Regroupez le montant des ventes (montant) mensuellement et créez 3 ensembles de données de construction de modèles pendant 12 mois pour l'apprentissage et 6 mois pour les tests.

`P-090`


#Trame de données de détail du reçu (df_reçu) est copié
df_tmp = df_receipt.copy()
# sales_Changez ymd de int64 en type str et extrayez l'année et le mois à l'aide de tranches
df_tmp['sales_ymd'] = df_tmp['sales_ymd'].astype('str').str[:6]

# sales_ymd(Année mois)Regrouper et additionner le montant des ventes (montant)
df_tmp = df_tmp.groupby('sales_ymd').agg({'amount': sum}).reset_index()

#Fonction à diviser en données d'entraînement et données de test
def split_date(df, train_size, test_size, slide_window, start_point):
    train_start = start_point * slide_window
    test_start = train_start + train_size
    return df[train_start:test_start], df[test_start:test_start+test_size]

#Créer 3 ensembles de données de construction de modèles
df_train_1, df_test_1 = split_date(df_tmp, train_size=12, test_size=6, slide_window=6, start_point=0)
df_train_2, df_test_2 = split_date(df_tmp, train_size=12, test_size=6, slide_window=6, start_point=1)
df_train_3, df_test_3 = split_date(df_tmp, train_size=12, test_size=6, slide_window=6, start_point=2)

(Supplément: comprendre le problème) Il existe 3 modèles avec des données sur 12 mois pour l'apprentissage et des données sur 6 mois pour les tests.

modèle	Données d'entraînement	Données d'entraînement範囲	données de test	données de test範囲
Modèle 1	df_train_1	2017/Janvier-2017/décembre	df_train_1	2017/Janvier-2017/décembre
Modèle 2	df_train_2	2017/Juin-2018/juin	df_train_2	2018/Juin-2018/décembre
Modèle 3	df_train_3	2018/Janvier-2018/décembre	df_train_3	2019/Janvier-2019/juin

Référence: train_test_split qui divise les données pour l'entraînement et les tests avec scicit-learn

P-091: Pour chaque client du bloc de données client (df_customer), sous-échantillonnez afin que le nombre de clients avec enregistrement de ventes et le nombre de clients sans enregistrement de ventes soient de 1: 1.

`P-091`


#Trame de données de détail du reçu (df_Reçu) est groupé par client et les ventes sont totalisées
df_tmp = df_receipt.groupby('customer_id').agg({'amount': sum}).reset_index()
#Trame de données client (df_client) et trame de données de détail de réception (df_le reçu)(Joint gauche)
df_tmp = pd.merge(df_customer, df_tmp, how='left', on='customer_id')

#Performance de ventes(amount)Entrez 1 s'il y en a, 0 sinon
df_tmp['buy_flg'] = df_tmp['amount'].apply(lambda x: 0 if np.isnan(x) else 1)

#Sortie du nombre de clients avec enregistrement des ventes et du nombre de clients sans enregistrement des ventes
print('Nombre de 0', len(df_tmp.query('buy_flg==0')))
print('Nombre de 1', len(df_tmp.query('buy_flg==1')))

#Sous-échantillonnage avec RandomUnderSampler
rs = RandomUnderSampler(random_state=71)
df_sample, _ = rs.fit_sample(df_tmp, df_tmp.buy_flg)

#Sortie du nombre de clients avec enregistrement des ventes et du nombre de clients sans enregistrement des ventes
print('Nombre de 0', len(df_sample.query('buy_flg==0')))
print('Nombre de 1', len(df_sample.query('buy_flg==1')))

Référence: [Kaggle] J'ai essayé le sous-échantillonnage en utilisant imbalanced-learn Référence: sous-échantillonnage des données déséquilibrées de la classification multi-classes

P-092: Dans la trame de données client (df_customer), les informations de genre sont conservées dans un état dénormalisé. Normaliser cela au troisième.

`P-092`


#Trame de données client (df_client) sexe_Supprimer la duplication de CD
df_gender = df_customer[['gender_cd', 'gender']].drop_duplicates()

#Base de données de genre(df_gender)Supprimer la colonne de sexe du cadre de données client
df_customer_s = df_customer.drop(columns='gender')

Référence: Extraire / supprimer les lignes en double de pandas.DataFrame, Series

P-093: Le cadre de données produit (df_product) contient uniquement la valeur de code de chaque catégorie, pas le nom de la catégorie. Créez un nouveau cadre de données produit avec le nom de la catégorie en le dénormalisant en combinaison avec le cadre de données de catégorie (df_category).

`P-093`


#Trame de données produit (df_product) et le bloc de données de catégorie (df_Catégorie)
df_product_full = pd.merge(df_product,df_category[['category_small_cd', 'category_major_name', 
                                                   'category_medium_name', 'category_small_name']], 
                                                   how='inner', on='category_small_cd')
df_product_full.head()

La clé est définie sur "category_small_cd" car "category_major_cd" et "category_medium_cd" sont des catégories et ne peuvent pas être classées en détail. スクリーンショット 2020-09-06 10.20.26.png

P-094: Exportez les données du produit avec le nom de catégorie créé précédemment dans un fichier avec les spécifications suivantes. Le chemin de destination de sortie est sous les données. -Le format du fichier est CSV (séparé par des virgules) ・ Avec en-tête ・ Le code de caractère est UTF-8

`P-094`


# to_csv(Le format de fichier est CSV)Sortie utilisant
df_product_full.to_csv('./data/P_df_product_full_UTF-8_header.csv', encoding='UTF-8', index=False)


# (Une autre solution)
#Exemple de code 2 (avec BOM pour éviter les caractères déformés dans Excel)
df_product_full.to_csv('./data/P_df_product_full_UTF-8_header.csv', 
                       encoding='utf_8_sig', 
                       index=False)

Référence: Exporter / Ajouter un fichier csv avec pandas (to_csv)

P-095: Exportez les données du produit avec le nom de catégorie créé précédemment dans un fichier avec les spécifications suivantes. Le chemin de destination de sortie est sous les données. -Le format du fichier est CSV (séparé par des virgules) ・ Avec en-tête ・ Le code de caractère est CP932

`P-095`


# to_csv(Le format de fichier est CSV)Sortie utilisant
df_product_full.to_csv('./data/P_df_product_full_CP932_header.csv', encoding='CP932', index=False)

Qu'est-ce que le CP932? *
Page de code Microsoft 932 (CP932) est un code de caractère que les fournisseurs OEM Microsoft et MS-DOS ont indépendamment étendu Shift_JIS. *

Référence: Exporter / Ajouter un fichier csv avec pandas (to_csv)

P-096: Exportez les données du produit avec le nom de catégorie créé précédemment dans un fichier avec les spécifications suivantes. Le chemin de destination de sortie est sous les données. -Le format du fichier est CSV (séparé par des virgules) · Aucun en-tête ・ Le code de caractère est UTF-8

`P-096`


# to_csv(Le format de fichier est CSV)Sortie utilisant
df_product_full.to_csv('./data/P_df_product_full_UTF-8_noh.csv', header=False ,encoding='UTF-8', index=False)

Référence: Exporter / Ajouter un fichier csv avec pandas (to_csv)

P-097: Lisez le fichier au format suivant créé précédemment et créez un bloc de données. Aussi, affichez les 10 premiers éléments et vérifiez qu'ils sont correctement pris. -Le format du fichier est CSV (séparé par des virgules) ・ Avec en-tête ・ Le code de caractère est UTF-8

`P-097`


# read_Lire en utilisant csv
df_tmp = pd.read_csv('./data/P_df_product_full_UTF-8_header.csv')
df_tmp.head(10)

Référence: Lire le fichier csv / tsv avec pandas (read_csv, read_table)

P-098: Lisez le fichier au format suivant créé précédemment et créez un bloc de données. Aussi, affichez les 10 premiers cas et vérifiez qu'ils sont correctement pris. -Le format du fichier est CSV (séparé par des virgules) · Aucun en-tête ・ Le code de caractère est UTF-8

`P-098`


# read_Lire en utilisant csv
df_tmp = pd.read_csv('./data/P_df_product_full_UTF-8_noh.csv', header=None)
df_tmp.head(10)

Référence: Lire le fichier csv / tsv avec pandas (read_csv, read_table)

P-099: Exporte les données produit avec le nom de catégorie créé précédemment dans un fichier avec les spécifications suivantes. Le chemin de destination de sortie est sous les données. -Le format du fichier est TSV (délimité par des tabulations) ・ Avec en-tête ・ Le code de caractère est UTF-8

`P-099`


# to_csv(Le format de fichier est CSV)Sortie utilisant
#Caractère de tabulation\Enregistrer en tant que fichier tsv séparé par t
df_product_full.to_csv('./data/P_df_product_full_UTF-8_header.tsv', sep='\t', encoding='UTF-8', index=False)

Référence: Exporter / Ajouter un fichier csv avec pandas (to_csv)

P-100: Lisez le fichier au format suivant créé précédemment et créez un bloc de données. Aussi, affichez les 10 premiers cas et vérifiez qu'ils sont correctement pris. -Le format du fichier est TSV (délimité par des tabulations) ・ Avec en-tête ・ Le code de caractère est UTF-8

`P-100`


#Lire TSV_Utiliser le tableau
df_tmp = pd.read_table('./data/P_df_product_full_UTF-8_header.tsv', encoding='utf-8')
df_tmp.head(10)

Référence: Lire le fichier csv / tsv avec pandas (read_csv, read_table)

3. Références

100 coups de science des données Comment exécuter 100 frappes de science des données sur Mac

4. Impressions

Le contenu était très moelleux jusqu'au 081-093. Il y a des endroits où l'explication est superficielle, je vais donc améliorer l'explication tout en la révisant.

[PYTHON] Commentaire sur la science des données à 100 coups (P081 ~ 100)

1.Tout d'abord

2. Commentaire

P-081

P-082

P-083

P-083

P-083

P-084

P-085

P-086

P-087

P-088

P-089

P-090

P-091

P-092

P-093

P-094

P-095

P-096

P-097

P-098

P-099

P-100

3. Références

4. Impressions

`P-081`

`P-082`

`P-083`

`P-083`

`P-083`

`P-084`

`P-085`

`P-086`

`P-087`

`P-088`

`P-089`

`P-090`

`P-091`

`P-092`

`P-093`

`P-094`

`P-095`

`P-096`

`P-097`

`P-098`

`P-099`

`P-100`