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)
Informationen zur Installation finden Sie in diesem Artikel (* Docker wird auf einem Mac verarbeitet)
Grundsätzlich ist es eine Erklärung der Antwort, aber es beschreibt auch eine andere Lösung.
P-061: Der Verkaufsbetrag (Betrag) des Belegdetail-Datenrahmens (df_receipt) wird für jede Kunden-ID (customer_id) summiert, und der Gesamtverkaufsbetrag wird in einen regulären logarithmischen Wert (Basis = 10) umgewandelt, um die Kunden-ID und den Verkaufsbetrag zu summieren Anzeige mit. Wenn die Kunden-ID jedoch mit "Z" beginnt, handelt es sich um ein Nichtmitglied. Schließen Sie sie daher von der Berechnung aus. Sie können 10 Ergebnisse anzeigen.
P-061
#Kundennummer"Z"Außer denen, die mit beginnen
#Belegdetail-Datenrahmen (df_Der Verkaufsbetrag (Betrag) des Eingangs) ist die Kunden-ID (Kunde)_id) gesamt
df_sales_amount = df_receipt.query('not customer_id.str.startswith("Z")',
engine='python').groupby('customer_id').amount.sum().reset_index()
#Konvertieren Sie den Verkaufsbetrag (Betrag) in den regulären Logarithmus (unten).=10)
#Mathe mit bewerben bewerben.log10(x+1)Regelmäßige logarithmische+1 ist erforderlich.
df_sales_amount['amount_log10'] = df_amount_sum['amount'].apply(lambda x: math.log10(x+1))
df_sales_amount.head(10)
# (Eine andere Lösung) np.mit 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)
Referenz: Exponential- / Logarithmusfunktionen mit Python berechnen (exp, log, log10, log2)
P-062: Der Verkaufsbetrag (Betrag) des Belegdetail-Datenrahmens (df_receipt) wird für jede Kunden-ID (customer_id) summiert, und der Gesamtverkaufsbetrag wird in einen natürlichen logarithmischen Wert (Basis = e) umgewandelt, um die Kunden-ID und den Verkaufsbetrag zu summieren. Anzeige mit. Wenn die Kunden-ID jedoch mit "Z" beginnt, handelt es sich um ein Nichtmitglied. Schließen Sie sie daher von der Berechnung aus. Sie können 10 Ergebnisse anzeigen.
P-062
#Kundennummer"Z"Außer denen, die mit beginnen
#Belegdetail-Datenrahmen (df_Der Verkaufsbetrag (Betrag) des Eingangs) ist die Kunden-ID (Kunde)_id) gesamt
df_sales_amount = df_receipt.query('not customer_id.str.startswith("Z")', engine='python') \
.groupby('customer_id').amount.sum().reset_index()
#Natürlicher logarithmischer Verkaufsbetrag (Betrag)(Unterseite=e) (erinnere dich an +1)
df_sales_amount['amount_log'] = np.log(df_sales_amount['amount'] + 1)
df_sales_amount.head()
# (Eine andere Lösung)
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)
Referenz: Exponential- / Logarithmusfunktionen mit Python berechnen (exp, log, log10, log2)
P-063: Berechnen Sie den Gewinnbetrag jedes Produkts aus dem Stückpreis (Einheitspreis) und den Kosten (Einheitskosten) des Produktdatenrahmens (df_product). Sie können 10 Ergebnisse anzeigen.
P-063
#Produktdatenrahmen (df_Produkt kopieren).
df_tmp = df_product.copy()
#Stückpreis (Stück)_Preis) zu Kosten (Einheit)_Kosten) abzüglich der Höhe des Gewinns(unit_profit)Anzeigen
df_tmp['unit_profit'] = df_tmp['unit_price'] - df_tmp['unit_cost']
df_tmp.head(10)
P-064: Berechnen Sie den Gesamtdurchschnitt der Gewinnspanne jedes Produkts aus dem Stückpreis (Einheitspreis) und den Kosten (Einheitskosten) des Produktdatenrahmens (df_product). Beachten Sie jedoch, dass die Stückpreise und -kosten NULL sind.
P-64
#Produktdatenrahmen (df_Produkt kopieren).
df_tmp = df_product.copy()
#Stückpreis (Stück)_Preis) zu Kosten (Einheit)_Der Stückpreis (Einheit) abzüglich der Kosten)_Preis) geteilt durch die Gewinnspanne(unit_profit_rate)Anzeigen
df_tmp['unit_profit_rate'] = (df_tmp['unit_price'] - df_tmp['unit_cost']) / df_tmp['unit_price']
#Berechnen Sie den durchschnittlichen Gewinn(Ohne Null: skipna=True)
df_tmp['unit_profit_rate'].mean(skipna=True)
P-065: Finden Sie einen neuen Stückpreis für jedes Produkt im Produktdatenrahmen (df_product) mit einer Gewinnspanne von 30%. Runden Sie jedoch weniger als 1 Yen ab. Zeigen Sie dann 10 Ergebnisse an und bestätigen Sie, dass die Gewinnspanne bei 30% liegt. Beachten Sie jedoch, dass der Einheitspreis (unit_price) und die Kosten (unit_cost) NULL-Werte enthalten.
P-065
#Produktdatenrahmen (df_Produkt kopieren).
df_tmp = df_product.copy()
#Kosteneinheit)_Kosten) auf eine Gewinnspanne von 30%Neuer Stückpreis(new_price)Ich suche(Runden Sie weniger als 1 Yen ab)
#Kosteneinheit)_cost） x 10/7 (Die Gewinnspanne beträgt 30%Wird)eine Formel. Mathematik.Boden ist ein Fehler
df_tmp['new_price'] = np.floor(df_tmp['unit_cost'] * 10/7)
#Überprüfen Sie die Gewinnspanne
df_tmp['new_price_rate'] = (df_tmp['new_price'] - df_tmp['unit_cost']) / df_tmp['new_price']
#Berechnen Sie den durchschnittlichen Gewinn(Ohne Null)
df_tmp.head(10)
# (Eine andere Lösung)
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)
Referenz: [NumPy] Reelle Zahl → Ganzzahl (Rundung / Rundung / Aufrundung)
P-066: Finden Sie einen neuen Stückpreis für jedes Produkt im Produktdatenrahmen (df_product) mit einer Gewinnspanne von 30%. Runden Sie diesmal weniger als 1 Yen ab (für 0,5 ist eine Rundung in die gleichmäßige Richtung in Ordnung). Zeigen Sie dann 10 Ergebnisse an und bestätigen Sie, dass die Gewinnspanne bei 30% liegt. Beachten Sie jedoch, dass der Einheitspreis (unit_price) und die Kosten (unit_cost) NULL-Werte enthalten.
P-066
#Produktdatenrahmen (df_Produkt kopieren).
df_tmp = df_product.copy()
#Kosteneinheit)_Kosten) auf eine Gewinnspanne von 30%Neuer Stückpreis(new_price)Ich suche(Runden Sie weniger als 1 Yen 0 ab.Rundung in gleichmäßige Richtung für 5)
#Kosteneinheit)_cost） x 10/7 (Die Gewinnspanne beträgt 30%Wird)eine Formel.
df_tmp['new_price'] = np.round(df_tmp['unit_cost'] * 10/7)
#Überprüfen Sie die Gewinnspanne
df_tmp['new_price_rate'] = (df_tmp['new_price'] - df_tmp['unit_cost']) / df_tmp['new_price']
#Berechnen Sie den durchschnittlichen Gewinn(Ohne Null)
df_tmp.head(10)
# (Eine andere Lösung)
#Die eingebaute Runde gibt einen Fehler mit NaN aus, aber numpy.Runde führt nicht zu einem Fehler
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)
Referenz: Zahlen mit Pandas runden (runden, auf gerade runden)
P-067: Finden Sie einen neuen Stückpreis für jedes Produkt im Produktdatenrahmen (df_product) mit einer Gewinnspanne von 30%. Runden Sie diesmal weniger als 1 Yen auf. Zeigen Sie dann 10 Ergebnisse an und bestätigen Sie, dass die Gewinnspanne bei 30% liegt. Beachten Sie jedoch, dass der Einheitspreis (unit_price) und die Kosten (unit_cost) NULL-Werte enthalten.
P-067
#Produktdatenrahmen (df_Produkt kopieren).
df_tmp = df_product.copy()
#Kosteneinheit)_Kosten) auf eine Gewinnspanne von 30%Neuer Stückpreis(new_price)Ich suche(Runden Sie weniger als 1 Yen auf)
#Kosteneinheit)_cost） x 10/7 (Die Gewinnspanne beträgt 30%Wird)eine Formel.
df_tmp['new_price'] = np.ceil(df_tmp['unit_cost'] * 10/7)
#Überprüfen Sie die Gewinnspanne
df_tmp['new_price_rate'] = (df_tmp['new_price'] - df_tmp['unit_cost']) / df_tmp['new_price']
#Berechnen Sie den durchschnittlichen Gewinn(Ohne Null)
df_tmp.head(10)
# (Eine andere Lösung)
#Codebeispiel 1
# math.Ceil gibt einen Fehler mit NaN, aber numpy.Ceil führt nicht zu einem Fehler
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)
Referenz: [NumPy] Reelle Zahl → Ganzzahl (Rundung / Rundung / Aufrundung)
P-068: Finden Sie den im Steuer enthaltenen Betrag mit einem Verbrauchsteuersatz von 10% für jedes Produkt im Produktdatenrahmen (df_product). Brüche unter 1 Yen sollten abgerundet und 10 Ergebnisse angezeigt werden. Beachten Sie jedoch, dass der Stückpreis (unit_price) NULL enthält.
P-068
#Produktdatenrahmen (df_Produkt kopieren).
df_tmp = df_product.copy()
#Verbrauchsteuersatz 10%Betrag inklusive Steuern(price_tax)Fragen.(Stückpreis (Stück)_price)*1.1)
df_tmp['price_tax'] = np.floor(df_tmp['unit_price'] * 1.1)
df_tmp.head(10)
# (Eine andere Lösung)
# math.Boden gibt einen Fehler mit NaN, aber numpy.Boden verursacht keinen Fehler
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)
Referenz: Zahlen mit Pandas runden (runden, auf gerade runden)
P-069: Kombinieren Sie den Belegdatenrahmen (df_receipt) und den Produktdatenrahmen (df_product) sowie den Gesamtumsatz aller Produkte für jeden Kunden und den Umsatz von "07" (in Dosen abgefüllt) in der Kategorie Hauptkategorie (category_major_cd). Berechnen Sie den Gesamtbetrag und ermitteln Sie das Verhältnis zwischen beiden. Es können nur Kunden extrahiert werden, die die Kategorie "07" (abgefüllt und in Dosen) gekauft haben, und es können 10 Ergebnisse angezeigt werden.
P-069
#Belegdetail-Datenrahmen (df_Quittung) und Produktdatenrahmen (df_Produkt)(pd.merge,Der Schlüssel ist das Produkt_cd)
#Berechnen Sie den Gesamtumsatz aller Produkte für jeden Kunden
df_tmp_1 = pd.merge(df_receipt, df_product, on='product_cd',
how='inner').groupby('customer_id').amount.sum().reset_index()
#Kategorie_major_CD)"07"Gesamtumsatz von (in Dosen abgefüllt)
# merge(df1, df2, on='Schlüssel', how='inner')Kombinieren mit
#Gruppe nach Kunden. Menge.sum()Gesamtumsatz
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 und df_Kombiniere tmp2.
df_tmp_3 = pd.merge(df_tmp_1, df_tmp_2, on='customer_id', how='inner')
#Finden Sie das Verhältnis der beiden.
df_tmp_3['rate_07'] = df_tmp_3['amount_y'] / df_tmp_3['amount_x']
df_tmp_3.head(10)
# (Eine andere Lösung) agg({Säule:Funktion anzuwenden})
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)
Referenz: Zusammenführen, Verbinden (Spalten- / Indexkriterien), um pandas.DataFrame beizutreten
P-070: Berechnen Sie die Anzahl der Tage, die vom Mitgliedsantragsdatum (application_date) des Kundendatenrahmens (df_customer) bis zum Verkaufsdatum (sales_ymd) des Belegdetaildatenrahmens (df_receipt) vergangen sind, und berechnen Sie die Kunden-ID (customer_id) und das Verkaufsdatum. , Anzeige mit dem Bewerbungsdatum des Mitglieds. Sie können 10 Ergebnisse anzeigen (beachten Sie, dass sales_ymd ein numerischer Wert und application_date eine Zeichenfolge ist).
P-70
#Belegdetail-Datenrahmen (df_Quittung) und Kundendatenrahmen (df_Kunde) beitreten
df_tmp = pd.merge(df_receipt[['sales_ymd', 'customer_id']],
df_customer[['application_date', 'customer_id']], how='inner', on='customer_id')
#Duplikate entfernen
df_tmp = df_tmp.drop_duplicates()
#Antragsdatum des Mitglieds (Antrag_Verkäufe ab Datum_ymd) ziehen
# pandas.to_datetime()Wenn Sie die Funktion verwenden, eine Zeichenfolge, die die Pandas für Datum und Uhrzeit (Datum / Uhrzeit) darstellt.Serie datetime64[ns]Kann in einen Typ konvertiert werden.
# sales_Da ymd ein numerischer Typ ist, Astype('str')Wechseln Sie zum Zeichenkettentyp mit
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)
Referenz: Doppelte Zeilen von pandas.DataFrame, Series extrahieren / löschen Referenz: Datums- / Zeitspalten mit Pandas verarbeiten (Zeichenfolgenkonvertierung, Datumsextraktion usw.)
P-071: Berechnen Sie für das Verkaufsdatum (sales_ymd) des Belegdaten-Datenrahmens (df_receipt) die Anzahl der Monate, die seit dem Mitgliedsanwendungsdatum (application_date) des Kundendatenrahmens (df_customer) vergangen sind, und berechnen Sie die Kunden-ID (customer_id) und den Umsatz. Anzeige mit Datum und Antragsdatum der Mitgliedschaft. Sie können 10 Ergebnisse anzeigen (beachten Sie, dass sales_ymd ein numerischer Wert und application_date eine Zeichenfolge ist). Schneiden Sie weniger als einen Monat ab.
P-071
# pd.Empfangsdetail-Datenrahmen mit Zusammenführung (df_Quittung) und Kundendatenrahmen (df_Kunde) beitreten(Der Schlüssel ist der Kunde_id)
df_tmp = pd.merge(df_receipt[['customer_id', 'sales_ymd']],
df_customer[['customer_id', 'application_date']], how='inner', on='customer_id')
#Duplikate entfernen(drop_duplicates())
df_tmp = df_tmp.drop_duplicates()
# pandas.to_datetime()Wenn Sie die Funktion verwenden, eine Zeichenfolge, die die Pandas für Datum und Uhrzeit (Datum / Uhrzeit) darstellt.Serie datetime64[ns]Kann in einen Typ konvertiert werden.
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 zur Berechnung der Anzahl der Monate(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)
#Kunden-ID (Kunde)_Nach ID sortieren) und 10 Elemente anzeigen
df_tmp.sort_values('customer_id').head(10)
Referenz: Python-Datums- / Zeitvergleich / Berechnung / andere
P-072: Berechnen Sie die Anzahl der Jahre, die vom Mitgliedsantragsdatum (Anwendungsdatum) des Kundendatenrahmens (df_customer) bis zum Verkaufsdatum (sales_ymd) des Belegdetaildatenrahmens (df_receipt) vergangen sind, und berechnen Sie die Kunden-ID (customer_id) und das Verkaufsdatum. , Anzeige mit dem Bewerbungsdatum des Mitglieds. Sie können 10 Ergebnisse anzeigen. (Beachten Sie, dass sales_ymd ein numerischer Wert und application_date eine Zeichenfolge ist.) Weniger als ein Jahr abschneiden.
P-072
# pd.Empfangsdetail-Datenrahmen mit Zusammenführung (df_Quittung) und Kundendatenrahmen (df_Kunde) beitreten(Der Schlüssel ist der Kunde_id)
df_tmp = pd.merge(df_receipt[['customer_id', 'sales_ymd']],
df_customer[['customer_id', 'application_date']], how='inner', on='customer_id')
#Duplikate entfernen(drop_duplicates())
df_tmp = df_tmp.drop_duplicates()
# pandas.to_datetime()Wenn Sie die Funktion verwenden, eine Zeichenfolge, die die Pandas für Datum und Uhrzeit (Datum / Uhrzeit) darstellt.Serie datetime64[ns]Kann in einen Typ konvertiert werden.
df_tmp['sales_ymd'] = pd.to_datetime(df_tmp['sales_ymd'].astype('str'))
df_tmp['application_date'] = pd.to_datetime(df_tmp['application_date'])
#Berechnen Sie die Anzahl der verstrichenen Jahre. relativedelta(datetime1, datetime2).Jahresunterschied in Jahren(axis=Verarbeitung entlang der Linie mit 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)
Referenz: Python-Datums- / Zeitvergleich / Berechnung / andere
P-073: Für das Verkaufsdatum (sales_ymd) des Datenrahmens für Belegdetails (df_receipt) wird die verstrichene Zeit in Epochensekunden ab dem Mitgliedsantragsdatum (application_date) des Kundendatenrahmens (df_customer) berechnet und die Kunden-ID (customer_id) berechnet. , Anzeige mit Verkaufsdatum und Antragsdatum der Mitgliedschaft. Sie können 10 Ergebnisse anzeigen (beachten Sie, dass sales_ymd ein numerischer Wert und application_date eine Zeichenfolge ist). Da die Zeitinformationen nicht gespeichert werden, steht jedes Datum für 0:00:00.
P-073
# pd.Empfangsdetail-Datenrahmen mit Zusammenführung (df_Quittung) und Kundendatenrahmen (df_Kunde) beitreten(Der Schlüssel ist der Kunde_id)
df_tmp = pd.merge(df_receipt[['customer_id', 'sales_ymd']],
df_customer[['customer_id', 'application_date']], how='inner', on='customer_id')
#Duplikate entfernen(drop_duplicates())
df_tmp = df_tmp.drop_duplicates()
# pandas.to_datetime()Wenn Sie die Funktion verwenden, eine Zeichenfolge, die die Pandas für Datum und Uhrzeit (Datum / Uhrzeit) darstellt.Serie datetime64[ns]Kann in einen Typ konvertiert werden.
df_tmp['sales_ymd'] = pd.to_datetime(df_tmp['sales_ymd'].astype('str'))
df_tmp['application_date'] = pd.to_datetime(df_tmp['application_date'])
#Berechnen Sie die verstrichene Zeit in Epochensekunden(timestamp()Konvertieren Sie das Datum / Uhrzeit-Objekt mit der Methode in die UNIX-Zeit)
#Hinweis: Der Zeitstempel ist die Unix-Zeit (10) einschließlich Nanosekunden**Teilen durch 9)
df_tmp['elapsed_date'] = (df_tmp['sales_ymd'].astype(np.int64) / 10**9) - \
(df_tmp['application_date'].astype(np.int64) / 10 **9)
#10 Elemente anzeigen
df_tmp.head(10)
reference
#Warum durch 10 zur 9. Potenz teilen?
nano_time = pd.to_datetime('1970-01-02')
nano_time.value
# >>>86400000000000
Da die Epochenzeit die vom 01.01.1970 verstrichene Zeit ist, sind 24 Stunden x 60 Minuten x 60 Sekunden = 86400 Sekunden Es stellt sich heraus, dass die Unix-Zeit Nanosekunden beträgt (10 bis 9 Potenz)
Referenz: Python-Datums- / Zeitvergleich / Berechnung / andere
P-074: Berechnen Sie für das Verkaufsdatum (sales_ymd) des Belegdetail-Datenrahmens (df_receipt) die Anzahl der Tage, die seit dem Montag der Woche vergangen sind, und zeigen Sie sie zusammen mit dem Verkaufsdatum und dem Datum des Montags der Woche an. Sie können 10 Ergebnisse anzeigen (beachten Sie, dass sales_ymd die Daten numerisch enthält).
P-074
#Belegdetail-Datenrahmen (df_Quittung) Kundendaten(customer_id),Verkaufsdatum (Verkauf)_ymd）
df_tmp = df_receipt[['customer_id', 'sales_ymd']]
#Duplikate entfernen
df_tmp = df_tmp.drop_duplicates()
# datetime64[ns]In Typ konvertieren
df_tmp['sales_ymd'] = pd.to_datetime(df_tmp['sales_ymd'].astype('str'))
#Montagsdaten hinzufügen.(relativedelta(days=x.weekday())Montag: 0,Dienstag: 1 ...)
df_tmp['monday'] = df_tmp['sales_ymd'].apply(lambda x: x - relativedelta(days=x.weekday()))
#Verkaufsdatum (Verkauf)_ymd) minus Montag, um die Anzahl der verstrichenen Tage zu ermitteln
df_tmp['elapsed_weekday'] = df_tmp['sales_ymd'] - df_tmp['monday']
df_tmp.head(10)
Referenz: Behandlung des Datasetime-Typs von Pandas (pd.to_datetime, pd.offsets, Zeitzone)
P-075: Extrahieren Sie zufällig 1% der Daten aus dem Kundendatenrahmen (df_customer) und extrahieren Sie die ersten 10 Daten.
P-075
#Kundendatenrahmen (df_Auszug aus dem Kunden)(sample)
#Zufällig 1%Daten sind das Argument frac=0.01
df_customer.sample(frac=0.01).head(10)
Referenz: Stichprobe, die zufällig Zeilen und Spalten von Pandas abtastet (extrahiert)
P-076: 10% der Daten werden zufällig aus dem Kundendatenrahmen (df_customer) basierend auf dem Verhältnis des Geschlechts (gender_cd) geschichtet und extrahiert und die Anzahl der Fälle nach Geschlecht aggregiert.
P-076
# sklearn.model_selection.train_test_Beispiel mit split
# _(Trainingsdaten 90%)、df_tmp(Testdaten 10%)10% werden zufällig von extrahiert(Geschichtete Extraktion:Argument schichten)
_, df_tmp = train_test_split(df_customer, test_size=0.1, stratify=df_customer['gender_cd'])
#Geschlecht_Gruppe nach CD), Kunde_Anzahl der IDs(count)Aggregat
df_tmp.groupby('gender_cd').agg({'customer_id' : 'count'})
# (Eine andere Lösung)
#Zufällig mit der Stichprobenmethode extrahiert(frac=0.Extrahieren Sie 10% Daten mit 1)
#Geschlecht_Gruppe nach CD), Kunde_Anzahl der IDs(count)Aggregat
df_customer.sample(frac=0.1).groupby('gender_cd').agg({'customer_id' : 'count'})
Referenz: Stichprobe, die zufällig Zeilen und Spalten von Pandas abtastet (extrahiert)
P-077: Summieren Sie den Verkaufsbetrag (Betrag) des Belegdetail-Datenrahmens (df_receipt) für jeden Kunden und extrahieren Sie den Ausreißer aus dem Gesamtverkaufsbetrag. Wenn die Kunden-ID jedoch mit "Z" beginnt, handelt es sich um ein Nichtmitglied. Schließen Sie sie daher von der Berechnung aus. Hierbei wird angenommen, dass der Abweichungswert 3σ oder mehr vom Durchschnitt entfernt ist. Sie können 10 Ergebnisse anzeigen.
P-077
#Kundennummer"Z"Schließen Sie diejenigen aus, die mit beginnen
#Belegdetail-Datenrahmen (df_Gesamtverkaufsbetrag (Belegbetrag) für jeden Kunden
df_sales_amount = df_receipt.query("not customer_id.str.startswith('Z')",
engine='python').groupby('customer_id').amount.sum().reset_index()
#Normalisierung / Standardisierung(Durchschnitt 0, Standardabweichung 1)：preprocessing.scale()Verwenden Sie eine Funktion.
df_sales_amount['amount_ss'] = preprocessing.scale(df_sales_amount['amount'])
#Ausreißer extrahieren(durchschnittlich(mean)± 3σ(std)Extrahieren Sie diejenigen, die weiter auseinander liegen)
#Extrahieren Sie diejenigen, die die Bedingungen erfüllen, mit der Abfragemethode. Absolutwerte getrennt durch 3σ oder mehr(abs)Verwenden
df_sales_amount.query('abs(amount_ss)>=3').head(10)
# (Eine andere Lösung)
#Kundennummer"Z"Schließen Sie diejenigen aus, die mit beginnen
#Belegdetail-Datenrahmen (df_Gesamtverkaufsbetrag (Belegbetrag) für jeden Kunden
df_sales_amount = df_receipt.query("not customer_id.str.startswith('Z')",
engine='python').groupby('customer_id').amount.sum().reset_index()
#Finden Sie den Durchschnitt und die Standardabweichung des Gesamtumsatzes jedes Kunden
mean = df_sales_amount.describe().loc['mean']
std = df_sales_amount.describe().loc['std']
#Ausreißer extrahieren(durchschnittlich(mean)± 3σ(std)Extrahieren Sie diejenigen, die weiter auseinander liegen)
df_sales_amount[(df_sales_amount['amount'] >= int(mean) + 3*int(std)) | \
(df_sales_amount['amount'] <= int(mean) - 3*int(std))].head(10)
Referenz: Normalisieren / Standardisieren mit Python (Liste, NumPy-Array, pandas.DataFrame)
P-078: Summieren Sie den Verkaufsbetrag (Betrag) des Belegdetail-Datenrahmens (df_receipt) für jeden Kunden und extrahieren Sie den Ausreißer aus dem Gesamtverkaufsbetrag. Wenn die Kunden-ID jedoch mit "Z" beginnt, handelt es sich um ein Nichtmitglied. Schließen Sie sie daher von der Berechnung aus. Hier ist unter Verwendung von IQR, der die Differenz zwischen dem ersten und dem dritten Quadranten darstellt, der Abweichungswert niedriger als "erster Quadrant - 1,5 x IQR" oder "dritter Quadrant". Es muss "Rang +1,5 x IQR" überschreiten. Sie können 10 Ergebnisse anzeigen.
P-078
#Kundennummer"Z"Schließen Sie diejenigen aus, die mit beginnen
#Belegdetail-Datenrahmen (df_Gesamtverkaufsbetrag (Belegbetrag) für jeden Kunden
df_sales_amount = df_receipt.query("not customer_id.str.startswith('Z')",
engine='python').groupby('customer_id').amount.sum().reset_index()
#Finden Sie den IQR, der den Unterschied zwischen dem ersten und dem dritten Quadranten darstellt
pct75 = df_sales_amount['amount'].quantile(0.75)
pct25 = df_sales_amount['amount'].quantile(0.25)
iqr = pct75 - pct25
#Erster Quadrant-1.5×IQR(amount_low),Dritter Quadrant+1.5×IQR(amount_hight)Fragen Sie nach jedem
amount_low = pct25 - (iqr * 1.5)
amount_hight = pct75 + (iqr * 1.5)
#Ausreißer extrahieren(@Variablenname in)
df_sales_amount.query('amount > @amount_hight | amount < @amount_low').head(10)
# (Eine andere Lösung) np.Antworte mit Perzentil
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)
Referenz: Quantil, um Brüche / Perzentile mit Pandas zu erhalten
P-079: Überprüfen Sie die Anzahl der fehlenden Artikel für jeden Artikel im Produktdatenrahmen (df_product).
P-079
# isnull()Beurteilen Sie, ob für jedes Element mit ein Wert fehlt
df_product.isnull().sum()
Referenz: Beurteilen Sie, ob der fehlende NaN-Wert in Pandas enthalten ist, zählen Sie die Anzahl
P-080: Erstellen Sie ein neues df_product_1, indem Sie alle Datensätze löschen, die in einem Element des Produktdatenrahmens (df_product) fehlen. Zeigen Sie außerdem die Anzahl der Fälle vor und nach dem Löschen an und bestätigen Sie, dass die Anzahl um die in der vorherigen Frage bestätigte Anzahl gesunken ist.
P-080
#Produktdatenrahmen (df_Produkt) Kopie
df_product_1 = df_product.copy()
#Überprüfen Sie die Anzahl der Fälle, bevor Sie fehlende Werte löschen
print('Vor dem Löschen: ', len(df_product_1))
#Dropna zum Ausschließen (Löschen) fehlender Werte()Methode
df_product_1.dropna(inplace=True)
print('Nach dem Löschen: ', len(df_product_1))
Referenz: Ausschließen (löschen) / ersetzen (ausfüllen) / fehlenden Wert NaN mit Pandas extrahieren
100 Schläge Data Science So führen Sie 100 Data Science-Schläge auf einem Mac aus
Die Schwierigkeit variiert je nach Problem. Schwierige Dinge sind schwierig.
Recommended Posts