Bei der Verarbeitung der Daten wurde daran gearbeitet, ungerade oder gerade Zeilen zu kennzeichnen. Zu dieser Zeit habe ich verschiedene Dinge versucht, um zu beschleunigen, also notieren Sie es sich.
Nehmen Sie als Voraussetzung an, dass Sie über die folgenden 10000 Zeilen Datenrahmen verfügen.
df = pd.DataFrame({'hoge':np.zeros(10000)}
df
| hoge | |
|---|---|
| 0 | 0.0 |
| 1 | 0.0 |
| 2 | 0.0 |
| 3 | 0.0 |
| 4 | 0.0 |
| ... | ... |
| 9995 | 0.0 |
| 9996 | 0.0 |
| 9997 | 0.0 |
| 9998 | 0.0 |
| 9999 | 0.0 |
Fügen Sie diesem Datenrahmen die folgende Spalte mit einem Flag in den ungeraden oder geraden Zeilen mit dem Namen "target_record" hinzu.
df['target_record'] = [1,0,1,0,1,...,0,1,0,1,0]
df
| hoge | target_record | |
|---|---|---|
| 0 | 0.0 | 1 |
| 1 | 0.0 | 0 |
| 2 | 0.0 | 1 |
| 3 | 0.0 | 0 |
| 4 | 0.0 | 1 |
| ... | ... | ... |
| 9995 | 0.0 | 0 |
| 9996 | 0.0 | 1 |
| 9997 | 0.0 | 0 |
| 9998 | 0.0 | 1 |
| 9999 | 0.0 | 0 |
Berechnen Sie die Zeit zum Erstellen dieser Spalte target_record. Die Verarbeitungszeit wurde übrigens als 10.000-mal gemessener Durchschnitt berechnet.
Zuallererst das einfachste? Vom Weg Fügen Sie eine Spalte 'a'target_record' hinzu, wobei allen Datensätzen 0 zugewiesen ist, und weisen Sie der angegebenen Zeile mit loc + Slice 1 zu.
df['target_record'] = 0
df.loc[0::2, 'target_record'] = 1 #Df für gerade Reihen.loc[1::2, 'target_record'] = 1
#Durchschnittliche Bearbeitungszeit: 0.0009912237882614137 sec
Übrigens mit iloc,
df['target_record'] = 0
df.iloc[0::2, 1] = 1
#Durchschnittliche Bearbeitungszeit: 0.0009658613920211792 sec
Ist es etwas schneller als loc?
Es ist eine berühmte Geschichte, dass die Verarbeitungsgeschwindigkeit von loc langsam ist. Erstellen Sie also ein Array mit numpy und weisen Sie Slices 1 zu.
target_record = np.zeros(10000, dtype=int)
target_record[0::2] = 1 #Ziel für gerade Reihen_record[1::2] = 1
df['target_record'] = target_record
#Durchschnittliche Bearbeitungszeit: 0.00035130116939544677 sec
Die Bearbeitungszeit wurde auf ca. 1/3 reduziert.
Erstellen Sie mit np.arange (10000) ein Array von 0 bis 9999 und ersetzen Sie den Wert des Restes geteilt durch 2.
target_record = np.arange(10000)
df['target_record'] = (target_record + 1) % 2 #Df für gerade Reihen['target_record'] = target_record % 2
#Durchschnittliche Bearbeitungszeit: 0.00046031529903411863 sec
Es ist ein wenig erfunden, aber es scheint, dass np.zeros + Slice 0,0001 Sekunden schneller ist.
Wenn Sie ungerade oder gerade Zeilen markieren, ist np.zeros + Slice das schnellste?
Übrigens, als ich die Zeit für jeden Prozess gemessen habe, wurde der Unterschied in der Verarbeitungsgeschwindigkeit geteilt. Der Unterschied bestand darin, ob der Rest berechnet oder in Scheiben ersetzt werden sollte. Es gab fast keinen Unterschied in der Verarbeitungsgeschwindigkeit zwischen np.zeros und np.arange (Nullen sind um 1.0e-06 Sekunden schneller).