[Pandas speedup] Signalez les lignes paires ou impaires

introduction

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.

Conditions préalables

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

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

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.

Comparaison de la vitesse de traitement

loc + tranche

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?

np.zeros + tranche

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.

np.arange + reste

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.

Résumé

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).