• 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文件中读取:


    展开全文
  • 如果你的电脑内存较小那么想在本地做一些事情是很有局限性的(哭丧脸),比如想拿一个kaggle上面的竞赛来练练手,你会发现多数训练数据集都是大几G或者几十G的,自己那小破电脑根本跑不起来。行,你有8000w条样本你...

    如果你的电脑内存较小那么想在本地做一些事情是很有局限性的(哭丧脸),比如想拿一个kaggle上面的竞赛来练练手,你会发现多数训练数据集都是大几G或者几十G的,自己那小破电脑根本跑不起来。行,你有8000w条样本你牛逼,我就取400w条出来跑跑总行了吧(狡滑脸)。

    下图是2015年kaggle上一个CTR预估比赛的数据集:

    看到train了吧,原始数据集6个G,特征工程后得多大?那我就取400w出来train。为了节省时间和完整介绍分批读入数据的功能,这里以test数据集为例演示。其实就是使用pandas读取数据集时加入参数chunksize。

    可以通过设置chunksize大小分批读入,也可以设置iterator=True后通过get_chunk选取任意行。

    当然将分批读入的数据合并后就是整个数据集了。

    ok了!

    展开全文
  • 1. 使用 pandas 读取 CSV 文件 原始数据包含了公司员工的数据: Name Hire Date Salary Sick Days remaining Graham Chapman 03/15/14 50000.00 10 John Cleese 06/01/15 65000.00 8 Eric Idle 05/12/14...

    1. 使用 pandas 读取 CSV 文件

    原始数据包含了公司员工的数据:

    Name Hire Date Salary Sick Days remaining
    Graham Chapman 03/15/14 50000.00 10
    John Cleese 06/01/15 65000.00 8
    Eric Idle 05/12/14 45000.00 10
    Terry Jones 11/01/13 70000.00 3
    Terry Gilliam 08/12/14 48000.00 7
    Michael Palin 05/23/13 66000.00 8

    将 CSV 文件读入 pandas DataFrame 快速而直接:

    import pandas
    df = pandas.read_csv('hrdata.csv')
    print(df)
    

    就这样简单:仅仅三行代码,而且其中只有一行真正有用。pandas.read_csv() 打开、分析并读取提供的 CSV 文件,并将数据存储在 DataFrame 中,打印 DataFrame 会产生以下输出:
    在这里插入图片描述
    以下是值得注意的几点:

    首先,pandas 识别到 CSV 的第一行包含列名,并自动使用它们。
    但是,pandas 也在 DataFrame 中使用从零开始的整数索引,那是因为没有告诉它我们的索引应该是什么。
    此外,如果查看列的数据类型,会看到 pandas 已将 Salary and Sick Days 剩余列正确转换为数字,但 Hire Date 列仍然是 String,这在交互模式下很容易确认:
    在这里插入图片描述
    让我们一次解决这些问题,要使用其他列作为 DataFrame 的索引,添加 index_col 可选参数:

    df2 = pandas.read_csv('hrdata.csv', index_col='Name')
    print(df2)
    

    现在,Name 字段就是我们的 DataFrame 索引:

    接下来,让我们修复「Hire Date」字段的数据类型。可以使用 parse_dates 可选参数强制pandas 将数据作为日期读取,该参数定义为要作为日期处理的列名列表:

    df3 = pandas.read_csv('hrdata.csv', index_col='Name', parse_dates=['Hire Date'])
    print(df3)
    

    注意输出的差异:
    在这里插入图片描述
    现在日期格式正确,可以在交互模式下轻松确认:

    在这里插入图片描述
    如果 CSV 文件的第一行中没有列名,则可以使用 names 可选参数来提供列名的列表。 如果要覆盖第一行中提供的列名,也可以使用此选项。 在这种情况下,还必须使用header = 0可选参数告诉 pandas.read_csv()忽略现有列名:

    df4 = pandas.read_csv('hrdata.csv', 
                index_col='Employee', 
                parse_dates=['Hired'], 
                header=0, 
                names=['Employee', 'Hired','Salary', 'Sick Days'])
    print(df4)
    

    请注意,由于列名称已更改,因此还必须更改index_col和parse_dates可选参数中指定的列,现在这会产生以下输出:
    在这里插入图片描述

    2. 使用 pandas 写入 CSV 文件

    当然,如果无法将数据从 pandas 中输出,那 pandas 可能没有多大好处。将 DataFrame 写入CSV 文件就像读取一个文件一样简单。下面让我们将带有新列名称的数据写入新的 CSV 文件:

    df5 = pandas.read_csv('hrdata.csv', 
                index_col='Employee', 
                parse_dates=['Hired'],
                header=0, 
                names=['Employee', 'Hired', 'Salary', 'Sick Days'])
    df5.to_csv('hrdata_modified.csv')
    

    此代码与上述读取代码之间的唯一区别是 print(df) 替换为 df.to_csv(),新的 CSV 文件如下所示:

    在这里插入图片描述
    参考此文章

    展开全文
  • import pandas as pd #在哪里搜索多个表格 filelocation="F:\\" #当前文件夹下搜索的文件名后缀 fileform="xlsx" #首先查找默认文件夹下有多少文档需要整合 filearray=[] for filename in...
    import glob
    import pandas as pd
    #在哪里搜索多个表格  
    filelocation="F:\\"  
    #当前文件夹下搜索的文件名后缀  
    fileform="xlsx"  
    #首先查找默认文件夹下有多少文档需要整合  
    filearray=[]  
    for filename in glob.glob(filelocation+"*."+fileform):  
        filearray.append(filename)  
    #以上是从pythonscripts文件夹下读取所有excel表格,并将所有的名字存储到列表filearray
    print("在默认文件夹下有%d个文档"%len(filearray)) 
    ge=len(filearray)  
    matrix = [None]*ge  
    #定义空的DataFrame,接收数据
    all_data = pd.DataFrame()
    #读取数据
    for i in range(ge):
       print(i)
       l_data = pd.read_excel(filearray[i])
       all_data = all_data.append(l_data)
    


    展开全文
  • 在这篇文章中,我们将看看如何利用像Pandas这样的工具来探索和绘制出Maryland州Montgomery郡的警察活动。我们开始会一起看一下JSON数据,然后过渡到勘探和分析。 当数据存储在SQL数据库时,它倾向于遵循一个看起来...

    处理大量的JSON数据集可能会很痛苦,特别是当它们太大而无法装入内存时。在这种情况下,命令行工具和Python的组合可以为探索和分析数据提供一种有效的方式。在这篇文章中,我们将看看如何利用像Pandas这样的工具来探索和绘制出Maryland州Montgomery郡的警察活动。我们开始会一起看一下JSON数据,然后过渡到勘探和分析。

    当数据存储在SQL数据库时,它倾向于遵循一个看起来像一个表的刚性结构。下面是SQLite数据库中的一个例子:

    id|code|name|area|area_land|area_water|population|population_growth|birth_rate|death_rate|migration_rate|created_at|updated_at
    1|af|Afghanistan|652230|652230|0|32564342|2.32|38.57|13.89|1.51|2015-11-01 13:19:49.461734|2015-11-01 13:19:49.461734
    2|al|Albania|28748|27398|1350|3029278|0.3|12.92|6.58|3.3|2015-11-01 13:19:54.431082|2015-11-01 13:19:54.431082
    3|ag|Algeria|2381741|2381741|0|39542166|1.84|23.67|4.31|0.92|2015-11-01 13:19:59.961286|2015-11-01 13:19:59.961286
    正如你所看到的,数据由行和列组成,其中每列映射到一个定义的属性,像id或code。在上面的数据集中,每一行代表一个国家,每一列代表关于这个国家的一些事实。

    但随着我们所采集的数据量的增加,我们常常不知道存储它时确切的数据结构。这就是所谓的非结构化数据。一个很好的例子是一个网站上的访客事件的列表。下面是一个发送到服务器的事件列表的例子:

      {'event_type': 'started-mission',
       'keen': {'created_at': '2015-06-12T23:09:03.966Z',
        'id': '557b668fd2eaaa2e7c5e916b',
        'timestamp': '2015-06-12T23:09:07.971Z'},
       'sequence': 1}

      {'event_type': 'started-screen',
       'keen': {'created_at': '2015-06-12T23:09:03.979Z',
        'id': '557b668f90e4bd26c10b6ed6',
        'timestamp': '2015-06-12T23:09:07.987Z'},
       'mission': 1,
       'sequence': 4,
       'type': 'code'}

      {'event_type': 'started-screen',
       'keen': {'created_at': '2015-06-12T23:09:22.517Z',
        'id': '557b66a246f9a7239038b1e0',
        'timestamp': '2015-06-12T23:09:24.246Z'},
       'mission': 1,
       'sequence': 3,
       'type': 'code'},
    正如你所看到的,上面列出了三​个独立的事件。每个事件具有不同的字段,并且一些字段被嵌套到另一个字段内。这种类型的数据是非常难存储到常规的SQL数据库中的。这样的非结构化数据通常存储在一个称为JavaScript Object Notation (JSON)的格式中。JSON是一种编码像列表和字典这样的数据结构为字符串的方式,它确保它们容易被机器所读取。即使JSON由单词Javascript开头,但是它实际上只是一种格式,并且可以通过任何语言来读取。

    Python对JSON有很大的支持,它拥有json库。我们既可以转换列表和字典到JSON,也可以将字符串转换为表和字典。JSON数据看起来很像Python中的一个字典,它存储了键和值。

    在这篇文章中,我们将在命令行上探讨一个JSON文件,然后将其导入Python,并使用Pandas对其进行处理。

    数据集


    我们将着眼于一个包含Maryland州Montgomery郡交通违法行为信息的数据集。你也可以在这里下载数据。该数据包含有关违规发生的地点信息,车的类型,关于收到违规的人的人口统计,以及其他一些有趣的信息。我们可以用这个数据集回答相当多的问题,其中包括了几个问题:

    什么类型的汽车是最有可能被超速拦停?

    一天的哪些时候警察最活跃?

    “超速陷阱”有多常见?或者在地理位置方面,交通罚款单是否相当均匀分布?

    人们被拦下来最常见的原因是什么?

    不幸的是,我们不知道JSON文件前期的结构,所以我们需要做一些探索来弄明白它。我们将使用Jupyter Notebook进行这种探索。

    探索数据
    即使JSON文件只有600MB,但是我们将把它当成更大进行处理,这样的话,我们就可以探索如何分析不适合读入的一个JSON文件。我们要做的第一件事就是看看md_traffic.json文件的前几行。一个JSON文件只是一个普通的文本文件,所以我们可以使用所有标准的命令行工具来与它进行交互:

    In [1]:%%bash
            head md_traffic.json
    (输出)

    {
      "meta" : {
        "view" : {
          "id" : "4mse-ku6q",
          "name" : "Traffic Violations",
          "averageRating" : 0,
          "category" : "Public Safety",
          "createdAt" : 1403103517,
          "description" : "This dataset contains traffic violation information from all electronic traffic violations issued in the County.  Any information that can be used to uniquely identify the vehicle, the vehicle owner or the officer issuing the violation will not be published.\r\n\r\nUpdate Frequency:  Daily",
          "displayType" : "table",
    从中我们可以看到,该JSON数据是一个字典,并且格式良好。meta是一个顶级键,缩进两个空格。我们可以使用grep命令让所有的顶级键打印任何有两个前导空格的行:

    In [2]:%%bash

            grep -E '^ {2}"' md_traffic.json
    (输出)

      "meta" : {
      "data" : [ [ 1889194, "92AD0076-5308-45D0-BDE3-6A3A55AD9A04", 1889194, 1455876689, "498050", 1455876689, "498050", null, "2016-02-18T00:00:00", "09:05:00", "MCP", "2nd district, Bethesda", "DRIVER USING HANDS TO USE HANDHELD TELEPHONE WHILEMOTOR VEHICLE IS IN MOTION", "355/TUCKERMAN LN", "-77.105925", "39.03223", "No", "No", "No", "No", "No", "No", "No", "No", "No", "No", "MD", "02 - Automobile", "2010", "JEEP", "CRISWELL", "BLUE", "Citation", "21-1124.2(d2)", "Transportation Article", "No", "WHITE", "F", "GERMANTOWN", "MD", "MD", "A - Marked Patrol", [ "{\"address\":\"\",\"city\":\"\",\"state\":\"\",\"zip\":\"\"}", "-77.105925", "39.03223", null, false ] ]
    这向我们表明,meta和data是md_traffic.json数据中的顶级键。一个列表的列表似乎与data一同出现,而这有可能包括我们交通违法行为集中的每个记录。每一个内部的列表都是一个记录,而第一条记录出现在grep命令的输出中。这非常类似于当我们操作CSV文件或SQL表格时使用的那种格式化数据。下面是数据可能看起来的样子的一个截断视图:

    [
        [1889194, "92AD0076-5308-45D0-BDE3-6A3A55AD9A04", 1889194, 1455876689, "498050"],
        [1889194, "92AD0076-5308-45D0-BDE3-6A3A55AD9A04", 1889194, 1455876689, "498050"],
        ...
    ]
    这看起来很像我们已经习惯使用的行和列。我们只是缺少告诉我们每列表示的含义的头。我们也许能够在meta键下找到此信息。

    meta通常是指关于数据本身的信息。让我们深入了解meta,看看有什么信息都包含在那里。使用head命令,我们知道至少有3个级别的键,meta包含一个键view,而view又包含id, name, averageRating等。我们可以通过使用grep来打印出JSON文件的全键结构,打印出任何具有2-6前导空格的行:

    In [6]:%%bash

            grep -E '^ {2,6}"' md_traffic.json
    (输出)

      "meta" : {
        "view" : {
          "id" : "4mse-ku6q",
          "name" : "Traffic Violations",
          "averageRating" : 0,
          "category" : "Public Safety",
          "createdAt" : 1403103517,
          "description" : "This dataset contains traffic violation information from all electronic traffic violations issued in the County.  Any information that can be used to uniquely identify the vehicle, the vehicle owner or the officer issuing the violation will not be published.\r\n\r\nUpdate Frequency:  Daily",
          "displayType" : "table",
          "downloadCount" : 2851,
          "iconUrl" : "fileId:r41tDc239M1FL75LFwXFKzFCWqr8mzMeMTYXiA24USM",
          "indexUpdatedAt" : 1455885508,
          "newBackend" : false,
          "numberOfComments" : 0,
          "oid" : 8890705,
          "publicationAppendEnabled" : false,
          "publicationDate" : 1411040702,
          "publicationGroup" : 1620779,
          "publicationStage" : "published",
          "rowClass" : "",
          "rowsUpdatedAt" : 1455876727,
          "rowsUpdatedBy" : "ajn4-zy65",
          "state" : "normal",
          "tableId" : 1722160,
          "totalTimesRated" : 0,
          "viewCount" : 6910,
          "viewLastModified" : 1434558076,
          "viewType" : "tabular",
          "columns" : [ {
          "disabledFeatureFlags" : [ "allow_comments" ],
          "grants" : [ {
          "metadata" : {
          "owner" : {
          "query" : {
          "rights" : [ "read" ],
          "sortBys" : [ {
          "tableAuthor" : {
          "tags" : [ "traffic", "stop", "violations", "electronic issued." ],
          "flags" : [ "default" ]
      "data" : [ [ 1889194, "92AD0076-5308-45D0-BDE3-6A3A55AD9A04", 1889194, 1455876689, "498050", 1455876689, "498050", null, "2016-02-18T00:00:00", "09:05:00", "MCP", "2nd district, Bethesda", "DRIVER USING HANDS TO USE HANDHELD TELEPHONE WHILEMOTOR VEHICLE IS IN MOTION", "355/TUCKERMAN LN", "-77.105925", "39.03223", "No", "No", "No", "No", "No", "No", "No", "No", "No", "No", "MD", "02 - Automobile", "2010", "JEEP", "CRISWELL", "BLUE", "Citation", "21-1124.2(d2)", "Transportation Article", "No", "WHITE", "F", "GERMANTOWN", "MD", "MD", "A - Marked Patrol", [ "{\"address\":\"\",\"city\":\"\",\"state\":\"\",\"zip\":\"\"}", "-77.105925", "39.03223", null, false ] ]
    这展示了md_traffic.json中的全键结构,并告诉我们JSON文件的哪些部分是与我们相关的。在这种情况下,columns键看起来有趣,因为它有可能包含data键中的列表的列表中的列的信息。

    提取列信息
    现在,我们知道了哪个键包含关于列的信息,接着我们需要读入该信息。由于假设JSON文件无法全部读入内存,因此不能直接使用json库将其读入。相反,我们将要以一种内存高效的方式迭代读入。

    我们可以使用ijson包来实现。ijson会迭代的解析JSON文件,而不是一次性将它们全部读入。这比直接读入整个文件慢,但它使得我们可以处理那些无法完全读入内存的大文件。要使用ijson,我们要指定一个想要从中提取数据的文件,然后指定一个键路径来提取:

    In [7]:
    import ijson

    filename = "md_traffic.json"
    with open(filename, 'r') as f:
        objects = ijson.items(f, 'meta.view.columns.item')
        columns = list(objects)
    在上面的代码中,我们打开了md_traffic.json文件,然后使用ijson中的items方法来从该文件中提取一个列表。我们使用meta.view.columns符号指定列表路径。回想一下,meta是一个顶级键,它包含view,而view又包含columns。然后,指定meta.view.columns.item来表明我们应该提取meta.view.columns列表中的每一个单独的项。items函数将返回一个生成器,所以使用list方法来将该生成器转换成Python列表。我们可以打印出该列表中的第一个项:

    In [36]:
    print(columns[0])
    {'renderTypeName': 'meta_data', 'name': 'sid', 'fieldName': ':sid', 'position': 0, 'id': -1, 'format': {}, 'dataTypeName': 'meta_data'}
    根据上面的输出,似乎columns中的每一个项都是一个包含每一个列信息的字典。要获取头部,看起来fieldName就是要提取的相关键。要获取列名,只需从columns中的每一个项提取fieldName即可:

    In [33]:
    column_names = [col["fieldName"] for col in columns]
    column_names
    Out[33]:
    [':sid',
     ':id',
     ':position',
     ':created_at',
     ':created_meta',
     ':updated_at',
     ':updated_meta',
     ':meta',
     'date_of_stop',
     'time_of_stop',
     'agency',
     'subagency',
     'description',
     'location',
     'latitude',
     'longitude',
     'accident',
     'belts',
     'personal_injury',
     'property_damage',
     'fatal',
     'commercial_license',
     'hazmat',
     'commercial_vehicle',
     'alcohol',
     'work_zone',
     'state',
     'vehicle_type',
     'year',
     'make',
     'model',
     'color',
     'violation_type',
     'charge',
     'article',
     'contributed_to_accident',
     'race',
     'gender',
     'driver_city',
     'driver_state',
     'dl_state',
     'arrest_type',
     'geolocation']
    好极了!现在,我们具备了列名,可以接着提取数据了。

    提取数据
    你可能还记得,数据被藏在data键的一个列表的列表中。我们需要将该数据读取到内存中以便操纵它。幸运的是,我们可以使用刚刚提取的列名来只抓取相关的列。这将节省大量空间。如果数据集更大,那么可以迭代的处理这些行。所以读取第一个10000000行,进行一些处理,然后下一个10000000行,等等。在这种情况下,我们可以定义关心的列,然后再次使用ijson来迭代地处理该JSON文件:

    In [9]:
    good_columns = [
        "date_of_stop", 
        "time_of_stop", 
        "agency", 
        "subagency",
        "description",
        "location", 
        "latitude", 
        "longitude", 
        "vehicle_type", 
        "year", 
        "make", 
        "model", 
        "color", 
        "violation_type",
        "race", 
        "gender", 
        "driver_state", 
        "driver_city", 
        "dl_state",
        "arrest_type"
    ]

    data = []
    with open(filename, 'r') as f:
        objects = ijson.items(f, 'data.item')
        for row in objects:
            selected_row = []
            for item in good_columns:
                selected_row.append(row[column_names.index(item)])
            data.append(selected_row)
            In [9]:
    good_columns = [
        "date_of_stop", 
        "time_of_stop", 
        "agency", 
        "subagency",
        "description",
        "location", 
        "latitude", 
        "longitude", 
        "vehicle_type", 
        "year", 
        "make", 
        "model", 
        "color", 
        "violation_type",
        "race", 
        "gender", 
        "driver_state", 
        "driver_city", 
        "dl_state",
        "arrest_type"
    ]

    data = []
    with open(filename, 'r') as f:
        objects = ijson.items(f, 'data.item')
        for row in objects:
            selected_row = []
            for item in good_columns:
                selected_row.append(row[column_names.index(item)])
            data.append(selected_row)
    现在,我们已经读取了数据,可以打印出data中第一项了:

    In [10]:
    data[0]
    Out[10]:
    ['2016-02-18T00:00:00',
     '09:05:00',
     'MCP',
     '2nd district, Bethesda',
     'DRIVER USING HANDS TO USE HANDHELD TELEPHONE WHILEMOTOR VEHICLE IS IN MOTION',
     '355/TUCKERMAN LN',
     '-77.105925',
     '39.03223',
     '02 - Automobile',
     '2010',
     'JEEP',
     'CRISWELL',
     'BLUE',
     'Citation',
     'WHITE',
     'F',
     'MD',
     'GERMANTOWN',
     'MD',
     'A - Marked Patrol']
    将数据读到Pandas中
    现在,我们有了一个作为列表的数据列表,及一个列头部列表,我们可以创建一个Pandas Dataframe来分析这些数据了。如果你不熟悉Pandas,其实它就是一个数据分析库,使用了一种名为Dataframe的高效的,表格式的数据结构来展示数据。Pandas允许你将一个列表的列表转换为一个Dataframe,并且分别指定列名。

    In [11]:
    import pandas as pd

    stops = pd.DataFrame(data, columns=good_columns)
    现在,我们有了一个存储在Dataframe的数据,可以进行一些有趣的分析了。下面是一个表格,表示了按照汽车颜色分类,有多少管制:

    In [12]:
    stops["color"].value_counts()
    Out[12]:
    BLACK          161319
    SILVER         150650
    WHITE          122887
    GRAY            86322
    RED             66282
    BLUE            61867
    GREEN           35802
    GOLD            27808
    TAN             18869
    BLUE, DARK      17397
    MAROON          15134
    BLUE, LIGHT     11600
    BEIGE           10522
    GREEN, DK       10354
    N/A              9594
    GREEN, LGT       5214
    BROWN            4041
    YELLOW           3215
    ORANGE           2967
    BRONZE           1977
    PURPLE           1725
    MULTICOLOR        723
    CREAM             608
    COPPER            269
    PINK              137
    CHROME             21
    CAMOUFLAGE         17
    dtype: int64
    伪彩似乎是一种非常受欢迎的汽车颜色。下面是一个表格,表示什么样的警卫队创建了罚单:

    In [13]:
    stops["arrest_type"].value_counts()
    Out[13]:
    A - Marked Patrol                         671165
    Q - Marked Laser                           87929
    B - Unmarked Patrol                        25478
    S - License Plate Recognition              11452
    O - Foot Patrol                             9604
    L - Motorcycle                              8559
    E - Marked Stationary Radar                 4854
    R - Unmarked Laser                          4331
    G - Marked Moving Radar (Stationary)        2164
    M - Marked (Off-Duty)                       1301
    I - Marked Moving Radar (Moving)             842
    F - Unmarked Stationary Radar                420
    C - Marked VASCAR                            323
    D - Unmarked VASCAR                          210
    P - Mounted Patrol                           171
    N - Unmarked (Off-Duty)                      116
    H - Unmarked Moving Radar (Stationary)        72
    K - Aircraft Assist                           41
    J - Unmarked Moving Radar (Moving)            35
    dtype: int64
    随着冲红灯摄影机和高速激光器的崛起,有趣的是巡逻车目前为止仍是罚单的主要来源。

    转换列
    现在,我们几乎准备好进行一些基于时间和地点的分析了,但是需要先将longitude, latitude, 和date列从字符串转换成浮点。可以使用下面的代码来转换latitude和longitude:

    In [40]:
    import numpy as np

    def parse_float(x):
        try:
            x = float(x)
        except Exception:
            x = 0
        return x
    stops["longitude"] = stops["longitude"].apply(parse_float)
    stops["latitude"] = stops["latitude"].apply(parse_float)
    奇怪的是,管制当天的时间以及管制日期分别存储在两个单独的列,time_of_stop和date_of_stop中。我们要解析这两个列,并将它们转换成一个单一的日期列:

    In [42]:
    import datetime
    def parse_full_date(row):
        date = datetime.datetime.strptime(row["date_of_stop"], "%Y-%m-%dT%H:%M:%S")
        time = row["time_of_stop"].split(":")
        date = date.replace(hour=int(time[0]), minute = int(time[1]), second = int(time[2]))
        return date

    stops["date"] = stops.apply(parse_full_date, axis=1)
    现在,我们可以绘制一张表示哪些天有最多交通管制:

    In [50]:
    import matplotlib.pyplot as plt
    %matplotlib inline 

    plt.hist(stops["date"].dt.weekday, bins=6)
    Out[50]:
    (array([ 112816.,  142048.,  133363.,  127629.,  131735.,  181476.]),
     array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.]),
     <a list of 6 Patch objects>)
     

    在这张图中,星期一是0,而星期天是6。看起来,星期天有最多的管制,而星期一则最少。这也可能是数据质量问题,即出于某种原因,星期天出现了无效日期。你必须更深入挖掘date_of_stop列,以明确找出原因(这超出了本文的范围)。

    我们也可以绘制出最常见的交通管制时间:

    In [51]:
    plt.hist(stops["date"].dt.hour, bins=24)
    Out[51]:
    (array([ 44125.,  35866.,  27274.,  18048.,  11271.,   7796.,  11959.,
             29853.,  46306.,  42799.,  43775.,  37101.,  34424.,  34493.,
             36006.,  29634.,  39024.,  40988.,  32511.,  28715.,  31983.,
             43957.,  60734.,  60425.]),
     array([  0.        ,   0.95833333,   1.91666667,   2.875     ,
              3.83333333,   4.79166667,   5.75      ,   6.70833333,
              7.66666667,   8.625     ,   9.58333333,  10.54166667,
             11.5       ,  12.45833333,  13.41666667,  14.375     ,
             15.33333333,  16.29166667,  17.25      ,  18.20833333,
             19.16666667,  20.125     ,  21.08333333,  22.04166667,  23.        ]),
     <a list of 24 Patch objects>)
     

    看起来管制最常发生在午夜,而最少发生在凌晨5点左右。这可能是有意义的,因为人们可能深夜从酒吧和晚餐开车回家,并且可能受伤。这也可能是一个数据质量问题,而为了能得到一个完整的答案,则必须通过time_of_stop列。

    构造管制子集
    我们已经转换了地点和日期列,可以绘制出交通管制了。由于绘图是CPU资源和内存非常密集的,所以需要先过滤stops中使用的行:

    In [43]:
    last_year = stops[stops["date"] > datetime.datetime(year=2015, month=2, day=18)]
    在上面的代码中,我们选择了所有日期在过去一年中的行。可以进一步缩小它,只选择那些在高峰时段出现的行 —— 当每个人都去上班的早晨时段:

    In [44]:
    morning_rush = last_year[(last_year["date"].dt.weekday < 5) & (last_year["date"].dt.hour > 5) & (last_year["date"].dt.hour < 10)]
    print(morning_rush.shape)
    last_year.shape
    (29824, 21)
    Out[44]:
    (234582, 21)
    使用优秀的folium包,现在可以可视化所有的管制在哪里发生。folium允许你轻松的通过利用leaflet来创建Python中交互式地图。为了保持性能,我们将只可视化morning_rush的前1000行:

    In [45]:
    import folium
    from folium import plugins

    stops_map = folium.Map(location=[39.0836, -77.1483], zoom_start=11)
    marker_cluster = folium.MarkerCluster().add_to(stops_map)
    for name, row in morning_rush.iloc[:1000].iterrows():
        folium.Marker([row["longitude"], row["latitude"]], popup=row["description"]).add_to(marker_cluster)
    stops_map.create_map('stops.html')
    stops_map
    Out[45]:
    (注:结果图是<iframe>格式,不知道怎么放上来。想看结果图的请到原文去看哈。多有不便,烦请原谅~~)

    这表明,许多交通管制都集中在该郡的右下角。我们可以使用一个热度进一步分析:

    In [46]:
    stops_heatmap  =  folium . Map ( location = [ 39.0836 ,  - 77.1483 ],  zoom_start = 11 ) 
    stops_heatmap . add_children ( plugins . HeatMap ([[ row [ "longitude" ],  row [ "latitude" ]]  for  name ,  row  in  morning_rush . iloc [: 1000 ] . iterrows ()])) 
    stops_heatmap . save ( "heatmap.html" ) 
    stops_heatmap
    想获取python学习资料的小伙伴可以加QQ:606115027
     

    展开全文
  • 文章目录目录1.分配更多的内存2.使用较小的样本3.将数据提交至服务器上4.更改数据格式5....因此,如何解决大数据读入问题是解决大数据机器学习的第一步。 1.分配更多的内存 如果硬件可以支持分配更多...
  • 如果你从事大数据工作,用Python的Pandas库时会发现很多惊喜。Pandas在数据科学和分析领域扮演越来越重要的角色,尤其是对于从Excel和VBA转向Python的用户。 所以,对于数据科学家,数据分析师,数据工程师,Pandas...
  • Pandas是Python中用于数据处理与分析的屠龙刀,想必大家也都不陌生,但Pandas在使用上有一些技巧和需要注意的地方,尤其是对于较大的数据集而言,如果你没有适当地使用,那么可能会导致Pandas的运行速度非常慢。...
  • 如果你从事大数据工作,用Python的Pandas库时会发现很多惊喜。Pandas在数据科学和分析领域扮演越来越重要的角色,尤其是对于从Excel和VBA转向Python的用户。所以,对于数据科学家,数据分析师,数据工程师,Pandas是...
  • python从mysql 数据库1迁移到数据库2(中间转化为...mysql 写入数据存在两种形式,create_engine速度快些 ,但批量数据时需要批次写入数据某则报错 #!/usr/bin/env python # -*- encoding: utf-8 -*- "...
  • 如果你从事大数据工作,用Python的Pandas库时会发现很多惊喜。Pandas在数据科学和分析领域扮演越来越重要的角色,尤其是对于从Excel和VBA转向Python的用户。 所以,对于数据科学家,数据分析师,数据工程师,Pandas...
  • python之数据文件批量清洗,入库 因为最近有一个数据接入清洗的项目,别的工具用起来有些觉得不太顺手,就学着写了一个数据清洗入库的通用模板,节省一些工作量。主要流程为:数据库连接---文件批量导入----文件批量...
  • 网上从文件中读取样本和标签的资料很多,但大多讲的不全面,或只讲原理,或只有变为.tfrecords部分,或没有调用的栗子。寄几and男票一起捣鼓了两天,终于有了目前这个完整版的代码,希望对看到的朋友有所帮助。...
  • 1.1 大数据部分的课程介绍 6 1.2 学习建议 6 1.3 就业前景及发展规划 6 1.4 HADOOP 简介 7 1.4.1 前言 7 1.4.2 hadoop 应用场景 7 1.5 hadoop 集群部署安装 7 2. HDFS 9 2.1 hdfs 的shell 操作 10 2.2 HDFS...
  • 以前批处理生成数据文件都是通过c程序直接按照逗号分隔方式写文本文件以csv保存的。但是由于有些处理的数据表直接给业务人员看,业务人员习惯使用xls,因此提了些需求改造,对于一些小于100w的数据均要求改为xlsx...
  • Python实现日报自动化

    2020-04-09 20:18:20
    最近负责公司某项目的日报,需要把五个CSV文件合并...首先要处理CSV文件和EXCEL文件的读取写入,调用pandas库。我总结了一下,使用pandas库修改CSV和EXCEL文件的套路 1. pandas库处理CSV和EXCEL文件的套路 import p...
  • 我们在做大数据测试分析的时候,经常需要用到excel 统计分析数据,以下例子就是 python 调用xlwt 写excel 文件: import sys import random import time import xlwt import codecs def Txt_to_Excel(ws,...
  • 使用python将大量数据导出到Excel中的小技巧分享今天小编就为大家分享一篇使用python将大量数据导出到Excel中的小技巧心得,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧(1) 问题描述:为了更...
  • Python 资源大全中文版

    2018-07-24 16:55:23
    环境管理 管理 Python 版本和环境的工具 p:非常简单的交互式 python 版本管理工具。官网 pyenv:简单的 Python 版本管理工具。官网 Vex:可以在虚拟环境中执行命令。... virtualenv:创建独立 Python 环境的工具...
  • **前言:**对前面的代码功能进行一次简要整合,简要添加了多线程功能: 1.tushare股票数据本地csv格式。 2.csv格式文件mysql化。...import pandas as pd import tushare as ts import threading import dateu
1 2 3
收藏数 52
精华内容 20