Lors du traitement des données, il y avait du travail pour marquer les lignes paires ou impaires. À ce moment-là, j'ai essayé différentes choses pour accélérer, alors prenez-en note.
Comme condition préalable, supposons que vous disposez des 10000 lignes de blocs de données suivantes.
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 |
Ajoutez la colonne suivante à ce bloc de données avec un indicateur sur les lignes impaires ou paires appelées "enregistrement_objectif".
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 |
Calculez le temps de création de cette colonne target_record. À propos, le temps de traitement a été calculé comme la moyenne mesurée 10 000 fois.
Tout d'abord, le plus simple? À partir de la voie Ajoutez une colonne "cible_enregistrement" avec 0 attribué à tous les enregistrements et attribuez 1 à la ligne spécifiée avec loc + slice.
df['target_record'] = 0
df.loc[0::2, 'target_record'] = 1 #Df pour les lignes paires.loc[1::2, 'target_record'] = 1
#Temps de traitement moyen: 0.0009912237882614137 sec
Au fait, avec iloc,
df['target_record'] = 0
df.iloc[0::2, 1] = 1
#Temps de traitement moyen: 0.0009658613920211792 sec
Est-ce un peu plus rapide que loc?
C'est une histoire célèbre que la vitesse de traitement de loc est lente, alors créez un tableau avec numpy et attribuez 1 à slice.
target_record = np.zeros(10000, dtype=int)
target_record[0::2] = 1 #Cible pour les lignes paires_record[1::2] = 1
df['target_record'] = target_record
#Temps de traitement moyen: 0.00035130116939544677 sec
Le temps de traitement a été réduit à environ 1/3.
Créez un tableau de 0 à 9999 avec np.arange (10000) et remplacez la valeur du reste par 2.
target_record = np.arange(10000)
df['target_record'] = (target_record + 1) % 2 #Df pour les lignes paires['target_record'] = target_record % 2
#Temps de traitement moyen: 0.00046031529903411863 sec
C'est un peu imaginé, mais il semble que la tranche np.zeros + soit 0,0001 seconde plus rapide.
Lorsque vous marquez des lignes impaires ou paires, np.zeros + slice est le plus rapide?
À propos, lorsque j'ai mesuré le temps de chaque processus, la différence de vitesse de traitement était divisée. La différence était de savoir s'il fallait calculer le reste ou le remplacer par tranches. Il n'y avait pratiquement aucune différence de vitesse de traitement entre np.zeros et np.arange (les zéros sont plus rapides de 1,0e-06 secondes).