python如何处理大数据

2016-05-16 23:05:32 Never_Stop_ 阅读数 2555
通常在python里,一个字典只有支持几万到几十万数据量的时候效率最高。字典太大并不适合这种数据类型。

列表也不是存贮效率高的一种方式,通常我们大数据量计算会使用array,最差也要使用blist。

另外range也不可以的。要用xrange。xrange通常不消耗多少内存。range会用很多内存。

你上面的文字描述也没有讲明白你的算法目标。如果你讲得清楚,可以直接帮你优化一下算法。

整型的KEY,完全可以不用字典,只需要一个索引加一个一个数组就可以解决。

2019-10-10 18:18:39 weixin_41334453 阅读数 222

今天为大家带来的内容是如何用Python处理大数据?3个小技巧助你提升效率(建议收藏)本文具有不错的参考意义,希望能够帮助到大家!

首先,提出个问题:如果你有个5、6 G 大小的文件,想把文件内容读出来做一些处理然后存到另外的文件去,你会使用什么进行处理呢?

解答:不用在线等,给几个错误示范:有人用multiprocessing 处理,但是效率非常低。于是,有人用python处理大文件还是会存在效率上的问题。因为效率只是和预期的时间有关,不会报错,报错代表程序本身出现问题了~

所以,为什么用python处理大文件总有效率问题?

如果工作需要,立刻处理一个大文件,你需要注意两点:

1、大型文件的读取效率

面对100w行的大型数据,经过测试各种文件读取方式,得出结论:

with open(filename,"rb") as f:
 for fLine in f:
 pass

方式最快,100w行全遍历2.7秒。

基本满足中大型文件处理效率需求。如果rb改为r,慢6倍。但是此方式处理文件,fLine为bytes类型。但是python自行断行,仍旧能很好的以行为单位处理读取内容。

2、文本处理效率问题

这里举例ascii定长文件,因为这个也并不是分隔符文件,所以打算采用列表操作实现数据分割。但是问题是处理20w条数据,时间急剧上升到12s。本以为是byte.decode增加了时间。遂去除decode全程bytes处理。但是发现效率还是很差。

那么关于python处理大文件的技巧,从网络整理三点:列表、文件属性、字典三个点来看看。

一. 列表处理

def fun(x):尽量选择集合、字典数据类型,千万不要选择列表,列表的查询速度会超级慢,同样的,在已经使用集合或字典的情况下,不要再转化成列表进行操作,比如:

如何用Python处理大数据?3个小技巧助你提升效率(建议收藏)

 

后者的速度会比前者快好多好多。

二. 对于文件属性

如果遇到某个文件,其中有属性相同的,但又不能进行去重操作,没有办法使用集合或字典时,可以增加属性,比如将原数据重新映射出一列计数属性,让每一条属性具有唯一性,从而可以用字典或集合处理:

return '(' + str(x) + ', 1)'
list(map(fun,[1,2,3]))

使用map函数将多个相同属性增加不同项。

三. 对于字典

多使用iteritems()少使用items(),iteritems()返回迭代器:

如何用Python处理大数据?3个小技巧助你提升效率(建议收藏)

 

字典的items函数返回的是键值对的元组的列表,而iteritems使用的是键值对的generator,items当使用时会调用整个列表 iteritems当使用时只会调用值。

除了以下5个python使用模块,你还有什么技巧解决大文件运行效率的问题吗?深入了解更多Python实用模块,快速提升工作效率~

如何用Python处理大数据?3个小技巧助你提升效率(建议收藏)

 

以上就是本文的全部内容啦!

python交流群:877562786(群里含大量学习资料,面试宝典等)

2017-08-29 10:18:08 u010035907 阅读数 28801

博文1:pandas.read_csv——分块读取大文件

http://blog.csdn.net/zm714981790/article/details/51375475

今天在读取一个超大csv文件的时候,遇到困难:

  • 首先使用office打不开
  • 然后在python中使用基本的pandas.read_csv打开文件时:MemoryError
  • 最后查阅read_csv文档发现可以分块读取。
  • read_csv中有个参数chunksize,通过指定一个chunksize分块大小来读取文件,返回的是一个可迭代的对象TextFileReader,IO Tools 举例如下:
In [138]: reader = pd.read_table('tmp.sv', sep='|', chunksize=4)

In [139]: reader
Out[139]: <pandas.io.parsers.TextFileReader at 0x120d2f290>

In [140]: for chunk in reader:
   .....:     print(chunk)
   .....: 
   Unnamed: 0         0         1         2         3
0           0  0.469112 -0.282863 -1.509059 -1.135632
1           1  1.212112 -0.173215  0.119209 -1.044236
2           2 -0.861849 -2.104569 -0.494929  1.071804
3           3  0.721555 -0.706771 -1.039575  0.271860
   Unnamed: 0         0         1         2         3
0           4 -0.424972  0.567020  0.276232 -1.087401
1           5 -0.673690  0.113648 -1.478427  0.524988
2           6  0.404705  0.577046 -1.715002 -1.039268
3           7 -0.370647 -1.157892 -1.344312  0.844885
   Unnamed: 0         0        1         2         3
0           8  1.075770 -0.10905  1.643563 -1.469388
1           9  0.357021 -0.67460 -1.776904 -0.968914
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 指定iterator=True 也可以返回一个可迭代对象TextFileReader :
In [141]: reader = pd.read_table('tmp.sv', sep='|', iterator=True)

In [142]: reader.get_chunk(5)
Out[142]: 
   Unnamed: 0         0         1         2         3
0           0  0.469112 -0.282863 -1.509059 -1.135632
1           1  1.212112 -0.173215  0.119209 -1.044236
2           2 -0.861849 -2.104569 -0.494929  1.071804
3           3  0.721555 -0.706771 -1.039575  0.271860
4           4 -0.424972  0.567020  0.276232 -1.087401
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

  • 我需要打开的数据集是个csv文件,大小为3.7G,并且对于数据一无所知,所以首先打开前5行观察数据的类型,列标签等等
chunks = pd.read_csv('train.csv',iterator = True)
chunk = chunks.get_chunk(5)
print chunk
'''
             date_time  site_name  posa_continent  user_location_country  
0  2014-08-11 07:46:59          2               3                     66   
1  2014-08-11 08:22:12          2               3                     66   
2  2014-08-11 08:24:33          2               3                     66   
3  2014-08-09 18:05:16          2               3                     66   
4  2014-08-09 18:08:18          2               3                     66   
'''
博文2:python大规模数据处理技巧之一:数据常用操作

http://blog.csdn.net/asdfg4381/article/details/51689344

面对读取上G的数据,Python不能像做简单代码验证那样随意,必须考虑到相应的代码的实现形式将对效率的影响。如下所示,对pandas对象的行计数实现方式不同,运行的效率差别非常大。虽然时间看起来都微不足道,但一旦运行次数达到百万级别时,其运行时间就根本不可能忽略不计了:

p1

故接下来的几个文章将会整理下渣渣在关于在大规模数据实践上遇到的一些问题,文章中总结的技巧基本是基于pandas,有错误之处望指正。

1、外部csv文件读写


大数据量csv读入到内存


  • 分析思路:数据量非常大时,比如一份银行一个月的流水账单,可能有高达几千万的record。对于一般性能的计算机,有或者是读入到特殊的数据结构中,内存的存储可能就非常吃力了。考虑到我们使用数据的实际情况,并不需要将所有的数据提取出内存。当然读入数据库是件比较明智的做法。若不用数据库呢?可将大文件拆分成小块按块读入后,这样可减少内存的存储与计算资源
  • 注意事项:open(file.csv)与pandas包的pd.read_csv(file.csv ): python32位的话会限制内存,提示太大的数据导致内存错误。解决方法是装python64位。如果嫌python各种包安装过程麻烦,可以直接安装Anaconda2 64位版本
  • 简易使用方法:
    chunker = pd.read_csv(PATH_LOAD, chunksize = CHUNK_SIZE)
  • 1
  • 1
  • 读取需要的列:
    columns = ("date_time",  "user_id")
    chunks_train = pd.read_csv(filename, usecols = columns, chunksize = 100000)
  • 1
  • 2
  • 1
  • 2

chunker对象指向了多个分块对象,但并没有将实际数据先读入,而是在提取数据时才将数据提取进来。数据的处理和清洗经常使用分块的方式处理,这能大大降低内存的使用量,但相比会更耗时一些

  • 分块读取chunk中的每一行:
    for rawPiece in chunker_rawData:
        current_chunk_size = len(rawPiece.index)   #rawPiece 是dataframe
        for i in range(current_chunk_size ):
            timeFlag = timeShape(rawPiece.ix[i])   #获取第i行的数据
  • 1
  • 2
  • 3
  • 4
  • 1
  • 2
  • 3
  • 4

将数据存到硬盘


  • 直接写出到磁盘:
    data.to_csv(path_save, index = False, mode = 'w')`
  • 1
  • 1
  • 分块写出到磁盘:
  1. 对于第一个分块使用pandas包的存储IO: 
    • 保留header信息,‘w’模式写入
    • data.to_csv(path_save, index = False, mode = 'w')
  2. 接下的分块写入 
    • 去除header信息,‘a’模式写入,即不删除原文档,接着原文档后继续写
    • data.to_csv(path_save, index = False, header = False, mode = a')
  • 少量的数据写出:

少量的数据用pickle(cPickle更快)输出和读取,非常方便 ,下面分别是写出和读入

写出:

    import cPickle as pickle
    def save_trainingSet(fileLoc, X, y):
        pack = [X, y]
        with open(fileLoc, 'w') as f:
            pickle.dump(pack, f)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

读入:

    import cPickle as pickle
    def read_trainingSet(fileLoc):
        with open(fileLoc, 'r') as f:
            pack = pickle.load(f)
        return pack[0], pack[1]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

高效读取外部csv到python内部的list数据结构


  • 效率低下的方法:使用pd读入需要从pd转换到python本身的数据结构,多此一举
    userList = []
    content = pd.read_csv(filename)
    for i in range(len(content)):
        line = content.ix[i]['id']
        userList.append(line)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5
  • 效率高的方法:直接将外部数据读入进来
    userList = []
    f = open(filename)
    content = f.readlines()
    for line in content:
        line = line.replace('\n', '').split(',')
        userList.append(line)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

2、数据分析时常用数据结构之间的转化


数据集的横向与纵向合并


  • 简单地横向合并数据集:
  • 问题分析: 
    • 纵向的合并使用list并不好,因为需要去拆解list的每一个行元素,并用extend去拓展每一行的纵向元素
    • 最好使用dataframe中的concat函数:c = pd.concat([a, b], axis = 1),当axis=0时表示合并行(以行为轴)
    inx1 = DataFrame(np.random.randn(nSample_neg), columns = ['randVal'])
    inx2 = DataFrame(range(nSample_neg), columns = ['inxVal'])
    inx = pd.concat([inx1, inx2], axis = 1)
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3
  • 类似数据库的表合并:join(待完整)
    ret = ret.join(dest_small, on="srch_destination_id", how='left', rsuffix="dest")
  • 1
  • 1
  • 简单纵向合并数据集:
  • 纵向合并数据集可以考虑一下几种方法: 
    • 读取数据为list格式,使用append函数逐行读取
    • 将数据集转换为pandas中的dataframe格式,使用dataframe的merge与concat方法
  • 方法: 
    • 方法一:使用dataframe读入,使用concat把每行并起来
    • 方法二:先使用list读入并起来,最后转换成dataframe
    • 方法三:先使用list读入并起来大块的list,每块list转换成dataframe后用concat合并起来
  • 比较:方法一由于concat的静态性,每次要重新分配资源,故跑起来很慢; 方法二与三:会快很多,但具体没有测试,以下是使用方法三的代码:
    data = []
    cleanedPiece = []
    for i in range(CHUNK_SIZE):
        line = rawPiece.ix[i]
        uid = [line['user_id'], line['item_id'],
            line['behavior_type'], timeFlag]
        cleanedPiece.append(uid)
    cleanedPiece = DataFrame(cleanedPiece, columns = columns)
    data = pd.concat([data, cleanedPiece], axis = 0)



2015-12-14 15:35:05 djd1234567 阅读数 2618

python

python 能处理数据库中百万行级的数据吗?处理大规模数据时有那些常用的python库,他们有什么优缺点?适用范围如何?

来自知乎小伙伴王守崑的回答:

需要澄清两点之后才可以比较全面的看这个问题:

1. 百万行级不算大数据量,以目前的互联网应用来看,大数据量的起点是10亿条以上。

2. 处理的具体含义,如果是数据载入和分发,用python是很高效的;如果是求一些常用的统计量和求一些基本算法的结果,python也有现成的高效的库,C实现的和并行化的;如果是纯粹自己写的算法,没有任何其他可借鉴的,什么库也用不上,用纯python写是自讨苦吃。

python的优势不在于运行效率,而在于开发效率和高可维护性。针对特定的问题挑选合适的工具,本身也是一项技术能力。

来自知乎小伙伴郭宽的回答:

这要看具体的应用场景,从本质上来说,我们把问题分解为两个方面:

1、CPU密集型操作
即我们要计算的大数据,大部分时间都在做一些数据计算,比如求逆矩阵、向量相似度、在内存中分词等等,这种情况对语言的高效性非常依赖,Python做此类工作的时候必然性能低下。

2、IO密集型操作
假如大数据涉及到频繁的IO操作,比如从数据流中每次读取一行,然后不做什么复杂的计算,频繁的输入输出到文件系统,由于这些操作都是调用的操作系统接口,所以用什么语言已经不在重要了。

结论
用Python来做整个流程的框架,然后核心的CPU密集操作部分调用C函数,这样开发效率和性能都不错,但缺点是对团队的要求又高了(尤其涉及到Python+C的多线程操作)…所以…鱼与熊掌不可兼得。如果一定要兼得,必须得自己牛逼。

2018-03-26 21:30:37 shujuelin 阅读数 18749

Mysql SQLyog导入导出csv文件

SQLyog 导出表中数据存为csv文件

1.    选择数据库表 --> 右击属性 --> 备份/导出 --> 导出表数据作为 --> 选择cvs --> 选择下面的“更改” --> 字段 --> 可变长度--> 字段终止与 -->输入逗号,(这是重点,否则导出的csv文件内容都在一列中,而不是分字段分列)
下面两个选项框取消。


2.导出csv文件后,使用UE编辑器或者记事本打开,另存为,选择编码为utf-8格式,保存。

3.打开csv文件,这样中文为正确的显示,如果不转码保存的话,为中文乱码。

SQLyog 将csv文件数据导入mysql表中

1.      将数据文件存为csv文件,保存的时候选择逗号(或\t)作为分隔符;

2.    选择数据库表 --> 导入 --> 导入本地可使用的CSV数据 --> 从文件导入,选择刚刚的csv文件,导入完成。

 

 

2.    选择cvs --> 选择下面的“更改” --> 字段 --> 可变长度--> 字段终止与 -->输入逗号,(这是重点,否则导入的csv文件内容都在一列中,而不是分字段分列)
下面两个选项框取消。

 http://www.cnblogs.com/DswCnblog/p/5970873.html



用Python Pandas处理亿级数据

在数据分析领域,最热门的莫过于Python和R语言,此前有一篇文章《别老扯什么Hadoop了,你的数据根本不够大》指出:只有在超过5TB数据量的规模下,Hadoop才是一个合理的技术选择。这次拿到近亿条日志数据,千万级数据已经是关系型数据库的查询分析瓶颈,之前使用过Hadoop对大量文本进行分类,这次决定采用Python来处理数据:

  • 硬件环境
      • CPU:3.5 GHz Intel Core i7
      • 内存:32 GB HDDR 3 1600 MHz
      • 硬盘:3 TB Fusion Drive
  • 数据分析工具
      • Python:2.7.6
      • Pandas:0.15.0
      • IPython notebook:2.0.0

源数据如下表所示:

 TableSizeDesc
ServiceLogs98,706,832 rows x 14 columns8.77 GB交易日志数据,每个交易会话可以有多条交易
ServiceCodes286 rows × 8 columns20 KB交易分类的字典表

数据读取

启动IPython notebook,加载pylab环境:

Pandas提供了IO工具可以将大文件分块读取,测试了一下性能,完整加载9800万条数据也只需要263秒左右,还是相当不错了。

 1百万条1千万条1亿条
ServiceLogs1 s17 s263 s

使用不同分块大小来读取再调用 pandas.concat 连接DataFrame,chunkSize设置在1000万条左右速度优化比较明显。

下面是统计数据,Read Time是数据读取时间,Total Time是读取和Pandas进行concat操作的时间,根据数据总量来看,对5~50个DataFrame对象进行合并,性能表现比较好。

Chunk SizeRead Time (s)Total Time (s)Performance
100,000224.418173261.358521 
200,000232.076794256.674154 
1,000,000213.128481234.934142√ √
2,000,000208.410618230.006299√ √ √
5,000,000209.460829230.939319√ √ √
10,000,000207.082081228.135672√ √ √ √
20,000,000209.628596230.775713√ √ √
50,000,000222.910643242.405967 
100,000,000263.574246263.574246 

屏幕快照 2015-02-17 下午2.05.48

如果使用Spark提供的Python Shell,同样编写Pandas加载数据,时间会短25秒左右,看来Spark对Python的内存使用都有优化。

数据清洗

Pandas提供了 DataFrame.describe 方法查看数据摘要,包括数据查看(默认共输出首尾60行数据)和行列统计。由于源数据通常包含一些空值甚至空列,会影响数据分析的时间和效率,在预览了数据摘要后,需要对这些无效数据进行处理。

首先调用 DataFrame.isnull() 方法查看数据表中哪些为空值,与它相反的方法是 DataFrame.notnull() ,Pandas会将表中所有数据进行null计算,以True/False作为结果进行填充,如下图所示:

屏幕快照 2015-02-16 下午11.21.29

Pandas的非空计算速度很快,9800万数据也只需要28.7秒。得到初步信息之后,可以对表中空列进行移除操作。尝试了按列名依次计算获取非空列,和 DataFrame.dropna() 两种方式,时间分别为367.0秒和345.3秒,但检查时发现 dropna() 之后所有的行都没有了,查了Pandas手册,原来不加参数的情况下, dropna() 会移除所有包含空值的行。如果只想移除全部为空值的列,需要加上 axis 和 how 两个参数:

共移除了14列中的6列,时间也只消耗了85.9秒。

接下来是处理剩余行中的空值,经过测试,在 DataFrame.replace() 中使用空字符串,要比默认的空值NaN节省一些空间;但对整个CSV文件来说,空列只是多存了一个“,”,所以移除的9800万 x 6列也只省下了200M的空间。进一步的数据清洗还是在移除无用数据和合并上。

对数据列的丢弃,除无效值和需求规定之外,一些表自身的冗余列也需要在这个环节清理,比如说表中的流水号是某两个字段拼接、类型描述等,通过对这些数据的丢弃,新的数据文件大小为4.73GB,足足减少了4.04G!

数据处理

使用 DataFrame.dtypes 可以查看每列的数据类型,Pandas默认可以读出int和float64,其它的都处理为object,需要转换格式的一般为日期时间。DataFrame.astype() 方法可对整个DataFrame或某一列进行数据格式转换,支持Python和NumPy的数据类型。

对数据聚合,我测试了 DataFrame.groupby 和 DataFrame.pivot_table 以及 pandas.merge ,groupby 9800万行 x 3列的时间为99秒,连接表为26秒,生成透视表的速度更快,仅需5秒。

根据透视表生成的交易/查询比例饼图:

屏幕快照 2015-02-17 上午12.00.09

将日志时间加入透视表并输出每天的交易/查询比例图:

屏幕快照 2015-02-17 下午2.27.05

除此之外,Pandas提供的DataFrame查询统计功能速度表现也非常优秀,7秒以内就可以查询生成所有类型为交易的数据子表:

该子表的大小为 [10250666 rows x 5 columns]。在此已经完成了数据处理的一些基本场景。实验结果足以说明,在非“>5TB”数据的情况下,Python的表现已经能让擅长使用统计分析语言的数据分析师游刃有余。

 


Python处理大数据

阅读数 4940