[PYTHON] Data Science 100 Klopfkommentar (P081 ~ 100)

1. Zuallererst

Ich werde vom letzten Mal an 100 Schläge der Datenwissenschaft erklären. Data Science 100-Klopfkommentar (P001 ~ 020) Data Science 100-Klopfkommentar (P021 ~ 040) Data Science 100-Klopfkommentar (P041 ~ 060) Data Science 100-Klopfkommentar (P061 ~ 080)

Informationen zur Installation finden Sie in diesem Artikel (* Docker wird auf einem Mac verarbeitet)

2. Kommentar

P-081: Erstellen Sie ein neues df_product_2, das die fehlenden Werte für Einheitspreis (Einheitspreis) und Kosten (Einheitskosten) mit ihren jeweiligen Durchschnittswerten ergänzt. Der Durchschnittswert von weniger als 1 Yen kann gerundet werden, und 0,5 kann gleichmäßig gerundet werden. Vergewissern Sie sich nach der Implementierung des Supplements auch, dass bei jedem Artikel keine Mängel vorliegen.

P-081

#Füllen Sie fehlende Werte mit fillna aus.
# np.Runden Sie gerade Zahlen in Runde ab. np.Durchschnittswert ohne fehlende Werte mit Nanomittel
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()Auf Mängel prüfen
df_product2.isnull().sum()

Referenz: Zahlen mit Pandas runden (runden, auf gerade runden) Referenz: Berechnen Sie die Summe und den Durchschnitt des Arrays ndarray mit dem fehlenden Wert np.nan mit NumPy

P-082: Erstellen Sie ein neues df_product_3, das die fehlenden Werte für Einheitspreis (Einheitspreis) und Kosten (Einheitskosten) mit ihren jeweiligen Medianwerten ergänzt. Wenn der Medianwert weniger als 1 Yen beträgt, kann er gerundet werden, und wenn er 0,5 beträgt, kann er gleichmäßig versetzt werden. Vergewissern Sie sich nach der Implementierung des Supplements auch, dass bei jedem Artikel keine Mängel vorliegen.

P-082

#Verwenden Sie fillna für fehlende Werte
# np.Runden Sie gerade Zahlen in Runde ab. Median np.Ergänzung mit 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()Auf Mängel prüfen
df_product_3.isnull().sum()

Referenz: Zahlen mit Pandas runden (runden, auf gerade runden) Referenz: [NumPy] 11. Verschiedene Verarbeitungen in Bezug auf NaN des NumPy-Arrays

P-083: Erstellen Sie ein neues df_product_4, das die fehlenden Werte für Einheitspreis (Einheitspreis) und Kosten (Einheitskosten) mit dem Medianwert ergänzt, der für jede Unterkategorie (Kategorie_klein_cd) jedes Produkts berechnet wird. Wenn der Medianwert weniger als 1 Yen beträgt, kann er gerundet werden, und wenn er 0,5 beträgt, kann er gleichmäßig versetzt werden. Vergewissern Sie sich nach der Implementierung des Supplements auch, dass bei jedem Artikel keine Mängel vorliegen.

P-083

# (Lösung 1)
#Unterkategorie jedes Produkts_small_Berechnen Sie den Medianwert für jede CD)
df_tmp = df_product.groupby('category_small_cd').agg({'unit_price': 'median', 
                                                      'unit_cost': 'median'}).reset_index()
#Ändern Sie den Spaltennamen
df_tmp.columns = ['category_small_cd', 'median_price', 'median_cost']
#Produktdatenrahmen (df_Produkt) und einen Datenrahmen mit dem Median(df_tmp)Kombinieren
df_product_4 = pd.merge(df_product, df_tmp, how='inner', on='category_small_cd')
#Stückpreis (Stück)_Ergänzen Sie den Medianwert mit dem fehlenden Wert des Preises.(axis=1 gilt für jede Zeile)
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)
#Kosteneinheit)_Ergänzen Sie den Medianwert mit dem fehlenden Kostenwert.(axis=1 gilt für jede Zeile)
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()Auf Mängel prüfen
df_product_4.isnull().sum()

P-083

# (Lösung 2)
#Unterkategorie jedes Produkts_small_Berechnen Sie den Medianwert für jede CD)
df_tmp = df_product.groupby('category_small_cd').agg(median_price=('unit_price', 'median'), 
                                                     median_cost=('unit_cost', 'median')).reset_index()
#Produktdatenrahmen (df_Produkt) und einen Datenrahmen mit dem Median(df_tmp)Kombinieren
df_product_4 = pd.merge(df_product, df_tmp, how='inner', on='category_small_cd')
#Fehlender Wert mit Maske(Nan)Der Teil von ist eine Maske (so dass sie nicht gesehen werden kann)Und ersetzen Sie den Medianwert
# mask(Bedingungen zum Verstecken,Wert zu füllen)Abgerundet auf Abgerundet
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()Auf Mängel prüfen
df_product_4.isnull().sum()

P-083

# (Lösung 3)
#Produktdatenrahmen (df_Produkt) Kopie
df_product_4 = df_product.copy()
#Stückpreis (Stück)_Preis) und Kosten (Einheit)_Kosten) Führen Sie jeden Prozess durch
#Verwenden Sie fillna, um fehlende Werte einzugeben.
#Unterkategorie jedes Produkts_small_Berechnen Sie den Medianwert für jede CD). Verwenden Sie 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()Auf Mängel prüfen
df_product_4.isnull().sum()

Referenz: [NumPy] 11. Verschiedene Verarbeitungen in Bezug auf NaN des NumPy-Arrays Referenz: Detaillierter Auswahlprozess für Python-Pandas-Daten <Teil 2> Referenz: Grundlegende Unterschiede zwischen Pandas transformieren und anwenden

P-084: Berechnen Sie das Verhältnis von Verkäufen 2019 zu allen Verkäufen für den gesamten Zeitraum für alle Kunden im Kundendatenrahmen (df_customer). Wenn jedoch kein Verkaufsrekord vorhanden ist, behandeln Sie ihn als 0. Extrahieren Sie dann das berechnete Verhältnis über 0. Sie können 10 Ergebnisse anzeigen. Stellen Sie außerdem sicher, dass die erstellten Daten keine NA oder NAN haben.

P-084

#Belegdetail-Datenrahmen (df_Quittung) Verkauf_ymd extrahiert 2019(df_tmp1)
df_tmp_1 = df_receipt.query('20190101 <= sales_ymd <= 20191231')
#Kundendatenrahmen (df_Kunde) Kunde_Empfangsdetail-Datenrahmen mit nur ID und 2019 extrahiert(df_tmp1)Links verbinden
# customer_Gruppiert nach ID (zum Zeitpunkt der Kombination erhöht), Verkaufsbetrag(amount)Summe
#Ändern Sie den Spaltennamen(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'})

#Gesamtumsatz für alle Zeiträume nach Kunden
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 und df_Kombiniere tmp2(Verkäufe für 2019 und alle Perioden(amount)Zum Vergleich)
df_tmp = pd.merge(df_tmp1, df_tmp_2, how='inner', on='customer_id')
# #Ergänzen Sie jeden fehlenden Wert mit 0
df_tmp['amount_2019'] = df_tmp['amount_2019'].fillna(0)
df_tmp['amount'] = df_tmp['amount'].fillna(0)

#Prozentsatz(amount_rate)Die fehlenden Werte ausfüllen
df_tmp['amount_rate'] = df_tmp['amount_2019'] / df_tmp['amount']
df_tmp['amount_rate'] = df_tmp['amount_rate'].fillna(0)

#Prozentsatz(amount_rate)Zeigen Sie 10 Elemente mit mehr als 0 an
df_tmp.query('amount_rate > 0').head(10)

Referenz: Verwendung von Pandas (Merge, Join, Concat) Referenz: Zeilennamen / Spaltennamen von pandas.DataFrame ändern

P-085: Erstellen Sie einen neuen df_customer_1, indem Sie den Datenrahmen für die Längen- und Breitengradkonvertierung (df_geocode) mit der Postleitzahl (postal_cd) für alle Kunden im Kundendatenrahmen (df_customer) verknüpfen. Wenn jedoch mehrere Verknüpfungen hergestellt werden, berechnen Sie den Durchschnitt für jeden Längengrad (Längengrad) und Breitengrad (Breitengrad).

P-085

#Kundendatenrahmen (df_Kunde) und Datenrahmen für die Längen- und Breitengradumwandlung (df_Geocode)
df_customer_1 = pd.merge(df_customer[['customer_id', 'postal_cd']],
                         df_geocode[['postal_cd', 'longitude' ,'latitude']],
                         how='inner', on='postal_cd')

#Da es doppelte Datenrahmen für die Längen- / Breitengradkonvertierung gibt, werden mehrere Datenrahmen verknüpft.
# customer_Gruppiert nach ID, Durchschnitt für Längen- und Breitengrad
#Ändern Sie den Spaltennamen
df_customer_1 = df_customer_1.groupby('customer_id'). \
    agg({'longitude':'mean', 'latitude':'mean'}).reset_index(). \
    rename(columns={'longitude':'m_longitude', 'latitude':'m_latitude'})

#Kundendatenrahmen (df_Keine Vervielfältigung mit dem Kunden)(df_customer_1)Kombinieren
df_customer_1 = pd.merge(df_customer, df_customer_1, how='inner', on='customer_id')
df_customer_1.head(3)

Referenz: Verwendung von Pandas (Merge, Join, Concat) Referenz: Zeilennamen / Spaltennamen von pandas.DataFrame ändern

P-086: Kombinieren Sie den Kundendatenrahmen (df_customer_1) mit dem in der vorherigen Frage erstellten Breiten- und Längengrad mit dem Speicherdatenrahmen (df_store) unter Verwendung des Anwendungsspeichercodes (application_store_cd) als Schlüssel. Ermitteln Sie dann die Entfernung (km) anhand der Breiten- / Längengradinformationen (Längengrad) des Anwendungsspeichers und des Breiten- / Längengrads des Kunden und zeigen Sie diese zusammen mit der Kunden-ID (customer_id), der Kundenadresse (Adresse) und der Geschäftsadresse (Adresse) an. .. Die Berechnungsformel kann eine einfache Formel sein, es kann jedoch eine Bibliothek verwendet werden, die eine andere hochgenaue Methode verwendet. Es sollten nur 10 Ergebnisse angezeigt werden.

P-086

#Erstellen Sie eine Funktion der Berechnungsformel
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))

#Kundendatenrahmen mit Längen- und Breitengrad (df_customer_1) und Datenrahmen speichern (df_Mit Laden kombinieren)
df_tmp = pd.merge(df_customer_1, df_store, how='inner', 
                  left_on=['application_store_cd'], right_on=['store_cd'])

#Finde die Entfernung
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)


# (Eine andere Lösung)Muster mit Mathe
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: Im Kundendatenrahmen (df_customer) wird derselbe Kunde aufgrund von Anwendungen in verschiedenen Filialen mehrmals registriert. Betrachten Sie Kunden mit demselben Namen (Kundenname) und derselben Postleitzahl (Postleitzahl) wie denselben Kunden und erstellen Sie einen Nayori-Kundendatenrahmen (df_customer_u), der so benannt ist, dass es einen Kunden und einen Datensatz gibt. Für denselben Kunden bleibt jedoch derjenige mit dem höchsten Gesamtumsatz übrig, und für Kunden mit demselben Gesamtumsatz oder ohne Verkaufsaufzeichnung bleibt derjenige mit der kleineren Kunden-ID (customer_id) übrig.

P-087

#Belegdetail-Datenrahmen (df_Quittung) wird für jeden Kunden in Gruppen eingeteilt und der Gesamtumsatz summiert.
df_tmp = df_receipt.groupby('customer_id').agg({'amount': sum}).reset_index()

#Kundendatenrahmen (df_Kunde) und den Verkaufsbetrag für jeden zuvor erstellten Kunden
#Kundendatenrahmen (df_Links beitreten, um alle Schlüssel für den Kunden zu hinterlassen)(how='left')
#Aufsteigend nach Kunden und Sortieren der Beträge in absteigender Reihenfolge
df_customer_u = pd.merge(df_customer, df_tmp, how='left', on='customer_id'). \
                    sort_values(['amount', 'customer_id'], ascending=[False, True])

#Name (Kunde) soll 1 Kunde 1 Datensatz sein_Name) und Post_cd) Duplikate entfernen.(Durch das Sortieren verlassen Duplikate das erste)
df_customer_u.drop_duplicates(subset=['customer_name', 'postal_cd'], keep='first', inplace=True)

#Geben Sie die reduzierte Anzahl aus
print('Anzahl der Abnahme: ', len(df_customer) - len(df_customer_u))

Referenz: Datenverkettung / Join-Verarbeitung gemäß Python-Pandas-Diagramm Referenz: sort_values, sort_index zum Sortieren von pandas.DataFrame, Series Referenz: Doppelte Zeilen von pandas.DataFrame, Series extrahieren / löschen

P-088: Erstellen Sie basierend auf den in der vorherigen Frage erstellten Daten einen Datenrahmen (df_customer_n) mit einer integrierten Nayori-ID, die dem Kundendatenrahmen hinzugefügt wurde. Die integrierte Nayori-ID wird jedoch gemäß den folgenden Spezifikationen zugewiesen.

Nicht doppelte Kunden: Kunden-ID festlegen (customer_id) Doppelter Kunde: Legen Sie die Kunden-ID des in der vorherigen Frage extrahierten Datensatzes fest

P-088

#Kundendatenrahmen (df_Nayori Kundendatenrahmen (df) benannter Kunde)_customer_u) kombinieren
#* Name (Kunde)_Name) und Post_cd) schließt sich den Spielen an
df_customer_n = pd.merge(df_customer, df_customer_u[['customer_id', 'customer_name', 'postal_cd']],
                        how='inner', on=['customer_name', 'postal_cd'])
#Spaltennamen ändern
df_customer_n.rename(columns={'customer_id_x': 'customer_id', 'customer_id_y': 'integration_id'}, inplace=True)

#Finden Sie den Unterschied in der ID
print('Unterschied in der Anzahl der IDs', len(df_customer_n['customer_id'].unique()) - len(df_customer_n['integration_id'].unique()))

Referenz: Anzahl und Häufigkeit (Anzahl der Vorkommen) eindeutiger Elemente in Pandas zählen

P-089: Für Kunden mit Verkaufsunterlagen möchte ich diese in Trainingsdaten und Testdaten unterteilen, um ein Vorhersagemodell zu erstellen. Teilen Sie die Daten zufällig in einem Verhältnis von jeweils 8: 2.

P-089

#Erstellen Sie Kundendaten mit einem Verkaufsdatensatz(df_Kunde und df_Quittung kombinieren)
df_tmp = pd.merge(df_customer, df_receipt['customer_id'], how='inner', on='customer_id')

# df_Teilen Sie den Kunden in Trainingsdaten und Testdaten auf(train_test_split)Verwenden
df_train, df_test = train_test_split(df_tmp, test_size=0.2, random_state=71)

#Berechnen Sie das Verhältnis von Trainingsdaten und Testdaten
print('Trainingsdatenverhältnis: ', len(df_train) / len(df_tmp))
print('Testdatenverhältnis: ', len(df_test) / len(df_tmp))

Referenz: train_test_split, der Daten für Training und Test mit scicit-learn aufteilt

P-090: Der Datenrahmen der Empfangsbestätigung (df_receipt) enthält Daten vom 1. Januar 2017 bis zum 31. Oktober 2019. Aggregieren Sie den Verkaufsbetrag (Betrag) monatlich und erstellen Sie 3 Sätze von Modellbildungsdaten für 12 Monate zum Lernen und 6 Monate zum Testen.

P-090

#Belegdetail-Datenrahmen (df_Quittung) wird kopiert
df_tmp = df_receipt.copy()
# sales_Ändern Sie ymd von int64 in str und extrahieren Sie das Jahr und den Monat mithilfe von Slices
df_tmp['sales_ymd'] = df_tmp['sales_ymd'].astype('str').str[:6]

# sales_ymd(Jahr Monat)Gruppieren Sie nach und addieren Sie den Verkaufsbetrag (Betrag)
df_tmp = df_tmp.groupby('sales_ymd').agg({'amount': sum}).reset_index()

#Funktion zur Aufteilung in Trainingsdaten und Testdaten
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]

#Erstellen Sie 3 Sätze von Modellbildungsdaten
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)

(Ergänzung: Verstehe das Problem) Es gibt 3 Modelle mit 12-Monats-Daten für das Training und 6-Monats-Daten für das Testen.

Referenz: train_test_split, der Daten für Training und Test mit scicit-learn aufteilt

P-091: Unterstichprobe für jeden Kunden im Kundendatenrahmen (df_customer), sodass die Anzahl der Kunden mit Verkaufsrekord und die Anzahl der Kunden ohne Verkaufsrekord 1: 1 beträgt.

P-091

#Empfangsdetail-Datenrahmen (df_Quittung) wird nach Kunden gruppiert und die Verkäufe werden summiert
df_tmp = df_receipt.groupby('customer_id').agg({'amount': sum}).reset_index()
#Kundendatenrahmen (df_Kunden) und Belegdetail-Datenrahmen (df_Kassenbon)(Links verbinden)
df_tmp = pd.merge(df_customer, df_tmp, how='left', on='customer_id')

#Umsatzentwicklung(amount)Geben Sie 1 ein, falls vorhanden, 0, wenn nicht
df_tmp['buy_flg'] = df_tmp['amount'].apply(lambda x: 0 if np.isnan(x) else 1)

#Geben Sie die Anzahl der Kunden mit Verkaufsrekord und die Anzahl der Kunden ohne Verkaufsrekord aus
print('Nummer 0', len(df_tmp.query('buy_flg==0')))
print('Nummer 1', len(df_tmp.query('buy_flg==1')))

#Unterabtastung mit RandomUnderSampler
rs = RandomUnderSampler(random_state=71)
df_sample, _ = rs.fit_sample(df_tmp, df_tmp.buy_flg)

#Geben Sie die Anzahl der Kunden mit Verkaufsrekord und die Anzahl der Kunden ohne Verkaufsrekord aus
print('Nummer 0', len(df_sample.query('buy_flg==0')))
print('Nummer 1', len(df_sample.query('buy_flg==1')))

Referenz: [Kaggle] Ich habe versucht, mit unausgeglichenem Lernen eine Unterabtastung durchzuführen Referenz: Downsampling von unausgeglichenen Daten der Mehrklassenklassifizierung

P-092: Im Kundendatenrahmen (df_customer) werden Geschlechtsinformationen in einem denormalisierten Zustand gehalten. Normalisieren Sie dies auf den dritten.

P-092

#Kundendatenrahmen (df_Kunde) Geschlecht_CD-Vervielfältigung entfernen
df_gender = df_customer[['gender_cd', 'gender']].drop_duplicates()

#Geschlechtsdatenrahmen(df_gender)Entfernen Sie die Geschlechtsspalte aus dem Kundendatenrahmen
df_customer_s = df_customer.drop(columns='gender')

Referenz: Doppelte Zeilen von pandas.DataFrame, Series extrahieren / löschen

P-093: Der Produktdatenrahmen (df_product) enthält nur den Codewert jeder Kategorie, nicht den Kategorienamen. Erstellen Sie einen neuen Produktdatenrahmen mit dem Kategorienamen, indem Sie ihn in Kombination mit dem Kategoriedatenrahmen (df_category) denormalisieren.

P-093

#Produktdatenrahmen (df_Produkt) und Kategoriedatenrahmen (df_Kategorie)
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()

Der Schlüssel ist auf "category_small_cd" gesetzt, da es sich um eine Kategorie in "category_major_cd" und "category_medium_cd" handelt und nicht im Detail klassifiziert werden kann.

P-094: Geben Sie die Produktdaten mit dem zuvor erstellten Kategorienamen in eine Datei mit den folgenden Spezifikationen aus. Der Ausgabezielpfad befindet sich unter Daten. -File Format ist CSV (durch Kommas getrennt) ・ Mit Header ・ Der Zeichencode lautet UTF-8

P-094

# to_csv(Das Dateiformat ist CSV)Ausgabe mit
df_product_full.to_csv('./data/P_df_product_full_UTF-8_header.csv', encoding='UTF-8', index=False)


# (Eine andere Lösung)
#Codebeispiel 2 (mit Stückliste, um verstümmelte Zeichen in Excel zu vermeiden)
df_product_full.to_csv('./data/P_df_product_full_UTF-8_header.csv', 
                       encoding='utf_8_sig', 
                       index=False)

Referenz: CSV-Datei mit Pandas exportieren / hinzufügen (to_csv)

P-095: Geben Sie die Produktdaten mit dem zuvor erstellten Kategorienamen in eine Datei mit den folgenden Spezifikationen aus. Der Ausgabezielpfad befindet sich unter Daten. -File Format ist CSV (durch Kommas getrennt) ・ Mit Header ・ Der Zeichencode lautet CP932

P-095

# to_csv(Das Dateiformat ist CSV)Ausgabe mit
df_product_full.to_csv('./data/P_df_product_full_CP932_header.csv', encoding='CP932', index=False)

• Was ist CP932? * *
• Microsoft Code Page 932 (CP932) ist ein Zeichencode, der eine Erweiterung von Shift_JIS durch Microsoft- und MS-DOS-OEM-Anbieter darstellt. * *

Referenz: CSV-Datei mit Pandas exportieren / hinzufügen (to_csv)

P-096: Geben Sie die Produktdaten mit dem zuvor erstellten Kategorienamen in eine Datei mit den folgenden Spezifikationen aus. Der Ausgabezielpfad befindet sich unter Daten. -File Format ist CSV (durch Kommas getrennt) ・ Kein Header ・ Der Zeichencode lautet UTF-8

P-096

# to_csv(Das Dateiformat ist CSV)Ausgabe mit
df_product_full.to_csv('./data/P_df_product_full_UTF-8_noh.csv', header=False ,encoding='UTF-8', index=False)

Referenz: CSV-Datei mit Pandas exportieren / hinzufügen (to_csv)

P-097: Lesen Sie die Datei in dem zuvor erstellten Format und erstellen Sie einen Datenrahmen. Zeigen Sie auch die ersten 10 Fälle an und überprüfen Sie, ob sie korrekt aufgenommen wurden. -File Format ist CSV (durch Kommas getrennt) ・ Mit Header ・ Der Zeichencode lautet UTF-8

P-097

# read_Lesen Sie mit csv
df_tmp = pd.read_csv('./data/P_df_product_full_UTF-8_header.csv')
df_tmp.head(10)

Referenz: CSV / TsV-Datei mit Pandas lesen (read_csv, read_table)

P-098: Lesen Sie die Datei in dem zuvor erstellten Format und erstellen Sie einen Datenrahmen. Zeigen Sie auch die ersten 10 Fälle an und überprüfen Sie, ob sie korrekt aufgenommen wurden. -File Format ist CSV (durch Kommas getrennt) ・ Kein Header ・ Der Zeichencode lautet UTF-8

P-098

# read_Lesen Sie mit csv
df_tmp = pd.read_csv('./data/P_df_product_full_UTF-8_noh.csv', header=None)
df_tmp.head(10)

Referenz: CSV / TsV-Datei mit Pandas lesen (read_csv, read_table)

P-099: Geben Sie die Produktdaten mit dem zuvor erstellten Kategorienamen in eine Datei mit den folgenden Spezifikationen aus. Der Ausgabezielpfad befindet sich unter Daten. -File-Format ist TSV (tabulatorgetrennt) ・ Mit Header ・ Der Zeichencode lautet UTF-8

P-099

# to_csv(Das Dateiformat ist CSV)Ausgabe mit
#Tabulatorzeichen\Als tsv-Datei speichern, getrennt durch t
df_product_full.to_csv('./data/P_df_product_full_UTF-8_header.tsv', sep='\t', encoding='UTF-8', index=False)

Referenz: CSV-Datei mit Pandas exportieren / hinzufügen (to_csv)

P-100: Lesen Sie die Datei in dem zuvor erstellten Format und erstellen Sie einen Datenrahmen. Zeigen Sie auch die ersten 10 Fälle an und bestätigen Sie, dass sie korrekt aufgenommen wurden. -File-Format ist TSV (tabulatorgetrennt) ・ Mit Header ・ Der Zeichencode lautet UTF-8

P-100

#Lesen Sie TSV_Tabelle verwenden
df_tmp = pd.read_table('./data/P_df_product_full_UTF-8_header.tsv', encoding='utf-8')
df_tmp.head(10)

Referenz: CSV / TsV-Datei mit Pandas lesen (read_csv, read_table)

3. Referenzen

100 Schläge Data Science So führen Sie 100 Data Science-Schläge auf einem Mac aus

4. Eindrücke

Der Inhalt war bis 081-093 sehr zäh. Es gibt einige Stellen, an denen die Erklärung flach ist, daher werde ich die Erklärung verbessern, während ich sie überprüfe.