浅谈Pandas dataframe数据处理方法的速度比较

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、pandas是什么？

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、使用步骤

1.引入库

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

2.读入数据

代码如下（示例）：

这篇文章主要介绍了浅谈Pandas dataframe数据处理方法的速度比较，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

 
数据修改主要以增删改差为主，这里比较几种写法在数据处理时间上的巨大差别。

数据量大概是500万行级别的数据，文件大小为100M。

1.iloc
iloc是一种速度极其慢的写法。这里我们对每个csv文件中的每一行循环再用iloc处理，示例代码如下：

1
2
for index in range(len(df)):
   df.iloc['attr'][index] = xxx
使用这种方法对五百万行的数据进行处理大概需要5个小时，实在是很慢。

2.at
at相比于iloc有了很大的性能提升，也是for循环处理，示例代码如下：

1
2
3
4
5
for i in range(len(df)):
  if df.at[i,'attr'] > 0:
    sum_positive += df.at[i,'attr']
  else:
    sum_negetive += df.at[i,'sttr']
在我的程序里at和iloc是可以通用的，用at，程序的速度会有大幅提高，大概10分钟，但是还不够。

3.apply(lambda x:...)
想说apply是因为我觉得for循环速度太慢，想在循环上对程序进行优化。然后网上有人说apply可以大幅度提升速度，然而经过测试发现在我的程序里，使用apply和for差不多吧，性能也一般。

4.直接用series处理
这才是真正优化for循环的方法，以上面at的程序为例，可以改写为：

1
2
sum_positive += df['attr'][df.attr > 0].sum()
sum_negative += df['attr'][df.attr < 0].sum()
将程序都改为series处理，快了很多，最后500万行的数据大概需要37秒能跑完，基本符合预期。

这里提两句关于dataframe属性筛选，也就是上面df.attr > 0这一部分。首先pandas这个属性筛选实在是很强大，很方便。

其次是我们属性筛选的时候不要去修改属性，而是修改后面的数字，比如，我们不要这样写：

float(df.attr )> 0，而是这样写：

df.attr > str(0)，因为df.attr作为属性是不能随便动的。

补充：pandas中DataFrame单个数据提取效率与修改效率

目标
使用pandas处理金融数据及建模中经常需要按时间序列顺序循DataFrame数据，读取具体位置的数据判断或修改。经验上这种操作要比直接对二维列表或者np.array格式数据慢的多，原因可能在于index及columns层次的查找（两个字典，都不是连续数组，每次查找定位都需要时间）和DataFrame中数据的内存布局，有机会以后再深入研究。

这里做一组数值实验对比几种方法的效率。

生成数据
先生成一个二维数组随机数作为DataFrame数据，不失一般性，并把列名、行名设为标记顺序的字符串。

1
2
3
4
5
6
7
8
9
10
11
import numpy as np
import pandas as pd
 
from copy import deepcopy
from time import time
 
np.random.seed(20000)
I = 900
df = pd.DataFrame(np.random.standard_normal((I, I)),
   columns=['c'+str(_) for _ in range(I)],
         index=['i'+str(_) for _ in range(I)])
然后从限定范围内随机生成取值位置，为了方便对比，把随机坐标与字符串名对应起来

1
2
3
4
5
columns_num = np.floor(np.random.uniform(0, 1, I) * I).astype(int)
index_num = np.floor(np.random.uniform(0, 1, I) * I).astype(int)
 
columns_str = ['c'+str(_) for _ in columns_num]
index_str = ['i'+str(_) for _ in index_num]
读取测试
首先传统方法，直接取columns及index中名称定位

1
2
3
4
5
6
7
t0 = time()
for m in columns_str:
  for n in index_str:
    c = df[m][n]
print(time()-t0)
 
6.789840459823608
先columns列名后在values中取行坐标，速度快了一些

1
2
3
4
5
6
7
t0 = time()
for m in columns_str:
  for n in index_num:
    c = df[m].values[n]
print(time()-t0)
 
1.9697318077087402
loc方法，速度和直接取columns及index中名称定位差不多

Python客栈送红包、纸质书

1
2
3
4
5
6
7
t0 = time()
for m in columns_str:
  for n in index_str:
    c = df.loc[n, m]
print(time()-t0)
 
5.661889314651489
at方法，比loc快一点，毕竟loc可以切片的

1
2
3
4
5
6
7
t0 = time()
for m in columns_str:
  for n in index_str:
    c = df.at[m, n]
print(time()-t0)
 
3.3770089149475098
假设知道具体横纵坐标后，我们再比较：

还是从取values开始，也很慢，看来每次从df中取values很耗时

1
2
3
4
5
6
7
t0 = time()
for m in columns_num:
  for n in index_num:
    c = df.values[n][m]
print(time()-t0)
 
6.041872024536133
iloc试一下，没什么区别

1
2
3
4
5
6
7
t0 = time()
for m in columns_num:
  for n in index_num:
    c = df.iloc[n, m]
print(time()-t0)
 
6.103677034378052
iat做对比，提升不大，有点失望

1
2
3
4
5
6
7
t0 = time()
for m in columns_num:
  for n in index_num:
    c = df.iat[n, m]
print(time()-t0)
 
4.375299692153931
最后最高效的方法，还是先取二维数组来再定位

1
2
3
4
5
6
7
8
t0 = time()
b = df.values
for m in columns_num:
  for n in index_num:
    c = b[n][m]
print(time()-t0)
 
0.6402544975280762
修改测试
重复刚才的过程，把对应值改为0作为简单测试方式，别忘了原始数据要备份

取columns及index中名称定位

1
2
3
4
5
6
7
8
df_backup = deepcopy(df)
t0 = time()
for m in columns_str:
  for n in index_str:
    df_backup[m][n] = 0.0
print(time()-t0)
 
41.99269938468933
先columns列名后在values中取行坐标

1
2
3
4
5
6
7
8
df_backup = deepcopy(df)
t0 = time()
for m in columns_str:
  for n in index_num:
    df_backup[m].values[n] = 0.0
print(time()-t0)
 
2.215076208114624
loc方法

1
2
3
4
5
6
7
8
df_backup = deepcopy(df)
t0 = time()
for m in columns_str:
  for n in index_str:
    df_backup.loc[n, m] = 0.0
print(time()-t0)
 
134.39290761947632
at方法，在修改数值上竟然比loc快这么多

1
2
3
4
5
6
7
8
df_backup = deepcopy(df)
t0 = time()
for m in columns_str:
  for n in index_str:
    df_backup.at[n, m] = 0.0
print(time()-t0)
 
4.7453413009643555
在values上改，也是不错的，和读取相近，看来还都是在每次提取values上耗时

1
2
3
4
5
6
7
8
df_backup = deepcopy(df)
t0 = time()
for m in columns_num:
  for n in index_num:
    df.values[n][m] = 0.0
print(time()-t0)
 
6.346027612686157
iloc方法

1
2
3
4
5
6
7
8
df_backup = deepcopy(df)
t0 = time()
for m in columns_num:
  for n in index_num:
    df.iloc[n, m] = 0.0
print(time()-t0)
 
122.33384037017822
iat方法

1
2
3
4
5
6
7
8
df_backup = deepcopy(df)
t0 = time()
for m in columns_num:
  for n in index_num:
    df.iat[n, m] = 0.0
print(time()-t0)
 
5.381632328033447
取二维数组来再定位

1
2
3
4
5
6
7
8
9
df_backup = deepcopy(df)
t0 = time()
b = df.values
for m in columns_num:
  for n in index_num:
    c = b[n][m]
print(time()-t0)
 
0.4298992156982422
总结
效率上肯定是直接取数值最优的，这次系统性比较做个记录。代码写的有点啰嗦了，不过方便复制实验。在建模级别的代码上我还是习惯于用第2种方法，主要是鉴于代码可读性、维护和修改上。代码会在key上告诉我这里是什么，直观易读。

以前也曾为了提高代码运行效率写过先提取二维数组的，但columns多了就很费劲，重读还需要转译一遍。当然也可以把数据写成类，但是感觉和pandas不好融合，从建模和研究效率上没有太好的解决方案。之后会找时间再研究DataFrame内部机制。

该处使用的url网络请求的数据。

---

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。