• Python大数据处理方案

    2018-03-26 21:30:37
    Mysql SQLyog导入导出csv文件SQLyog 导出表中数据存为csv文件1. 选择数据库表 --> 右击属性 --> 备份/导出 --> 导出表数据作为 --> 选择cvs --> 选择下面的“更改” -->...

    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 大数据入门教程

    2018-12-07 17:35:38
    Python大数据行业非常火爆近两年,as a pythonic,所以也得涉足下大数据分析,下面就聊聊它们。 Python数据分析与挖掘技术概述 所谓数据分析,即对已知的数据进行分析,然后提取出一些有价值的信息,比如统计...

    Python在大数据行业非常火爆近两年,as a pythonic,所以也得涉足下大数据分析,下面就聊聊它们。

    Python数据分析与挖掘技术概述

    所谓数据分析,即对已知的数据进行分析,然后提取出一些有价值的信息,比如统计平均数,标准差等信息,数据分析的数据量可能不会太大,而数据挖掘,是指对大量的数据进行分析与挖倔,得到一些未知的,有价值的信息等,比如从网站的用户和用户行为中挖掘出用户的潜在需求信息,从而对网站进行改善等。
    数据分析与数据挖掘密不可分,数据挖掘是对数据分析的提升。数据挖掘技术可以帮助我们更好的发现事物之间的规律。所以我们可以利用数据挖掘技术可以帮助我们更好的发现事物之间的规律。比如发掘用户潜在需求,实现信息的个性化推送,发现疾病与病状甚至病与药物之间的规律等。

    预先善其事必先利其器

    我们首先聊聊数据分析的模块有哪些:

    1. numpy 高效处理数据,提供数组支持,很多模块都依赖它,比如pandas,scipy,matplotlib都依赖他,所以这个模块都是基础。所以必须先安装numpy。
    2. pandas 主要用于进行数据的采集与分析
    3. scipy 主要进行数值计算。同时支持矩阵运算,并提供了很多高等数据处理功能,比如积分,微分方程求样等。
    4. matplotlib 作图模块,结合其他数据分析模块,解决可视化问题
    5. statsmodels 这个模块主要用于统计分析
    6. Gensim 这个模块主要用于文本挖掘
    7. sklearn,keras 前者机器学习,后者深度学习。

    下面就说说这些模块的基础使用。

    numpy模块安装与使用

    安装:
    下载地址是:http://www.lfd.uci.edu/~gohlke/pythonlibs/
    我这里下载的包是1.11.3版本,地址是:http://www.lfd.uci.edu/~gohlke/pythonlibs/f9r7rmd8/numpy-1.11.3+mkl-cp35-cp35m-win_amd64.whl
    下载好后,使用pip install "numpy-1.11.3+mkl-cp35-cp35m-win_amd64.whl"
    安装的numpy版本一定要是带mkl版本的,这样能够更好支持numpy

    numpy简单使用

    import numpy
    
    x=numpy.array([11,22,33,4,5,6,7,])  #创建一维数组
    x2=numpy.array([['asfas','asdfsdf','dfdf',11],['1iojasd','123',989012],["jhyfsdaeku","jhgsda"]])    #创建二维数组,注意是([])
    
    x.sort()   #排序,没有返回值的,修改原处的值,这里等于修改了X
    x.max()    # 最大值,对二维数组都管用
    x.min()    # 最小值,对二维数组都管用
    x1=x[1:3]   # 取区间,和python的列表没有区别

    生成随机数

    主要使用numpy下的random方法。

    #numpy.random.random_integers(最小值,最大值,个数)  获取的是正数
    data = numpy.random.random_integers(1,20000,30)   #生成整形随机数
    #正态随机数  numpy.random.normal(均值,偏离值,个数)  偏离值决定了每个数之间的差 ,当偏离值大于开始值的时候,那么会产生负数的。
    data1 = numpy.random.normal(3.2,29.2,10)    # 生成浮点型且是正负数的随机数

    pandas

    使用pip install pandas即可

    直接上代码:
    下面看看pandas输出的结果, 这一行的数字第几列,第一列的数字是行数,定位一个通过第一行,第几列来定位:

    print(b)
          0     1     2    3    
    0     1     2     3  4.0
    1  sdaf  dsaf  18hd  NaN
    2  1463  None  None  NaN

    常用方法如下:

    import pandas
    a=pandas.Series([1,2,3,34,])   # 等于一维数组
    b=pandas.DataFrame([[1,2,3,4,],["sdaf","dsaf","18hd"],[1463]])   # 二维数组
    print(b.head())  # 默认取头部前5行,可以看源码得知
    print(b.head(2))  # 直接传入参数,如我写的那样
    print(b.tail())   # 默认取尾部前后5行
    print(b.tail(1))     # 直接传入参数,如我写的那样

    下面看看pandas对数据的统计,下面就说说每一行的信息

    # print(b.describe())   # 显示统计数据信息
             3      # 3表示这个二维数组总共多少个元素
    count  1.0      # 总数
    mean   4.0      # 平均数
    std    NaN      # 标准数
    min    4.0      # 最小数
    25%    4.0      # 分位数
    50%    4.0      # 分位数
    75%    4.0      # 分位数
    max    4.0      # 最大值

    转置功能:把行数转换为列数,把列数转换为行数,如下所示:

    print(b.T)   # 转置
       0     1     2   
    0  1  sdaf  1463
    1  2  dsaf  None
    2  3  18hd  None
    3  4   NaN   NaN

    通过pandas导入数据

    pandas支持多种输入格式,我这里就简单罗列日常生活最常用的几种,对于更多的输入方式可以查看源码后者官网。

    CSV文件

    csv文件导入后显示输出的话,是按照csv文件默认的行输出的,有多少列就输出多少列,比如我有五列数据,那么它就在prinit输出结果的时候,就显示五列

    csv_data = pandas.read_csv('F:\Learnning\CSDN-python大数据\hexun.csv')
    print(csv_data)

    excel表格

    依赖于xlrd模块,请安装它。
    老样子,原滋原味的输出显示excel本来的结果,只不过在每一行的开头加上了一个行数

    excel_data = pandas.read_excel('F:\Learnning\CSDN-python大数据\cxla.xls')
    print(excel_data)

    读取SQL

    依赖于PyMySQL,所以需要安装它。pandas把sql作为输入的时候,需要制定两个参数,第一个是sql语句,第二个是sql连接实例。

    conn=pymysql.connect(host="127.0.0.1",user="root",passwd="root",db="test")
    sql="select * from fortest"
    e=pda.read_sql(sql,conn)

    读取HTML

    依赖于lxml模块,请安装它。
    对于HTTPS的网页,依赖于BeautifulSoup4,html5lib模块。
    读取HTML只会读取HTML里的表格,也就是只读取<table>标签包裹的内容.

    html_data = pandas.read_html('F:\Learnning\CSDN-python大数据\shitman.html')   # 读取本地html文件。
    html_from_online = pandas.read_html('https://book.douban.com/')  # 读取互联网的html文件
    print(html_data)
    print('html_from_online')

    显示的是时候是通过python的列表展示,同时添加了行与列的标识

    读取txt文件

    输出显示的时候同时添加了行与列的标识

    text_data = pandas.read_table('F:\Learnning\CSDN-python大数据\dforsay.txt')
    print(text_data)

    scipy

    安装方法是先下载whl格式文件,然后通过pip install “包名” 安装。whl包下载地址是:http://www.lfd.uci.edu/~gohlke/pythonlibs/f9r7rmd8/scipy-0.18.1-cp35-cp35m-win_amd64.whl

    matplotlib 数据可视化分析

    我们安装这个模块直接使用pip install即可。不需要提前下载whl后通过 pip install安装。

    下面请看代码:

    from matplotlib import  pylab
    import numpy
    # 下面2行定义X轴,Y轴
    x=[1,2,3,4,8]
    y=[1,2,3,4,8]
    # plot的方法是这样使用(x轴数据,y轴数据,展现形式)
    pylab.plot(x,y)   # 先把x,y轴的信息塞入pylab里面,再调用show方法来画图
    pylab.show()    # 这一步开始画图,默认是至线图

    画出的图是这样的:
    image

    下面说说修改图的样式

    关于图形类型,有下面几种:

    1. 直线图(默认)
    2. - 直线
    3. -- 虚线
    4. -. -.形式
    5. : 细小虚线

    关于颜色,有下面几种:

    1. c-青色
    2. r-红色
    3. m-品红
    4. g-绿色
    5. b-蓝色
    6. y-黄色
    7. k-黑色
    8. w-白色

    关于形状,有下面几种:

    1. s 方形
    2. * 星形
    3. p 五角形

    我们还可以对图稍作修改,添加一些样式,下面修改圆点图为红色的点,代码如下:

    pylab.plot(x,y,'or')   # 添加O表示画散点图,r表示red
    pylab.show()

    image

    我们还可以画虚线图,代码如下所示:

    pylab.plot(x,y,'r:')
    pylab.show()

    还可以给图添加上标题,x,y轴的标签,代码如下所示

    pylab.plot(x,y,'pr--')   #p是图形为五角星,r为红色,--表示虚线
    pylab.title('for learnning')   # 图形标题
    pylab.xlabel('args')   # x轴标签
    pylab.ylabel('salary')   # y轴标签
    pylab.xlim(2)    # 从y轴的2开始做线
    pylab.show()

    image

    直方图

    利用直方图能够很好的显示每一段的数据。下面使用随机数做一个直方图。

    data1 = numpy.random.normal(5.0,4.0,10)   # 正态随机数
    pylab.hist(data1)
    pylab.show()

    image
    Y轴为出现的次数,X轴为这个数的值(或者是范围)

    还可以指定直方图类型通过histtype参数:

    图形区别语言无法描述很详细,大家可以自信尝试。

    1. bar :is a traditional bar-type histogram. If multiple data
      are given the bars are aranged side by side.
    2. barstacked :is a bar-type histogram where multiple
      data are stacked on top of each other.
    3. step :generates a lineplot that is by default
      unfilled.
    4. stepfilled :generates a lineplot that is by default
      filled.

    举个例子:

    sty=numpy.arange(1,30,2)
    pylab.hist(data1,histtype='stepfilled')
    pylab.show() 

    image

    子图功能

    什么是子图功能呢?子图就是在一个大的画板里面能够显示多张小图,每个一小图为大画板的子图。
    我们知道生成一个图是使用plot功能,子图就是subplog。代码操作如下:

    #subplot(行,列,当前区域)
    pylab.subplot(2,2,1)   # 申明一个大图里面划分成4块(即2*2),子图使用第一个区域(坐标为x=1,y=1)
    pylab.subplot(2,2,2)  # 申明一个大图里面划分成4块(即2*2),子图使用第二个区域(坐标为x=2,y=2)
    x1=[1,4,6,9]
    x2=[3,21,33,43]
    pylab.plot(x1,x2)   # 这个plot表示把x,y轴数据塞入前一个子图中。我们可以在每一个子图后使用plot来塞入x,y轴的数据
    pylab.subplot(2,1,2)  # 申明一个大图里面划分成2块(即),子图使用第二个区域(坐标为x=1,y=2)
    pylab.show()

    实践小例子

    我们现在可以通过一堆数据来绘图,根据图能够很容易的发现异常。下面我们就通过一个csv文件来实践下,这个csv文件是某个网站的文章阅读数与评论数。
    先说说这个csv的文件结构,第一列是序号,第二列是每篇文章的URL,第三列每篇文章的阅读数,第四列是每篇评论数。
    我们的需求就是把评论数作为Y轴,阅读数作为X轴,所以我们需要获取第三列和第四列的数据。我们知道获取数据的方法是通过pandas的values方法来获取某一行的值,在对这一行的值做切片处理,获取下标为3(阅读数)和4(评论数)的值,但是,这里只是一行的值,我们需要是这个csv文件下的所有评论数和阅读数,那怎么办?聪明的你会说,我自定义2个列表,我遍历下这个csv文件,把阅读数和评论数分别添加到对应的列表里,这不就行了嘛。呵呵,其实有一个更快捷的方法,那么就是使用T转置方法,这样再通过values方法,就能直接获取这一评论数和阅读数了,此时在交给你matplotlib里的pylab方法来作图,那么就OK了。了解思路后,那么就写吧。

    下面看看代码:

    
    csv_data = pandas.read_csv('F:\Learnning\CSDN-python大数据\hexun.csv')
    dt = csv_data.T   # 装置下,把阅读数和评论数转为行
    readers=dt.values[3]   
    comments = dt.values[4]
    pylab.xlabel(u'reads')
    pylab.ylabel(u'comments')   # 打上标签
    pylab.title(u"The Article's reads and comments")
    pylab.plot(readers,comments,'ob')
    pylab.show()

    image

     

    展开全文
  • 今天为大家带来的内容是如何用Python处理大数据?3个小技巧助你提升效率(建议收藏)本文具有不错的参考意义,希望能够帮助到大家! 首先,提出个问题:如果你有个5、6 G 大小的文件,想把文件内容读出来做一些处理...

    今天为大家带来的内容是如何用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(群里含大量学习资料,面试宝典等)

    展开全文
  • 示例:python用dataset导入900w条数据到oracle dataset可以批量导入数据库,以dict结构就可以导入数据库 import dataset import logging import time def handle_txt(): ids = [] uids= [] with open('./xxx.txt'...

    示例:python用dataset导入900w条数据到oracle

    dataset可以批量导入数据库,以dict结构就可以导入数据库

    import dataset
    import logging
    import time
    def handle_txt():
        ids = []
        uids= []
        with open('./xxx.txt',mode='r',encoding="utf8") as f:
            rows = f.readlines()
            for row in rows:
                text = row.split(',')
                ids.append(text[0])
                uids.append(text[1])
    
        logging.StreamHandler(stream=None)
        db = dataset.connect('oracle://"用户名":“密码”@“数据库连接名”')
        table = db['tablename']
    
    
        import_data = []
        data = zip(ids,uids)
        data = list(data)
        for i in data :
            start_time = time.time()
            import_data.append(dict(id=i[0], uid=i[1]))
            if len(import_data) == 20000:
                table.insert_many(import_data)
                import_data = []
            end_time = time.time()
            cost_time = end_time - start_time
            logging.info("%s" % cost_time)
    
        import_data = []
        start_num = len(data) % 20000
        print(start_num)
        data_save = data[-start_num:]
        for i in data_save:
            import_data.append(dict(id=i[0], uid=i[1]))
            table.insert_many(import_data)
        db.commit()
    
    
    if __name__ == '__main__':
        data= handle_txt()
    
    
    
    
    
    
    
    
    展开全文
  • 博文1:pandas.read_csv——分块读取大文件 ... 今天在读取一个超大csv文件的时候,遇到困难...首先使用office打不开然后在python中使用基本的pandas.read_csv打开文件时:MemoryError最后查阅read_csv文档发现可以

    博文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)



    展开全文
  • 使用Python导入数据集
  • python快速读取大数据1

    2019-07-21 06:45:42
    1 rd = pd.read_csv(path7 + u'0501-0914.csv',encoding = 'gbk',iterator = True) 2 loop =True 3 dflst = [] 4 i = 0 5 while loop: 6 try: 7 i+=1 8 df0 = rd.get_chunk(50...
  • python的培训学习中,我们会用python进行数据分析的学习与应用,并且在这一部分进行绘图是必不可少的,所以为了看一下大家的实力,今天我们python培训安排了python大数据与机器学习Matplotlib练习题十道,来看下你...
  • 除了做程序的开发,有可能你还要自己做一下性能的测试,例如一个导入功能,你需要导入大批量的数据,多到什么程度。 几万条甚至几十万条数据。 导入的数据我们第一个想到的当然是excel导入数据。那几万条数据我们...
  • Python大数据无处不在。在时下这个年代,不管你喜欢与否,在运营一个成功的商业的过程中都有可能会遇到它。 本教程将会简要介绍何谓大数据,无论你是尝试抓住时机的商人,抑或是寻找下一个项目的编程高手...
  • Python乱炖每周三赠书时间到~《Python大数据与机器学习实战》5本包邮!查看文章尾部参与赠书随着5G时代的来临、企事业单位信息化系统的不断完善以及物联网的兴起,数据...
  • 实验环境 CentOS镜像为CentOS-7-x86_64-Everything-1804.iso 虚机配置 节点名称 IP地址 子网掩码 CPU/内存 磁盘 安装方式 master 192.168.204.101 255.255.255.0 1核心/4GB ...255.255.255.0...
  • 写在前面:这系列文章都是笔者在阅读《python金融大数据》时写下的勘误笔记。由于笔者的书使用python2,而笔者自学python3,因此将书中与python3不符合的代码部分找出并将修正结果写在这里,供自己欣赏。 年统计...
  • 大数据面试之python

    2020-06-20 14:46:18
    Q1、Python中的列表和元组有什么区别? 列表是动态数组,它们不可变且可以重设长度(改变其内部元素的个数)。 元组是静态数组,它们不可变,且其内部数据一旦创建便无法改变。 Q2、Python的主要功能是什么? ...
  • 大数据分析,内存不够用怎么办? 当然,你可以升级你的电脑为超级电脑。 另外,你也可以采用硬盘操作。 本文示范了硬盘操作的一种可能的方式。   本文基于:win10(64) + py3.5 ...本人电脑配置:4G内存 ...
  • java导入大数据文件

    2019-06-14 15:34:32
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • 使用python脚本上传大数据集CSV文件到MySQL # -*- coding: utf-8 -*- """ Created on Thu Jun 7 14:54:14 2018 @author: YFX """ #--------------------------------------------...
  • 各位朋友,我已开通微信公共号:小程在线 我会把文章及时的更新到公共号上,欢迎大家的关注。 只提供测试数据!!! 测试数据如下:中间是用Tab键分隔开的 ...into table test #往数据库表导入数据 fields term...
  • 在用Python读一个两个多G的txt文本时,天真的直接用readlines方法,结果一运行内存就崩了。 还好同事点拨了下,用yield方法,测试了下果然毫无压力。咎其原因,原来是readlines是把文本内容全部放于内存中,而yield...
  • python的培训学习中,我们会用python进行数据分析的学习与应用,并且在这一部分进行绘图是必不可少的,所以为了看一下大家的实力,今天我们python培训安排了python大数据与机器学习Matplotlib练习题十道,来看下你...
1 2 3 4 5 ... 20
收藏数 12,816
精华内容 5,126
关键字:

python导入大数据