• Pandas使用一个二维的数据结构DataFrame来表示表格式的数据,相比较于Numpy,Pandas可以存储混合的数据结构,同时使用NaN来表示缺失的数据,而不用像Numpy一样要手工处理缺失的数据,并且Pandas使用轴标签来表示行和...

    Pandas使用一个二维的数据结构DataFrame来表示表格式的数据,相比较于Numpy,Pandas可以存储混合的数据结构,同时使用NaN来表示缺失的数据,而不用像Numpy一样要手工处理缺失的数据,并且Pandas使用轴标签来表示行和列

    1、文件读取
    首先将用到的pandas和numpy加载进来
    import pandas as pd
    import numpy as np
    读取数据:
    #csv和xlsx分别用read_csv和read_xlsx,下面以csv
    为例

    df=pd.read_csv('f:\1024.csv') 


    2、查看数据

    df.head()  

    #默认出5行号里可以填其他数据

    3、查看数据类型

    df.dtypes

    4、利用现有数据生成一列新数据

    比如:max_time和min_time是现有的两列,现在业务需要生成一列gs,gs=max_time-min_time

    df.['gs']=df.['max_time']-['min_time']

    #查看是否成功

    df.head()

    5、查看基本统计量

    df.describe(include='all')                 # all代表需要将所有列都列出


    通常来说,数据是CSV格式,就算不是,至少也可以转换成CSV格式。在Python中,我们的操作如下:


    import pandas as pd

     

    # Reading data locally

    df = pd.read_csv('/Users/al-ahmadgaidasaad/Documents/d.csv')

     

    # Reading data from web

    data_url = "https://raw.githubusercontent.com/alstat/Analysis-with-Programming/master/2014/Python/Numerical-Descriptions-of-the-Data/data.csv"


    df = pd.read_csv(data_url)


    为了读取本地CSV文件,我们需要pandas这个数据分析库中的相应模块。


    其中的read_csv函数能够读取本地和web数据




    # Head of the data

    print df.head()

     

    # OUTPUT

        Abra  Apayao  Benguet  Ifugao  Kalinga

    0   1243    2934      148    3300    10553

    1   4158    9235     4287    8063    35257

    2   1787    1922     1955    1074     4544

    3  17152   14501     3536   19607    31687

    4   1266    2385     2530    3315     8520

     

    # Tail of the data


    print df.tail()

     

    # OUTPUT

         Abra  Apayao  Benguet  Ifugao  Kalinga

    74   2505   20878     3519   19737    16513

    75  60303   40065     7062   19422    61808

    76   6311    6756     3561   15910    23349

    77  13345   38902     2583   11096    68663

    78   2623   18264     3745   16787    16900


    上述操作等价于通过print(head(df))来打印数据的前6行,以及通过print(tail(df))来打印数据的后6行。



    当然Python中,默认打印是5行,而R则是6行。因此R的代码head(df, n = 10),


    在Python中就是df.head(n = 10),打印数据尾部也是同样道理。



    在Python中,我们则使用columns和index属性来提取,如下:



    # Extracting column names


    print df.columns

     

    # OUTPUT


    Index([u'Abra', u'Apayao', u'Benguet', u'Ifugao', u'Kalinga'], dtype='object')

     

    # Extracting row names or the index


    print df.index

     

    # OUTPUT

    Int64Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30], dtype='int64')


    数据转置使用T方法,



    # Transpose data

    print df.T

     

    # OUTPUT

                0      1     2      3     4      5     6      7     8      9  

    Abra      1243   4158  1787  17152  1266   5576   927  21540  1039   5424  

    Apayao    2934   9235  1922  14501  2385   7452  1099  17038  1382  10588  

    Benguet    148   4287  1955   3536  2530    771  2796   2463  2592   1064  

    Ifugao    3300   8063  1074  19607  3315  13134  5134  14226  6842  13828  

    Kalinga  10553  35257  4544  31687  8520  28252  3106  36238  4973  40140  

     

             ...       69     70     71     72     73     74     75     76     77  

    Abra     ...    12763   2470  59094   6209  13316   2505  60303   6311  13345  

    Apayao   ...    37625  19532  35126   6335  38613  20878  40065   6756  38902  

    Benguet  ...     2354   4045   5987   3530   2585   3519   7062   3561   2583  

    Ifugao   ...     9838  17125  18940  15560   7746  19737  19422  15910  11096  

    Kalinga  ...    65782  15279  52437  24385  66148  16513  61808  23349  68663  

     

                78  

    Abra      2623  

    Apayao   18264  

    Benguet   3745  

    Ifugao   16787  

    Kalinga  16900  

     

    其他变换,例如排序就是用sort属性。现在我们提取特定的某列数据

    Python中,可以使用iloc或者ix属性。但是我更喜欢用ix,因为它更稳定一些。假设我们需数据第一列的前5行,我们有:


    print df.ix[:, 0].head()

     

    # OUTPUT

    0     1243

    1     4158

    2     1787

    3    17152

    4     1266

    Name: Abra, dtype: int64



    顺便提一下,Python的索引是从0开始而非1。为了取出从11到20行的前3列数据,我们有:


    print df.ix[10:20, 0:3]

     

    # OUTPUT

        Abra  Apayao  Benguet

    10    981    1311     2560

    11  27366   15093     3039

    12   1100    1701     2382

    13   7212   11001     1088

    14   1048    1427     2847

    15  25679   15661     2942

    16   1055    2191     2119

    17   5437    6461      734

    18   1029    1183     2302

    19  23710   12222     2598

    20   1091    2343     2654



    上述命令相当于df.ix[10:20, ['Abra', 'Apayao', 'Benguet']]。


    为了舍弃数据中的列,这里是列1(Apayao)和列2(Benguet),我们使用drop属性,如下:


    print df.drop(df.columns[[1, 2]], axis = 1).head()

     

    # OUTPUT

        Abra  Ifugao  Kalinga

    0   1243    3300    10553

    1   4158    8063    35257

    2   1787    1074     4544

    3  17152   19607    31687

    4   1266    3315     8520


    axis 参数告诉函数到底舍弃列还是行。如果axis等于0,那么就舍弃行


    统计描述


    下一步就是通过describe属性,对数据的统计特性进行描述:


    print df.describe()

     

    # OUTPUT

                   Abra        Apayao      Benguet        Ifugao       Kalinga

    count     79.000000     79.000000    79.000000     79.000000     79.000000

    mean   12874.379747  16860.645570  3237.392405  12414.620253  30446.417722

    std    16746.466945  15448.153794  1588.536429   5034.282019  22245.707692

    min      927.000000    401.000000   148.000000   1074.000000   2346.000000

    25%     1524.000000   3435.500000  2328.000000   8205.000000   8601.500000

    50%     5790.000000  10588.000000  3202.000000  13044.000000  24494.000000

    75%    13330.500000  33289.000000  3918.500000  16099.500000  52510.500000

    max    60303.000000  54625.000000  8813.000000  21031.000000  68663.000000


    Python有一个很好的统计推断包。那就是scipy里面的stats。ttest_1samp实现了单样本t检验。因此,如果我们想检验数据Abra列的稻谷产量均值,通过零假设,这里我们假定总体稻谷产量均值为15000,我们有:


     from scipy import stats as ss

     

    # Perform one sample t-test using 1500 as the true mean

    print ss.ttest_1samp(a = df.ix[:, 'Abra'], popmean = 15000)

     

    # OUTPUT

    (-1.1281738488299586, 0.26270472069109496)


    返回下述值组成的元祖:


    t : 浮点或数组类型

    t统计量

    prob : 浮点或数组类型

    two-tailed p-value 双侧概率值

    通过上面的输出,看到p值是0.267远大于α等于0.05,因此没有充分的证据说平均稻谷产量不是150000。将这个检验应用到所有的变量,同样假设均值为15000,我们有:


    print ss.ttest_1samp(a = df, popmean = 15000)

     

    # OUTPUT

    (array([ -1.12817385,   1.07053437, -65.81425599,  -4.564575  ,   6.17156198]),

    array([  2.62704721e-01,   2.87680340e-01,   4.15643528e-70,

              1.83764399e-05,   2.82461897e-08]))



    第一个数组是t统计量,第二个数组则是相应的p值。


    可视化


    Python中有许多可视化模块,最流行的当属matpalotlib库。稍加提及,我们也可选择bokeh和seaborn模块。之前的博文中,我已经说明了matplotlib库中的盒须图模块功能。


    # Import the module for plotting

    import matplotlib.pyplot as plt

    plt.show(df.plot(kind = 'box'))



    现在,我们可以用pandas模块中集成R的ggplot主题来美化图表。要使用ggplot,我们只需要在上述代码中多加一行,



    import matplotlib.pyplot as plt

    pd.options.display.mpl_style = 'default' # Sets the plotting display theme to ggplot2

    df.plot(kind = 'box')



    # Import the seaborn library

    import seaborn as sns

    # Do the boxplot

    plt.show(sns.boxplot(df, widths = 0.5, color = "pastel"))



    import numpy as np

    import scipy.stats as ss

     

    def case(n = 10, mu = 3, sigma = np.sqrt(5), p = 0.025, rep = 100):

        m = np.zeros((rep, 4))

     

        for i in range(rep):

            norm = np.random.normal(loc = mu, scale = sigma, size = n)

            xbar = np.mean(norm)

            low = xbar - ss.norm.ppf(q = 1 - p) * (sigma / np.sqrt(n))

            up = xbar + ss.norm.ppf(q = 1 - p) * (sigma / np.sqrt(n))

     

            if (mu > low) & (mu < up):

                rem = 1

            else:

                rem = 0

     

            m[i, :] = [xbar, low, up, rem]

     

        inside = np.sum(m[:, 3])

        per = inside / rep

        desc = "There are " + str(inside) + " confidence intervals that contain "

               "the true mean (" + str(mu) + "), that is " + str(per) + " percent of the total CIs"

     

        return {"Matrix": m, "Decision": desc}



    import numpy as np

    import scipy.stats as ss

     

    def case2(n = 10, mu = 3, sigma = np.sqrt(5), p = 0.025, rep = 100):

        scaled_crit = ss.norm.ppf(q = 1 - p) * (sigma / np.sqrt(n))

        norm = np.random.normal(loc = mu, scale = sigma, size = (rep, n))

     

        xbar = norm.mean(1)

        low = xbar - scaled_crit

        up = xbar + scaled_crit

     

        rem = (mu > low) & (mu < up)

        m = np.c_[xbar, low, up, rem]

     

        inside = np.sum(m[:, 3])

        per = inside / rep

        desc = "There are " + str(inside) + " confidence intervals that contain "

               "the true mean (" + str(mu) + "), that is " + str(per) + " percent of the total CIs"

        return {"Matrix": m, "Decision": desc}



    读取数据

    Pandas使用函数read_csv()来读取csv文件

    复制代码

    import pandas
    
    food_info = ('food_info.csv')
    print(type(food_info))
    
    # 输出:<class 'pandas.core.frame.DataFrame'> 可见读取后变成一个DataFrame变量
    

    复制代码

     

    该文件的内容如下:

    图片3

     

    使用函数head( m )来读取前m条数据,如果没有参数m,默认读取前五条数据

    first_rows = food_info.head()
    
    first_rows = food_info.head(3)
    

    由于DataFrame包含了很多的行和列,

    Pandas使用省略号(...)来代替显示全部的行和列,可以使用colums属性来显示全部的列名

    复制代码

    print(food_info.columns)
    

    # 输出:输出全部的列名,而不是用省略号代替

    Index(['NDB_No', 'Shrt_Desc', 'Water_(g)', 'Energ_Kcal', 'Protein_(g)', 'Lipid_Tot_(g)', 'Ash_(g)', 'Carbohydrt_(g)', 'Fiber_TD_(g)', 'Sugar_Tot_(g)', 'Calcium_(mg)', 'Iron_(mg)', 'Magnesium_(mg)', 'Phosphorus_(mg)', 'Potassium_(mg)', 'Sodium_(mg)', 'Zinc_(mg)', 'Copper_(mg)', 'Manganese_(mg)', 'Selenium_(mcg)', 'Vit_C_(mg)', 'Thiamin_(mg)', 'Riboflavin_(mg)', 'Niacin_(mg)', 'Vit_B6_(mg)', 'Vit_B12_(mcg)', 'Vit_A_IU', 'Vit_A_RAE', 'Vit_E_(mg)', 'Vit_D_mcg', 'Vit_D_IU', 'Vit_K_(mcg)', 'FA_Sat_(g)', 'FA_Mono_(g)', 'FA_Poly_(g)', 'Cholestrl_(mg)'], dtype='object')
    

    复制代码

    可以使用tolist()函数转化为list

    food_info.columns.tolist()
    

    与Numpy一样,用shape属性来显示数据的格式


    dimensions = food_info.shapeprint(dimensions)
    print(dimensions)
    ​
    
    输出:(8618,36) ,
    
    其中dimensions[0]为8618,dimensions[1]为36
    

     

    与Numpy一样,用dtype属性来显示数据类型,Pandas主要有以下几种dtype:

    • object -- 代表了字符串类型

    • int -- 代表了整型

    • float -- 代表了浮点数类型

    • datetime -- 代表了时间类型

    • bool -- 代表了布尔类型

     

    当读取了一个文件之后,Pandas会通过分析值来推测每一列的数据类型

    复制代码

    print()
    

    输出:每一列对应的数据类型

    NDB_No            int64

    Shrt_Desc           object

    Water_(g)           float64

    Energ_Kcal          int64

    Protein_(g)          float64

    ...


    索引

    读取了文件后,Pandas会把文件的一行作为列的索引标签,使用行数字作为行的索引标签

    图片4

    注意,行标签是从数字0开始的

    Pandas使用Series数据结构来表示一行或一列的数据,类似于Numpy使用向量来表示数据。Numpy只能使用数字来索引,而Series可以使用非数字来索引数据,当你选择返回一行数据的时候,Series并不仅仅返回该行的数据,同时还有每一列的标签的名字。

    譬如要返回文件的第一行数据,Numpy就会返回一个列表(但你可能不知道每一个数字究竟代表了什么)

    图片5

    而Pandas则会同时把每一列的标签名返回(此时就很清楚数据的意思了)

    图片6

     

    选择数据

    Pandas使用loc[]方法来选择行的数据

    复制代码

    # 选择单行数据:
    
    food_info.loc[0]   # 选择行标号为0的数据,即第一行数据
    food_info.loc[6]   # 选择行标号为6的数据,即第七行数据
    
    # 选择多行数据:
    
    food_info.loc[3:6] # 使用了切片,注意:由于这里使用loc[]函数,所以返回的是行标号为3,4,5,6的数据,与python的切片不同的是这里会返回最后的标号代表的数据,但也可以使用python的切片方法:food_info[3:7]
    
    food_info.loc[[2,5,10]] # 返回行标号为2,5,10三行数据
    
    练习:返回文件的最后五行
    
    方法一:
    
    length = food_info.shape[0]
    
    last_rows = food_info.loc[length-5:length-1]
    
    方法二:
    
    num_rows = food_info.shape[0]
    
    last_rows = food_info[num_rows-5:num_rows]
    
    Pandas直接把列名称填充就能返回该列的数据
    
    ndb_col = food_info["NDB_No"] # 返回列名称为NDB_No的那一列的数据
    
    zinc_copper = food_info[["Zinc_(mg)", "Copper_(mg)"]] # 返回两列数据
    

    复制代码

     

    简单运算

    现在要按照如下公式计算所有食物的健康程度,并按照降序的方式排列结果:

    Score=2×(Protein_(g))−0.75×(Lipid_Tot_(g))

    对DataFrame中的某一列数据进行算术运算,其实是对该列中的所有元素进行逐一的运算,譬如:

    water_energy = food_info["Water_(g)"] * food_info["Energ_Kcal"]

    原理:

    图片7

    由于每一列的数据跨度太大,有的数据是从0到100000,而有的数据是从0到10,所以为了尽量减少数据尺度对运算结果的影响,采取最简单的方法来规范化数据,那就是将每个数值都除以该列的最大值,从而使所有数据都处于0和1之间。其中max()函数用来获取该列的最大值.

    复制代码

    food_info['Normalized_Protein'] = food_info['Protein_(g)'] / food_info['Protein_(g)'].max()
    
    food_info['Normalized_Fat'] = food_info['Lipid_Tot_(g)'] / food_info['Lipid_Tot_(g)'].max()
    
    food_info['Norm_Nutr_Index'] = food_info["Normalized_Protein"] * 2 - food_info["Normalized_Fat"] * 0.75
    
    注意:上面的两个语句已经在原来的DataFrame中添加了三列,列名分别为Normalized_Protein和Normalized_Fat,Norm_Nutr_Index。只需要使用中括号和赋值符就能添加新列,类似于字典
    
    对DataFrame的某一列数据排序,只需要使用函数sort()即可
    
    food_info.sort("Sodium_(mg)") # 函数参数为列名,默认是按照升序排序,同时返回一个新的
    
    DataFramefood_info.sort("Norm_Nutr_Index", inplace=True, ascending=False ) 
    
    # 通过inplace参数来控制在原表排序,而不是返回一个新的对象;ascending参数用来控制是否升序排序
    


    import pandas as pd

    read_csv()

    读写csv数据

    df = pd.read_csv(path): 读入csv文件,形成一个数据框(data.frame)

    df = pd.read_csv(path, header=None) 不要把第一行作为header

    to_csv()

    * 注意,默认会将第一行作为header,并且默认会添加index,所以不需要的话需要手动禁用 *

    df.to_csv(path, header=False, index=False)

    数据框操作

    df.head(1) 读取头几条数据

    df.tail(1) 读取后几条数据

    df[‘date’] 获取数据框的date列

    df.head(1)[‘date’] 获取第一行的date列

    df.head(1)[‘date’][0] 获取第一行的date列的元素值

    sum(df[‘ability’]) 计算整个列的和

    df[df[‘date’] == ‘20161111’] 获取符合这个条件的行

    df[df[‘date’] == ‘20161111’].index[0] 获取符合这个条件的行的行索引的值

    df.iloc[1] 获取第二行

    df.iloc[1][‘test2’] 获取第二行的test2值

    10 mins to pandas 
    df.index 获取行的索引

    df.index[0] 获取第一个行索引

    df.index[-1] 获取最后一个行索引,只是获取索引值

    df.columns 获取列标签

    df[0:2] 获取第1到第2行,从0开始,不包含末端

    df.loc[1] 获取第二行

    df.loc[:,’test1’] 获取test1的那一列,这个冒号的意思是所有行,逗号表示行与列的区分

    df.loc[:,[‘test1’,’test2’]] 获取test1列和test2列的数据

    df.loc[1,[‘test1’,’test2’]] 获取第二行的test1和test2列的数据

    df.at[1,’test1’] 表示取第二行,test1列的数据,和上面的方法类似

    df.iloc[0] 获取第一行

    df.iloc[0:2,0:2] 获取前两行前两列的数据

    df.iloc[[1,2,4],[0,2]] 获取第1,2,4行中的0,2列的数据

    (df[2] > 1).any() 对于Series应用any()方法来判断是否有符合条件的


    一、            创建对象

    可以通过 Data Structure Intro Setion 来查看有关该节内容的详细信息。

    1、可以通过传递一个list对象来创建一个Seriespandas会默认创建整型索引:

    2、通过传递一个numpy array,时间索引以及列标签来创建一个DataFrame

    3、通过传递一个能够被转换成类似序列结构的字典对象来创建一个DataFrame

    4、查看不同列的数据类型:

    5、如果你使用的是IPython,使用Tab自动补全功能会自动识别所有的属性以及自定义的列,下图中是所有能够被自动识别的属性的一个子集:

    二、            查看数据

    详情请参阅:Basics Section

     

    1、  查看frame中头部和尾部的行:

    2、  显示索引、列和底层的numpy数据:

    3、  describe()函数对于数据的快速统计汇总:

    4、  对数据的转置:

    5、  按轴进行排序

    6、  按值进行排序

    三、            选择

    虽然标准的Python/Numpy的选择和设置表达式都能够直接派上用场,但是作为工程使用的代码,我们推荐使用经过优化的pandas数据访问方式: .at, .iat, .loc, .iloc  .ix详情请参阅Indexing and Selecing Data  MultiIndex / Advanced Indexing

    l  获取

    1、 选择一个单独的列,这将会返回一个Series,等同于df.A

    2、 通过[]进行选择,这将会对行进行切片

    l  通过标签选择

    1、 使用标签来获取一个交叉的区域

    2、 通过标签来在多个轴上进行选择

    3、 标签切片

    4、 对于返回的对象进行维度缩减

    5、 获取一个标量

    6、 快速访问一个标量(与上一个方法等价)

    l  通过位置选择

    1、 通过传递数值进行位置选择(选择的是行)

    2、 通过数值进行切片,与numpy/python中的情况类似

    3、 通过指定一个位置的列表,与numpy/python中的情况类似

    4、 对行进行切片

    5、 对列进行切片

    6、 获取特定的值

    l  布尔索引

    1、 使用一个单独列的值来选择数据:

    2、 使用where操作来选择数据:

    3、 使用isin()方法来过滤:

     

    l  设置

    1、 设置一个新的列:

    2、 通过标签设置新的值:

    3、 通过位置设置新的值:

    4、 通过一个numpy数组设置一组新值:

    上述操作结果如下:

    5、 通过where操作来设置新的值:

    四、            缺失值处理

    pandas中,使用np.nan来代替缺失值,这些值将默认不会包含在计算中,详情请参阅:Missing Data Section

    1、  reindex()方法可以对指定轴上的索引进行改变/增加/删除操作,这将返回原始数据的一个拷贝:、

    2、  去掉包含缺失值的行:

    3、  对缺失值进行填充:

    4、  对数据进行布尔填充:

    五、            相关操作

    详情请参与 Basic Section On Binary Ops

    • 统计(相关操作通常情况下不包括缺失值)

    1、  执行描述性统计:

    2、  在其他轴上进行相同的操作:

    3、  对于拥有不同维度,需要对齐的对象进行操作。Pandas会自动的沿着指定的维度进行广播:

    • Apply

    1、  对数据应用函数:

    • 直方图

    具体请参照:Histogramming and Discretization


    • 字符串方法

    Series对象在其str属性中配备了一组字符串处理方法,可以很容易的应用到数组中的每个元素,如下段代码所示。更多详情请参考:Vectorized String Methods.

    六、            合并

    Pandas提供了大量的方法能够轻松的对SeriesDataFramePanel对象进行各种符合各种逻辑关系的合并操作。具体请参阅:Merging section

    • Concat

    • Append 将一行连接到一个DataFrame上,具体请参阅Appending

    七、            分组

    对于”group by”操作,我们通常是指以下一个或多个操作步骤:

    • Splitting)按照一些规则将数据分为不同的组;

    • Applying)对于每组数据分别执行一个函数;

    • Combining)将结果组合到一个数据结构中;

    详情请参阅:Grouping section

    1、  分组并对每个分组执行sum函数:

    2、  通过多个列进行分组形成一个层次索引,然后执行函数:

    八、            Reshaping

    详情请参阅 Hierarchical Indexing  Reshaping

    • Stack

    可以从这个数据中轻松的生成数据透视表:

    九、            时间序列

    Pandas在对频率转换进行重新采样时拥有简单、强大且高效的功能(如将按秒采样的数据转换为按5分钟为单位进行采样的数据)。这种操作在金融领域非常常见。具体参考:Time Series section

    1、  时区表示:

    2、  时区转换:

    3、  时间跨度转换:

    4、  时期和时间戳之间的转换使得可以使用一些方便的算术函数。

    十、            Categorical

    0.15版本开始,pandas可以在DataFrame中支持Categorical类型的数据,详细 介绍参看:categorical introductionAPI documentation

    1、  将原始的grade转换为Categorical数据类型:

    2、  Categorical类型数据重命名为更有意义的名称:

    3、  对类别进行重新排序,增加缺失的类别:

    4、  排序是按照Categorical的顺序进行的而不是按照字典顺序进行:

    5、  Categorical列进行排序时存在空的类别:

    十一、           画图

    具体文档参看:Plotting docs

    对于DataFrame来说,plot是一种将所有列及其标签进行绘制的简便方法:

    十二、           导入和保存数据

    1、  写入csv文件:

    2、  csv文件中读取:

    1、  写入HDF5存储:

    2、  HDF5存储中读取:

    1、  写入excel文件:

    2、  excel文件中读取:


    展开全文
  • pandas处理大数据———减少90%内存消耗的小贴士 一般来说,用pandas处理小于100兆的数据,性能不是问题。当用pandas来处理100兆至几个G的数据时,将会比较耗时,同时会导致程序因内存不足而运行失败。 当然,像...

    原文地址https://www.dataquest.io/blog/pandas-big-data/

    一般来说,用pandas处理小于100兆的数据,性能不是问题。当用pandas来处理100兆至几个G的数据时,将会比较耗时,同时会导致程序因内存不足而运行失败。

    当然,像Spark这类的工具能够胜任处理100G至几个T的大数据集,但要想充分发挥这些工具的优势,通常需要比较贵的硬件设备。而且,这些工具不像pandas那样具有丰富的进行高质量数据清洗、探索和分析的特性。对于中等规模的数据,我们的愿望是尽量让pandas继续发挥其优势,而不是换用其他工具。

    本文我们讨论pandas的内存使用,展示怎样简单地为数据列选择合适的数据类型,就能够减少dataframe近90%的内存占用。

    处理棒球比赛记录数据

    我们将处理130年的棒球甲级联赛的数据,数据源于Retrosheet

    原始数据放在127个csv文件中,我们已经用csvkit将其合并,并添加了表头。如果你想下载我们版本的数据用来运行本文的程序,我们提供了下载地址

    我们从导入数据,并输出前5行开始:

    import pandas as pd
    
    gl = pd.read_csv('game_logs.csv')
    gl.head()
      date number_of_game day_of_week v_name v_league v_game_number h_name
    0 18710504 0 Thu CL1 na 1 FW1
    1 18710505 0 Fri BS1 na 1 WS3
    2 18710506 0 Sat CL1 na 2 RC1
    3 18710508 0 Mon CL1 na 3 CH1
    4 18710509 0 Tue BS1 na 2 TRO

    我们将一些重要的字段列在下面:

    • date - 比赛日期
    • v_name - 客队名
    • v_league - 客队联赛
    • h_name - 主队名
    • h_league - 主队联赛
    • v_score - 客队得分
    • h_score - 主队得分
    • v_line_score - 客队线得分, 如010000(10)00.
    • h_line_score- 主队线得分, 如010000(10)0X.
    • park_id - 主办场地的ID
    • attendance- 比赛出席人数

    我们可以用Dataframe.info()方法来获得我们dataframe的一些高level信息,譬如数据量、数据类型和内存使用量。

    这个方法默认情况下返回一个近似的内存使用量,现在我们设置参数memory_usage'deep'来获得准确的内存使用量:

    gl.info(memory_usage='deep')
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 171907 entries, 0 to 171906
    Columns: 161 entries, date to acquisition_info
    dtypes: float64(77), int64(6), object(78)
    memory usage: 861.6 MB
    

    我们可以看到它有171907行和161列。pandas已经为我们自动检测了数据类型,其中包括83列数值型数据和78列对象型数据。对象型数据列用于字符串或包含混合数据类型的列。

    由此我们可以进一步了解我们应该如何减少内存占用,下面我们来看一看pandas如何在内存中存储数据。

    Dataframe对象的内部表示

    在底层,pandas会按照数据类型将列分组形成数据块(blocks)。下图所示为pandas如何存储我们数据表的前十二列:

    可以注意到,这些数据块没有保持对列名的引用,这是由于为了存储dataframe中的真实数据,这些数据块都经过了优化。有个BlockManager类会用于保持行列索引与真实数据块的映射关系。他扮演一个API,提供对底层数据的访问。每当我们查询、编辑或删除数据时,dataframe类会利用BlockManager类接口将我们的请求转换为函数和方法的调用。

    每种数据类型在pandas.core.internals模块中都有一个特定的类。pandas使用ObjectBlock类来表示包含字符串列的数据块,用FloatBlock类来表示包含浮点型列的数据块。对于包含数值型数据(比如整型和浮点型)的数据块,pandas会合并这些列,并把它们存储为一个Numpy数组(ndarray)。Numpy数组是在C数组的基础上创建的,其值在内存中是连续存储的。基于这种存储机制,对其切片的访问是相当快的。

    由于不同类型的数据是分开存放的,我们将检查不同数据类型的内存使用情况,我们先看看各数据类型的平均内存使用量:

    for dtype in ['float','int','object']:
        selected_dtype = gl.select_dtypes(include=[dtype])
        mean_usage_b = selected_dtype.memory_usage(deep=True).mean()
        mean_usage_mb = mean_usage_b / 1024 ** 2
        print("Average memory usage for {} columns: {:03.2f} MB".format(dtype,mean_usage_mb))
    Average memory usage for float columns: 1.29 MB
    Average memory usage for int columns: 1.12 MB
    Average memory usage for object columns: 9.53 MB
    

    我们可以看到内存使用最多的是78个object列,我们待会再来看它们,我们先来看看我们能否提高数值型列的内存使用效率。

    理解子类型(Subtypes)

    刚才我们提到,pandas在底层将数值型数据表示成Numpy数组,并在内存中连续存储。这种存储方式消耗较少的空间,并允许我们较快速地访问数据。由于pandas使用相同数量的字节来表示同一类型的每一个值,并且numpy数组存储了这些值的数量,所以pandas能够快速准确地返回数值型列所消耗的字节量。

    pandas中的许多数据类型具有多个子类型,它们可以使用较少的字节去表示不同数据,比如,float型就有float16float32float64这些子类型。这些类型名称的数字部分表明了这种类型使用了多少比特来表示数据,比如刚才列出的子类型分别使用了2、4、8个字节。下面这张表列出了pandas中常用类型的子类型:

    memory usage float int uint datetime bool object
    1 bytes int8 uint8 bool
    2 bytes float16 int16 uint16
    4 bytes float32 int32 uint32
    8 bytes float64 int64 uint64 datetime64
    variable object

    一个int8类型的数据使用1个字节(8位比特)存储一个值,可以表示256(2^8)个二进制数值。这意味着我们可以用这种子类型去表示从-128到127(包括0)的数值。

    我们可以用numpy.iinfo类来确认每一个整型子类型的最小和最大值,如下:

    import numpy as np
    int_types = ["uint8", "int8", "int16"]
    for it in int_types:
        print(np.iinfo(it))
    Machine parameters for uint8
    -----------------------------------------------------
    min = 0
    max = 255
    -----------------------------------------------------
    
    Machine parameters for int8
    -----------------------------------------------------
    min = -128
    max = 127
    -----------------------------------------------------
    
    Machine parameters for int16
    -----------------------------------------------------
    min = -32768
    max = 32767
    -----------------------------------------------------
    

    这里我们还可以看到uint(无符号整型)和int(有符号整型)的区别。两者都占用相同的内存存储量,但无符号整型由于只存正数,所以可以更高效的存储只含正数的列。

    用子类型优化数值型列

    我们可以用函数pd.to_numeric()来对数值型进行向下类型转换。我们用DataFrame.select_dtypes来只选择整型列,然后我们优化这种类型,并比较内存使用量。

    # We're going to be calculating memory usage a lot,
    # so we'll create a function to save us some time!
    
    def mem_usage(pandas_obj):
        if isinstance(pandas_obj,pd.DataFrame):
            usage_b = pandas_obj.memory_usage(deep=True).sum()
        else: # we assume if not a df it's a series
            usage_b = pandas_obj.memory_usage(deep=True)
        usage_mb = usage_b / 1024 ** 2 # convert bytes to megabytes
        return "{:03.2f} MB".format(usage_mb)
    
    gl_int = gl.select_dtypes(include=['int'])
    converted_int = gl_int.apply(pd.to_numeric,downcast='unsigned')
    
    print(mem_usage(gl_int))
    print(mem_usage(converted_int))
    
    compare_ints = pd.concat([gl_int.dtypes,converted_int.dtypes],axis=1)
    compare_ints.columns = ['before','after']
    compare_ints.apply(pd.Series.value_counts)
    7.87 MB
    1.48 MB
    
      before after
    uint8 NaN 5.0
    uint32 NaN 1.0
    int64 6.0 NaN

    我们看到内存用量从7.9兆下降到1.5兆,降幅达80%。这对我们原始dataframe的影响有限,这是由于它只包含很少的整型列。

    同理,我们再对浮点型列进行相应处理:

    gl_float = gl.select_dtypes(include=['float'])
    converted_float = gl_float.apply(pd.to_numeric,downcast='float')
    
    print(mem_usage(gl_float))
    print(mem_usage(converted_float))
    
    compare_floats = pd.concat([gl_float.dtypes,converted_float.dtypes],axis=1)
    compare_floats.columns = ['before','after']
    compare_floats.apply(pd.Series.value_counts)
    100.99 MB
    50.49 MB
    
      before after
    float32 NaN 77.0
    float64 77.0 NaN

    我们可以看到所有的浮点型列都从float64转换为float32,内存用量减少50%。

    我们再创建一个原始dataframe的副本,将其数值列赋值为优化后的类型,再看看内存用量的整体优化效果。

    optimized_gl = gl.copy()
    
    optimized_gl[converted_int.columns] = converted_int
    optimized_gl[converted_float.columns] = converted_float
    
    print(mem_usage(gl))
    print(mem_usage(optimized_gl))
    861.57 MB
    804.69 MB
    

    可以看到通过我们显著缩减数值型列的内存用量,我们的dataframe的整体内存用量减少了7%。余下的大部分优化将针对object类型进行。

    在这之前,我们先来研究下与数值型相比,pandas如何存储字符串。

    对比数值与字符的存储

    object类型用来表示用到了Python字符串对象的值,有一部分原因是Numpy缺少对缺失字符串值的支持。因为Python是一种高层、解析型语言,它没有提供很好的对内存中数据如何存储的细粒度控制。

    这一限制导致了字符串以一种碎片化方式进行存储,消耗更多的内存,并且访问速度低下。在object列中的每一个元素实际上都是存放内存中真实数据位置的指针。

    下图对比展示了数值型数据怎样以Numpy数据类型存储,和字符串怎样以Python内置类型进行存储的。


    图示来源并改编自Why Python Is Slow

    你可能注意到上文表中提到object类型数据使用可变(variable)大小的内存。由于一个指针占用1字节,因此每一个字符串占用的内存量与它在Python中单独存储所占用的内存量相等。我们用sys.getsizeof()来证明这一点,先来看看在Python单独存储字符串,再来看看使用pandas的series的情况。

    from sys import getsizeof
    
    s1 = 'working out'
    s2 = 'memory usage for'
    s3 = 'strings in python is fun!'
    s4 = 'strings in python is fun!'
    
    for s in [s1, s2, s3, s4]:
        print(getsizeof(s))
    60
    65
    74
    74
    
    obj_series = pd.Series(['working out',
                              'memory usage for',
                              'strings in python is fun!',
                              'strings in python is fun!'])
    obj_series.apply(getsizeof)
    0    60
    1    65
    2    74
    3    74
    dtype: int64
    

    你可以看到这些字符串的大小在pandas的series中与在Python的单独字符串中是一样的。

    用类别(categoricals)类型优化object类型

    Pandas在0.15版本中引入类别类型。category类型在底层使用整型数值来表示该列的值,而不是用原值。Pandas用一个字典来构建这些整型数据到原数据的映射关系。当一列只包含有限种值时,这种设计是很不错的。当我们把一列转换成category类型时,pandas会用一种最省空间的int子类型去表示这一列中所有的唯一值。

    为了介绍我们何处会用到这种类型去减少内存消耗,让我们来看看我们数据中每一个object类型列中的唯一值个数。

    gl_obj = gl.select_dtypes(include=['object']).copy()
    gl_obj.describe()
      day_of_week v_name v_league h_name h_league day_night
    count 171907 171907 171907 171907 171907 140150
    unique 7 148 7 148 7 2
    top Sat CHN NL CHN NL D
    freq 28891 8870 88866 9024 88867 82724

    可以看到在我们包含了近172000场比赛的数据集中,很多列只包含了少数几个唯一值。

    我们先选择其中一个object列,开看看将其转换成类别类型会发生什么。这里我们选用第二列:day_of_week

    我们从上表中可以看到,它只包含了7个唯一值。我们用.astype()方法将其转换为类别类型。

    dow = gl_obj.day_of_week
    print(dow.head())
    
    dow_cat = dow.astype('category')
    print(dow_cat.head())
    0    Thu
    1    Fri
    2    Sat
    3    Mon
    4    Tue
    Name: day_of_week, dtype: object
    0    Thu
    1    Fri
    2    Sat
    3    Mon
    4    Tue
    Name: day_of_week, dtype: category
    Categories (7, object): [Fri, Mon, Sat, Sun, Thu, Tue, Wed]
    

    可以看到,虽然列的类型改变了,但数据看上去好像没什么变化。我们来看看底层发生了什么。

    下面的代码中,我们用Series.cat.codes属性来返回category类型用以表示每个值的整型数字。

    dow_cat.head().cat.codes
    0    4
    1    0
    2    2
    3    1
    4    5
    dtype: int8
    

    可以看到,每一个值都被赋值为一个整数,而且这一列在底层是int8类型。这一列没有任何缺失数据,但是如果有,category子类型会将缺失数据设为-1。

    最后,我们来看看这一列在转换为category类型前后的内存使用量。

    print(mem_usage(dow))
    print(mem_usage(dow_cat))
    9.84 MB
    0.16 MB
    

    内存用量从9.8兆降到0.16兆,近乎98%的降幅!注意这一特殊列可能代表了我们一个极好的例子——一个包含近172000个数据的列只有7个唯一值。

    这样的话,我们把所有这种类型的列都转换成类别类型应该会很不错,但这里面也要权衡利弊。首要问题是转变为类别类型会丧失数值计算能力,在将类别类型转换成真实的数值类型前,我们不能对category列做算术运算,也不能使用诸如Series.min()Series.max()等方法。

    对于唯一值数量少于50%的object列,我们应该坚持首先使用category类型。如果某一列全都是唯一值,category类型将会占用更多内存。这是因为这样做不仅要存储全部的原始字符串数据,还要存储整型类别标识。有关category类型的更多限制,参看pandas文档

    下面我们写一个循环,对每一个object列进行迭代,检查其唯一值是否少于50%,如果是,则转换成类别类型。

    converted_obj = pd.DataFrame()
    
    for col in gl_obj.columns:
        num_unique_values = len(gl_obj[col].unique())
        num_total_values = len(gl_obj[col])
        if num_unique_values / num_total_values < 0.5:
            converted_obj.loc[:,col] = gl_obj[col].astype('category')
        else:
            converted_obj.loc[:,col] = gl_obj[col]

    更之前一样进行比较:

    print(mem_usage(gl_obj))
    print(mem_usage(converted_obj))
    
    compare_obj = pd.concat([gl_obj.dtypes,converted_obj.dtypes],axis=1)
    compare_obj.columns = ['before','after']
    compare_obj.apply(pd.Series.value_counts)
    752.72 MB
    51.67 MB
    
      before after
    object 78.0 NaN
    category NaN 78.0

    这本例中,所有的object列都被转换成了category类型,但其他数据集就不一定了,所以你最好还是得使用刚才的检查过程。

    本例的亮点是内存用量从752.72兆降为51.667兆,降幅达93%。我们将其与我们dataframe的剩下部分合并,看看初始的861兆数据降到了多少。

    optimized_gl[converted_obj.columns] = converted_obj
    
    mem_usage(optimized_gl)
    '103.64 MB'
    

    耶,看来我们的进展还不错!我们还有一招可以做优化,如果你记得我们刚才那张类型表,会发现我们数据集第一列还可以用datetime类型来表示。

    date = optimized_gl.date
    print(mem_usage(date))
    date.head()
    0.66 MB
    0    18710504
    1    18710505
    2    18710506
    3    18710508
    4    18710509
    Name: date, dtype: uint32
    

    你可能还记得这一列之前是作为整型读入的,并优化成了uint32。因此,将其转换成datetime会占用原来两倍的内存,因为datetime类型是64位比特的。将其转换为datetime的意义在于它可以便于我们进行时间序列分析。

    转换使用pandas.to_datetime()函数,并使用format参数告之日期数据存储为YYYY-MM-DD格式。

    optimized_gl['date'] = pd.to_datetime(date,format='%Y%m%d')
    
    print(mem_usage(optimized_gl))
    optimized_gl.date.head()
    104.29 MB
    0   1871-05-04
    1   1871-05-05
    2   1871-05-06
    3   1871-05-08
    4   1871-05-09
    Name: date, dtype: datetime64[ns]
    

    在数据读入的时候设定数据类型

    目前为止,我们探索了一些方法,用来减少现有dataframe的内存占用。通过首先读入dataframe,再对其一步步进行内存优化,我们可以更好地了解这些优化方法能节省多少内存。然而,正如我们之前谈到,我们通常没有足够的内存去表达数据集中的所有数据。如果不能在一开始就创建dataframe,我们怎样才能应用内存节省技术呢?

    幸运的是,我们可以在读入数据集的时候指定列的最优数据类型。pandas.read_csv()函数有一些参数可以做到这一点。dtype参数接受一个以列名(string型)为键字典、以Numpy类型对象为值的字典。

    首先,我们将每一列的目标类型存储在以列名为键的字典中,开始前先删除日期列,因为它需要分开单独处理。

    dtypes = optimized_gl.drop('date',axis=1).dtypes
    
    dtypes_col = dtypes.index
    dtypes_type = [i.name for i in dtypes.values]
    
    column_types = dict(zip(dtypes_col, dtypes_type))
    
    # rather than print all 161 items, we'll
    # sample 10 key/value pairs from the dict
    # and print it nicely using prettyprint
    
    preview = first2pairs = {key:value for key,value in list(column_types.items())[:10]}
    import pprint
    pp = pp = pprint.PrettyPrinter(indent=4)
    pp.pprint(preview)
    {   'acquisition_info': 'category',
        'h_caught_stealing': 'float32',
        'h_player_1_name': 'category',
        'h_player_9_name': 'category',
        'v_assists': 'float32',
        'v_first_catcher_interference': 'float32',
        'v_grounded_into_double': 'float32',
        'v_player_1_id': 'category',
        'v_player_3_id': 'category',
        'v_player_5_id': 'category'}
    

    现在我们使用这个字典,同时传入一些处理日期的参数,让日期以正确的格式读入。

    read_and_optimized = pd.read_csv('game_logs.csv',dtype=column_types,parse_dates=['date'],infer_datetime_format=True)
    
    print(mem_usage(read_and_optimized))
    read_and_optimized.head()
    104.28 MB
    
      date number_of_game day_of_week v_name v_league v_game_number h_name
    0 1871-05-04 0 Thu CL1 na 1 FW1
    1 1871-05-05 0 Fri BS1 na 1 WS3
    2 1871-05-06 0 Sat CL1 na 2 RC1
    3 1871-05-08 0 Mon CL1 na 3 CH1
    4 1871-05-09 0 Tue BS1 na 2 TRO

    通过对列的优化,我们是pandas的内存用量从861.6兆降到104.28兆,有效降低88%。

    分析棒球比赛

    现在我们有了优化后的数据,可以进行一些分析。我们先看看比赛日的分布情况。

    optimized_gl['year'] = optimized_gl.date.dt.year
    games_per_day = optimized_gl.pivot_table(index='year',columns='day_of_week',values='date',aggfunc=len)
    games_per_day = games_per_day.divide(games_per_day.sum(axis=1),axis=0)
    
    ax = games_per_day.plot(kind='area',stacked='true')
    ax.legend(loc='upper right')
    ax.set_ylim(0,1)
    plt.show()

    我们可以看到,1920年代之前,周日棒球赛很少是在周日的,随后半个世纪才逐渐增多。

    我们也看到最后50年的比赛日分布变化相对比较平稳。

    我们来看看比赛时长的逐年变化。

    game_lengths = optimized_gl.pivot_table(index='year', values='length_minutes')
    game_lengths.reset_index().plot.scatter('year','length_minutes')
    plt.show()

    看来棒球比赛时长从1940年代之后逐渐变长。

    总结

    我们学习了pandas如何存储不同的数据类型,并利用学到的知识将我们的pandas dataframe的内存用量降低了近90%,仅仅只用了一点简单的技巧:

    • 将数值型列降级到更高效的类型
    • 将字符串列转换为类别类型
    展开全文
  • 同学们在进行数据分析、数据处理时经常会使用pandas来储存结构化数据。我们在数据处理中会出现各种的过程文件或最终文件,虽然pandas给我们提供了非常多的输出结口,比如csv文件、xlsx文件、html文件、文本文件,...

    安装准备(可以不用看)

    同学们在进行数据分析、数据处理时经常会使用pandas来储存结构化数据。我们在数据处理中会出现各种的过程文件或最终文件,虽然pandas给我们提供了非常多的输出结口,比如csv文件、xlsx文件、html文件、文本文件,但是这些文件都有各自的限制。如csv文件在大数据量情况下文件过大,xlsx只能保存100万左右的文件,html、文本文件不利于关联分析等等。而pandas当然也提供了输出dataframe对象到数据库的输出接口,MySQL作为一种功能多样,较为成熟的数据库,同样也是一个不错的选择。
    1、pymysql 2、sqlalchemy

    1、导入dataframe数据到mysql

    from sqlalchemy import create_engine
    engine = create_engine("mysql+pymysql://use:pwd@localhost:3306/test?charset=utf8")
    df.to_sql("table", engine, schema="test", if_exists='replace', index=True,
                chunksize=None, dtype=None)
    

    use:就是你的用户名
    pwd:就是你的用户密码
    localhost:如果是本地就是localhost,如果是远程则为对应的ip
    3306:对应的端口
    test:要进行操作的数据库名
    table:要进行操作的表
    schema:同上,对应的数据库名
    if_exists(
    fail(添加):如果表存在,则不进行操作
    replace(覆盖):如果表存在就删除表,重新生成,插入数据
    append(更新):如果表存在就插入数据,不存在就直接生成表
    )
    index:是否需要索引,视情况而定
    chunksize:对数据量过大的dataframe进行分块处理,百万以下的数据一般不用处理。
    dtype:指定的数据类型
    df:要导入进MySQL的dataframe对象

    2、从mysql中导出dataframe对象

    注意:从mysql导出dataframe对象,不一定要求数据表存的是我们导入的dataframe对象,而是任何一张表都可以作为dataframe对象被我们导出进行操作。

    conn = pymysql.connect(host="localhost",port=3306,user="use",
                           password="pwd",database="test",charset="utf8")
    sql = "select * from table;"
    df = pd.read_sql(sql,conn)
    

    host:数据库路径,本地为localhost
    port:端口一般为3306
    user:用户名
    pssword:密码
    database:操作的数据库名
    table:对应的表名
    df即为从表中生成的dataframe对象

    展开全文
  • CSV导出大量数据

    2017-04-29 19:49:15
    $csvname = $csvname . '.csv'; header('Content-Type: application/vnd.ms-excel;charset=GB2312'); header('Content-Disposition: attachment;filename="' . $csvname ....header('Cache-Control: max-age=0')
    $csvname = $csvname . '.csv';
    header('Content-Type: application/vnd.ms-excel;charset=GB2312');
    header('Content-Disposition: attachment;filename="' . $csvname . '"');
    header('Cache-Control: max-age=0');
    header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT');
    header('Cache-Control: no-cache, must-revalidate'); //HTTP/1.1
    //open handle,php://output 表示直接输出到浏览器
    $fp = fopen('php://output', 'a');
    
    //output csv first column
    $head = $columName;
    foreach ($head as $i => $v) {
        $head[$i] = iconv('utf-8', 'gbk', $v);
    }
    fputcsv($fp, $head);
    
    // 计数器
    $cnt = 0;
    $limit = 2000;
    
    // 从数据库中获取数据,节省内存,从句柄中一行一行读即可
    $i = 2;
    
    foreach ($result as $key => $val) {
        $cnt++;
        //每隔$limit行,刷新一下输出buffer
        if ($limit == $cnt) {
            ob_flush();
            flush();
            $cnt = 0;
        }
    
        $rows[$i] = iconv('utf-8', 'gbk', $val['vendor_item']);
        $rows[$i + 1] = iconv('utf-8', 'gbk', $val['item_code']);
        $rows[$i + 2] = iconv('utf-8', 'gbk', $val['product_name']);
        $rows[$i + 3] = iconv('utf-8', 'gbk', $val['brand_code']);
        $rows[$i + 4] = iconv('utf-8', 'gbk', $val['brand']);
        $rows[$i + 5] = iconv('utf-8', 'gbk', $val['vendor_id']);
        $rows[$i + 6] = iconv('utf-8', 'gbk', $val['vendor_name']);
        $rows[$i + 7] = iconv('utf-8', 'gbk', $val['warehouse_code']);
        $rows[$i + 8] = iconv('utf-8', 'gbk', $val['quantity']);
        $rows[$i + 9] = iconv('utf-8', 'gbk', $val['lockcount']);
        $rows[$i + 10] = iconv('utf-8', 'gbk', $val['bindcount']);
        fputcsv($fp, $rows);
        //释放数组
        unset($rows);
    }
    展开全文
  • pandas 数据导入在pandas中数据导入有对应的模块;本节解决三个关键问题:(1)路径斜线问题;(2)中文路径问题;(3)编码问题;正常导入见下,若没问题则完事大吉,但往往没这么顺利。import pandas as pd file_...

    pandas 数据导入

    在pandas中数据导入有对应的模块;本节解决三个关键问题:

    (1)路径斜线问题;

    (2)中文路径问题;

    (3)编码问题;

    正常导入见下,若没问题则完事大吉,但往往没这么顺利。

    import pandas as pd
    file_path = 'D:/0Raw_data/ftm_p.csv'
    data = pd.read_csv(file_path)

    1、导入路径斜线问题

    当错误类型如下,则一般是路径斜线问题。

    ValueError: stat: embedded null character in path

    在win中的直接复制的路径,斜线默认是“\”;但在python中路径一般首选是“/”;有3种合理解决方案:

    file_path1 = 'D:/0Raw_data/ftm_p.csv'
    file_path2 = 'D:\\0Raw_data\\ftm_p.csv'
    file_path3 = r'D:\0Raw_data\ftm_p.csv'

    2、中文路径问题

    当错误类型如下,则一般是中文路径问题。

    OSError: Initializing from file failed

    不废话,解决方案就是先用open打开,而且一般用open先打开,能直接解决编码问题:

    file_path = 'D:/0Raw_data/zhaoyang_charge_sta/京AW7531'
    path = open(file_path)
    data = pd.read_csv(path)

    3、编码问题

    当错误类型如下,则一般是编码问题。panda读取时会先检测第一个字符的编码类型,若不是'utf-8'则会报错。

    UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb9 in position 0: invalid start byte

    还是不废话,直接解决方案:

    解决方案1,用open,请注意报错问题,可以合理配置encoding,在中国一般就为'utf-8'或者'gbk'。

    import pandas as pd
    file_path = 'D:/0Raw_data/zhaoyang_charge_sta/京AW7531'
    f = open(file_path,encoding='utf-8')
    data = pd.read_csv(f)
    f.close()

    解决方案2,配置pandas的encoding;

    import pandas as pd
    file_path = 'D:/0Raw_data/zhaoyang_charge_sta/京AW7531'
    data = pd.read_csv('D:/0Raw_data/ftm_p.csv',encoding='gbk')

    4、总结

    因为本人主要研究车辆网大数据分析,在不上spark的情况下,也不可能一个一个配置每个文件的编码问题,所以我一般用鲁棒性较好的解决方案如下,供参考。若能解决您的问题,请点个赞,欢迎交流。

    import pandas as pd
    file_path = 'D:/0Raw_data/zhaoyang_charge_sta/京AW7531'
    f = open(file_path,encoding='utf-8')
    data = pd.read_csv(f)
    f.close()


    展开全文
  • 作者:王雅宁 转载自: https://blog.csdn.net/insightzen_xian/article/details/80659243 目录 0.序言 1. 数据接入 2. 脏数据的清洗 3. 缺失值的处理 4. 数据质量核查与基本的...本文主要以基于AWS 搭建的...
  • 有如下csv文件,在读取之后,如何输出为同样的格式 1、常见用法 >>> df.to_csv(r'D:/myExcel/res.csv') >>> df = pd.read_csv(r'D:/myExcel/2.csv') >>> df ...0 1 ...
  • 我用 python pandas 写了数据统计与分析脚本,并把计算结果用 pandas 的 to_excel() 存入到 excel 表格提交给团队。但遇到一个问题:当我的老板和同事们打开 excel 文件时,发现百分比数值无法正常显示,提示为...
  • 一.HSSF,XSSF和SXSSF的区别 HSSF是POI工程对Excel 97-2007 (.xls) 文件操作的纯Java实现 XSSF是POI工程对Excel 2007 OOXML (.xlsx) 文件操作的纯Java实现 从POI 3.8版本开始,提供了一种基于...百万级数据高效导出.
  • 3、循环读进pandas 比如,想要从全国的POI数据中,读取四川省的: import pandas as pd import numpy as np import os from tqdm._tqdm_notebook import tnrange filepath='D:\\高德POI数据全国\\2018-POIC...
  • pandas 处理CSV大文件

    2018-11-02 09:55:16
    1、pandas操作CSV import pandas as pd df = pd.read_csv('datas/donations.csv', nrows=10000) # nrows设置读取数据的行数 donation_src_table = pd.DataFrame(df, columns=['projectid', 'is_teacher_acct']) #...
  • 使用python将大量数据导出到Excel中的小技巧分享今天小编就为大家分享一篇使用python将大量数据导出到Excel中的小技巧心得,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧(1) 问题描述:为了更...
  • Pandas是Python中用于数据处理与分析的屠龙刀,想必大家也都不陌生,但Pandas在使用上有一些技巧和需要注意的地方,尤其是对于较大的数据集而言,如果你没有适当地使用,那么可能会导致Pandas的运行速度非常慢。...
  • 一、通过pandas导出数据 pandas的两大数据类型See 1、to_csv(),导出文本文件
  • 事实确实如此,在数据分析领域,那么如何处理亿级数据呢,pandas提供了IO工具可以将大文件分块读取,测试了一下性能,非常不错。可谓是瑞士中的军刀python 读取亿级数据代码如下:# encoding: utf-8 import sys ...
  • pandas-profiling第一印象应该是pandas吧,pandas-profiling确实和pandas有点关系,pandas-profiling能够使用DataFrame自动生成数据的详细报告,相比describe生成的profile要详细的多。 pandas_profiling基于pandas...
  • 0.实验环境 待切割CSV文件大小:1.5G(字段有中文有英文) 所介绍的两个软件的下载地址:CSVSplitter和CSVed打包下载地址 1.CSVSplitter 本次实验使用的就是这个神器,优势有两个: ...可以转换CSV里面的中文字段...
  • 【python基础操作】数据集/模型输出结果导出为EXCEL/CSV文件 【编程小白的逆袭之路,我们一起学习python吧~】 本篇介绍的是如何将 list 或 numpy.narray 类型的数据导出为excel/csv文件。 我们以python中的自带的...
  • 在数据分析领域,最热门的莫过于Python和R语言,此前有一篇文章《别老扯什么Hadoop了,你的数据根本不够大》指出:只有在超过5TB数据量的规模下,Hadoop才是一个合理的技术选择。这次拿到近亿条日志数据,...
  • 今天接到一个业务的需求,需要把一部分据大量的数据导出excel,数据达到千万级 从一开始打算直接使用plsql导出tsv文件,然后直接脚本处理,后来发现数据量太大,在查询的过程中一不小心出现闪断,前功尽弃。于是...
1 2 3 4 5 ... 20
收藏数 929
精华内容 371