python的pandas库基础

素颜马尾好姑娘i 2023-07-19 12:08 50阅读 0赞

@TOC

# python的pandas库在数据分析中常用的函数及其功能(持续更新中) #

### 导入pandas库 ###

import pandas as pd

### 数据的读取 ###

###### pandas中提供了七种常用的读取数据的方式： ######

*  读取CSV文档：

pd.read_csv(filename, headers=None)

###### 注意此处的headers参数，在导入CSV文件时，pandas默认文件的第一行为列名称，不是数据，会将第一行当做列名称来处理，因此需要将headers参数设置为None。 ######

*  读取Excel文档：

pd.read_excel(fielname)

*  读取sql：

pd.read_sql(query,connection_object)

*  读取json格式的字符串，url或文件

pd.read_json(json_string)

*  解析HTML，字符串或文件，并将表提取到数据框列表

pd.read_html(url)

*  获取剪切板的内容并将其传给read\_table()

pd.read_clipboard()

### pandas中的数据结构 ###

<table> 
 <thead> 
  <tr> 
   <th>数据结构</th> 
   <th>维数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Series</td> 
   <td>1</td> 
   <td>序列/系列；一维数组</td> 
  </tr> 
  <tr> 
   <td>DataFrame</td> 
   <td>2</td> 
   <td>数据框/表格；二维数组</td> 
  </tr> 
  <tr> 
   <td>Pannel</td> 
   <td>3</td> 
   <td>面板；三维数组</td> 
  </tr> 
 </tbody> 
</table>

### 数据框数据的索引与切片 ###

###### 接下来用几个例子来具体演示这几个方法的用法 ######

首先导入pandas包，并赋予一个缩写的名称

import pandas as pd

接着，我们导入一个CSV文档

dataSet = pd.read_csv("iris.data")

此处的iris.data为一个有关鸢尾花的数据集，接着显示导入的内容，看看里面都有些什么

print(dataSet)

0    1    2    3               4
    0    5.1  3.5  1.4  0.2     Iris-setosa
    1    4.9  3.0  1.4  0.2     Iris-setosa
    2    4.7  3.2  1.3  0.2     Iris-setosa
    3    4.6  3.1  1.5  0.2     Iris-setosa
    4    5.0  3.6  1.4  0.2     Iris-setosa
    5    5.4  3.9  1.7  0.4     Iris-setosa
    6    4.6  3.4  1.4  0.3     Iris-setosa
    7    5.0  3.4  1.5  0.2     Iris-setosa
    8    4.4  2.9  1.4  0.2     Iris-setosa
    9    4.9  3.1  1.5  0.1     Iris-setosa
    10   5.4  3.7  1.5  0.2     Iris-setosa
    11   4.8  3.4  1.6  0.2     Iris-setosa
    12   4.8  3.0  1.4  0.1     Iris-setosa
    13   4.3  3.0  1.1  0.1     Iris-setosa
    14   5.8  4.0  1.2  0.2     Iris-setosa
    ..   ...  ...  ...  ...             ...

这会儿我们会发现内容好多呀，我们只是想看一下里面内容的格式什么的，只需要看里面的几行数据，不需要看这么多，那我们该怎么设置呢？

print(dataSet.head(5))

这里的.head()函数的意思是只显示内容的前五行数据

0    1    2    3            4
    0  5.1  3.5  1.4  0.2  Iris-setosa
    1  4.9  3.0  1.4  0.2  Iris-setosa
    2  4.7  3.2  1.3  0.2  Iris-setosa
    3  4.6  3.1  1.5  0.2  Iris-setosa
    4  5.0  3.6  1.4  0.2  Iris-setosa

同样的，既然可以显示前五行，那么一定就可以显示后五行喽

print(dataSet.tail(5))

0    1    2    3               4
    145  6.7  3.0  5.2  2.3  Iris-virginica
    146  6.3  2.5  5.0  1.9  Iris-virginica
    147  6.5  3.0  5.2  2.0  Iris-virginica
    148  6.2  3.4  5.4  2.3  Iris-virginica
    149  5.9  3.0  5.1  1.8  Iris-virginica

从行名称(就是最左边那一列数字)可以看出，这里显示的是最后五行的数据。  
从一个对于这个数据集的介绍里，我们可以了解到，这些数据的第二列到第六列(此处把最左边的145-149看做第一列)表示鸢尾花花萼的长度，花萼的宽度，花瓣的长度，花瓣的宽度以及花的种类，我们如何在数据集中显示每一列对应的属性名称呢？

###### 在这里我们需要注意一下，之前我们导入数据的时候，pandas库是会自动给我们的数据添上列标签和行标签的，不过是用一连串的数字来表示的，因此，我们现在要做的，就是重新定义这些标签，也就是将原来导入数据的dataSet中的内容，剔除行标签与列标签，只取出数值部分的内容，然后给数值的部分的内容添加行标签与列标签，因此，我们首先要做的就是取出dataSet中的数值内容，可以用如下三种方式： ######

import numpy as np
    dataSet1 = np.array(dataSet)
    dataSet2 = dataSet.values
    dataSet3 = dataSet.as_matrix()

结果如下：

print(dataSet1)
    print(dataSet2)
    print(dataSet3)
    >>>
    [[5.1 3.5 1.4 0.2 'Iris-setosa']
     [4.9 3.0 1.4 0.2 'Iris-setosa']
     [4.7 3.2 1.3 0.2 'Iris-setosa']
     [4.6 3.1 1.5 0.2 'Iris-setosa']
     [5.0 3.6 1.4 0.2 'Iris-setosa']
     [5.4 3.9 1.7 0.4 'Iris-setosa']
     [4.6 3.4 1.4 0.3 'Iris-setosa']
     [5.0 3.4 1.5 0.2 'Iris-setosa']
     [4.4 2.9 1.4 0.2 'Iris-setosa']

此处需要用到numpy库，关于这个库的使用，以后再讲(码到这里，才意识到应该先讲numpy的>.<)。  
在print显示数据的时候，python提醒我：\*\*FutureWarning: Method .as\_matrix will be removed in a future version. Use .values instead.\*\*原因是as\_matrix()命令以后会被移除，所以大家最好用其他两个命令吧。  
刚刚进行了一个小拓展，接下来我们接着干正事：

dataSet = pd.DataFrame(np.array(dataSet), columns=['sl', 'sw', 'pl', 'pw', 'types'], index=range(150))

此处需要用到dataFrame命令，columns参数后面的内容是列标签的内容，index参数后面的内容是行标签的内容，行标签需要注意，如果用的是range函数的话，那么行标签是从0开始的哦。  
结果显示如下：

print(dataSet.head(5))
    
    >>>
       sl   sw   pl   pw        types
    0  5.1  3.5  1.4  0.2  Iris-setosa
    1  4.9    3  1.4  0.2  Iris-setosa
    2  4.7  3.2  1.3  0.2  Iris-setosa
    3  4.6  3.1  1.5  0.2  Iris-setosa
    4    5  3.6  1.4  0.2  Iris-setosa

这样，我们就给数据添加行行列标签了。

刚刚添加行列标签的操作，不仅仅方便我们在查看数据时能够明确知道每一条数据代表了什么特征，而且也方便了我们对数据进行索引。  
如果我们想要取出某一个特征对应的数据，可以这样做：

print(dataSet[['pw']])
    
    >>>
          pw
    0    0.2
    1    0.2
    2    0.2
    3    0.2
    4    0.2
    5    0.4
    6    0.3
    7    0.2
    8    0.2
    9    0.1
    10   0.2

如果想要取出两列指定数据，可以这样：

print(dataSet[['pw', 'sl']])
    
    >>>
          pw   sl
    0    0.2  5.1
    1    0.2  4.9
    2    0.2  4.7
    3    0.2  4.6
    4    0.2    5
    5    0.4  5.4
    6    0.3  4.6
    7    0.2    5
    8    0.2  4.4

再取出多列数据的时候，一定要注意是两个方括号里面写入列标签哈。  
我们也可以直接输入列的索引值来查看列的数据：

print(dataSet.iloc[:,0])
    
    >>>
    0      5.1
    1      4.9
    2      4.7
    3      4.6
    4        5
    5      5.4
    6      4.6
    7        5

**注意：这里的列的索引值，不包括行标签那一列**  
前面提到的ix命令，也可以实现这样的操作，这里就不进行演示了。

上面讲过了关于列的内容的索引，如何对行进行索引呢？

print(dataSet.loc[0:3])
    
    >>>
     sl   sw   pl   pw        types
    0  5.1  3.5  1.4  0.2  Iris-setosa
    1  4.9    3  1.4  0.2  Iris-setosa
    2  4.7  3.2  1.3  0.2  Iris-setosa
    3  4.6  3.1  1.5  0.2  Iris-setosa

ix，iloc的用法跟loc一样，这里就不演示了。  
当我们需要将某个数据集里的某几个样本抽取出来时，就可以这样来操作。

### pandas描述性统计 ###

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>df.count()</td> 
   <td>非空观测数量</td> 
  </tr> 
  <tr> 
   <td>df.sum()</td> 
   <td>所有值的和</td> 
  </tr> 
  <tr> 
   <td>df.mean()</td> 
   <td>所有值的平均值</td> 
  </tr> 
  <tr> 
   <td>df.median()</td> 
   <td>所有值的中位数</td> 
  </tr> 
  <tr> 
   <td>df.mode()</td> 
   <td>值的模值</td> 
  </tr> 
  <tr> 
   <td>df.std()</td> 
   <td>值的标准差</td> 
  </tr> 
  <tr> 
   <td>df.min()</td> 
   <td>所有值中的最小值</td> 
  </tr> 
  <tr> 
   <td>df.max()</td> 
   <td>所有值中的最大值</td> 
  </tr> 
  <tr> 
   <td>df.abs()</td> 
   <td>绝对值</td> 
  </tr> 
  <tr> 
   <td>df.prod()</td> 
   <td>数组元素的乘积</td> 
  </tr> 
  <tr> 
   <td>df.cunsum()</td> 
   <td>累计总和</td> 
  </tr> 
  <tr> 
   <td>df.cunprod()</td> 
   <td>累积乘积</td> 
  </tr> 
  <tr> 
   <td>df.describe()</td> 
   <td>得到数据框df每一列的描述性统计</td> 
  </tr> 
  <tr> 
   <td>df.corr()</td> 
   <td>得到数据框df中每一列与其他列的相关系数</td> 
  </tr> 
 </tbody> 
</table>

这里的函数有点多，接下来我一一为大家演示一下用法。  
我们重新读取一个CSV文件，内容显示如下：

df = pd.read_csv("test.names", header=None)
    print(df)
    
    >>>
        0   1   2   3   4
    0   1   2   3   4   5
    1   6   7   8   9  10
    2  11      12  13  14
    3  16  17      18  19

可以看到该数据里是由缺失数据的。

print(df.count(axis=0))
    >>>
    0    4
    1    3
    2    3
    3    4
    4    4

这里的参数axis默认为0，为零时表示对每一列进行检测，统计非零元素个数，为1时，表示对每一行进行检测，统计非零元素个数。

print(df.sum(axis=0))
    
    >>>
    0    15.0
    1    40.0
    2    50.0
    3    70.0

这里的参数axis默认为0，为零时表示对每一列进行求和，为1时，表示对每一行进行求和。

print(df.mean(axis=0))
    
    >>>
    0     8.500000
    1     8.666667
    2     7.666667
    3    11.000000
    4    12.000000

这里的参数axis默认为0，为零时表示对每一列进行求均值，为1时，表示对每一行进行求均值。

print(df.median(axis=0))
    
    >>>
    0     8.5
    1     7.0
    2     8.0
    3    11.0
    4    12.0

这里的参数axis默认为0，为零时表示对每一列进行求中位数，为1时，表示对每一行进行求中位数。

print(df.mode())
    
    >>>
       0     1     2   3   4
    0   1   2.0   3.0   4   5
    1   6   7.0   8.0   9  10
    2  11  17.0  12.0  13  14
    3  16   NaN   NaN  18  19

对df中的所有元素求模值。

print(df.std(axis=1))
    
    >>>
    0    1.581139
    1    1.581139
    2    1.290994
    3    1.290994

这里的参数axis默认为0，为零时表示对每一列进行求标准差，为1时，表示对每一行进行求标准差。

print(df.min(axis=1))
    
    >>>
    0     1.0
    1     6.0
    2    11.0
    3    16.0

这里的参数axis默认为0，为零时表示对每一列进行求最小值，为1时，表示对每一行进行求最小值。  
max()函数用法同min函数。

print(df.abs())
    
    >>>
     0     1     2     3     4
    0   1.0   2.0   3.0   4.0   5.0
    1   6.0   7.0   8.0   9.0  10.0
    2  11.0   NaN  12.0  13.0  14.0
    3  16.0  17.0   NaN  18.0  19.0

对df中的所有元素求绝对值。

print(df.prod(axis=1))
    
    >>>
    0      120.0
    1    30240.0
    2    24024.0
    3    93024.0

这里的参数axis默认为0，为零时表示对每一列进行求元素的乘积，为1时，表示对每一行进行求元素的乘积。

print(df.cumsum(axis=1))
    
    >>>
     0     1     2     3     4
    0   1.0   3.0   6.0  10.0  15.0
    1   6.0  13.0  21.0  30.0  40.0
    2  11.0   NaN  23.0  36.0  50.0
    3  16.0  33.0   NaN  51.0  70.0

这里的参数axis默认为0，为零时表示对每一列求元素的累计总和，为1时，表示对每一行球元素的累计总和。

print(df.cumprod(axis=1))
    
    >>>
     0      1      2       3        4
    0   1.0    2.0    6.0    24.0    120.0
    1   6.0   42.0  336.0  3024.0  30240.0
    2  11.0    NaN  132.0  1716.0  24024.0
    3  16.0  272.0    NaN  4896.0  93024.0

这里的参数axis默认为0，为零时表示对每一列求元素的累计乘积，为1时，表示对每一行球元素的累计乘积。

print(df.describe())
    
    >>>
              0          1          2          3          4
    count   4.000000   3.000000   3.000000   4.000000   4.000000
    mean    8.500000   8.666667   7.666667  11.000000  12.000000
    std     6.454972   7.637626   4.509250   5.944185   5.944185
    min     1.000000   2.000000   3.000000   4.000000   5.000000
    25%     4.750000   4.500000   5.500000   7.750000   8.750000
    50%     8.500000   7.000000   8.000000  11.000000  12.000000
    75%    12.250000  12.000000  10.000000  14.250000  15.250000
    max    16.000000  17.000000  12.000000  18.000000  19.000000

得到数据框df每一列的描述性统计。

print(df.corr())
    
    >>>
    0         1         2         3         4
    0  1.000000  1.000000  0.997949  0.999056  0.999056
    1  1.000000  1.000000  1.000000  0.999645  0.999645
    2  0.997949  1.000000  1.000000  1.000000  1.000000
    3  0.999056  0.999645  1.000000  1.000000  1.000000
    4  0.999056  0.999645  1.000000  1.000000  1.000000

得到数据框df中每一列与其他列的相关系数

### 数据的清洗 ###

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>pd.dropna</td> 
   <td>判断空值函数</td> 
  </tr> 
  <tr> 
   <td>pd.fillna</td> 
   <td>填充空值数据</td> 
  </tr> 
  <tr> 
   <td>pd.isnull()</td> 
   <td>检查数据中空值出现的情况，并返回一个由布尔值(True,Fale)组成的列</td> 
  </tr> 
  <tr> 
   <td>pd.notnull()</td> 
   <td>检查数据中非空值出现的情况，并返回一个由布尔值(True,False)组成的列</td> 
  </tr> 
  <tr> 
   <td>s.astype(float)</td> 
   <td>将数组(Series)的格式转化为浮点数</td> 
  </tr> 
  <tr> 
   <td>s.replace(1,‘one’)</td> 
   <td>将数组(Series)中的所有1替换为’one’</td> 
  </tr> 
  <tr> 
   <td>s.replace([1,3],[‘one’,‘three’])</td> 
   <td>将数组(Series)中所有的1替换为’one’, 所有的3替换为’three’</td> 
  </tr> 
  <tr> 
   <td>df.rename(columns=lambda x: x + 2)</td> 
   <td>将全体列重命名</td> 
  </tr> 
  <tr> 
   <td>df.rename(columns={‘old_name’: ‘new_ name’})</td> 
   <td>将选择的列重命名</td> 
  </tr> 
  <tr> 
   <td>df.rename(index = lambda x: x+ 1)</td> 
   <td>改变全体索引</td> 
  </tr> 
  <tr> 
   <td>df.set_index(‘column_one’)</td> 
   <td>改变索引 ，指定某一列的值当整个DataFrame的索引</td> 
  </tr> 
 </tbody> 
</table>

实例：  
此处，我们依然使用上一节例子中使用的数据集。

print(df.dropna(axis=0, how='any', thresh=None))
    
    >>>
      0    1    2  3   4
    0  1  2.0  3.0  4   5
    1  6  7.0  8.0  9  10

该函数用来删除带有空值的行或列。其中，参数axis=1时，删去列，axis=0时删去行；how等于any时，表示该行或列只要有一个空值，就删去，how等于all时表示，该行或列的元素全为空时，才会删去；thresh参数表示这一行或列出现多少个空值才会删去。

print(df.fillna(df.mean(axis=1)))
    
    >>>
     0     1     2   3   4
    0   1   2.0   3.0   4   5
    1   6   7.0   8.0   9  10
    2  11   8.0  12.0  13  14
    3  16  17.0  12.5  18  19

该语句的意思是使用df每一行的平均值去填充每一行中的缺失值。

print(df.fillna(method='backfill'))
    
    >>>
     0     1     2   3   4
    0   1   2.0   3.0   4   5
    1   6   7.0   8.0   9  10
    2  11  17.0  12.0  13  14
    3  16  17.0   NaN  18  19

此处，method为可选参数，可以选择填充的方式，可取值为\{‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None\}, 默认值 None ; 其中，‘backfill’, ‘bfill’为用空值的下一个非空值来填充空值，，‘pad’, ‘ffill’为用空值的前一个非空值来填充空值。  
该函数还有参数：inplace，默认为false，若为true，则在原数据集的基础上进行填充，为false则另生成一个数据集；limit，限制填充的空值的个数。

print(df.isnull())
    >>>
    0      1      2      3      4
    0  False  False  False  False  False
    1  False  False  False  False  False
    2  False   True  False  False  False
    3  False  False   True  False  False

该函数返回一个矩阵，在对应为空值的地方显示true，其他位置显示false。  
notnull()函数与isnull()函数用法相似。

print(df.astype('float'))
    
    >>>
      0     1     2     3     4
    0   1.0   2.0   3.0   4.0   5.0
    1   6.0   7.0   8.0   9.0  10.0
    2  11.0   NaN  12.0  13.0  14.0
    3  16.0  17.0   NaN  18.0  19.0

改变df中每个元素的类型，比如int,float等。

print(df.replace(1.0, 'one'))
    
    >>>
     0     1     2   3   4
    0  one   2.0   3.0   4   5
    1    6   7.0   8.0   9  10
    2   11   NaN  12.0  13  14
    3   16  17.0   NaN  18  19

将df中的元素1.0替换为one。

**再添加一些不常用的命令：**  
最近在学机器学习的时候，有个数据处理过程叫“分箱”，也就是将离散的数据分到对应的数据区间中去，可以有效减少异常值对数据分析的影响。主要用得到的是cut函数和qcut函数。  
下面一例子来说明这两个函数的用法：

# 假设某项研究中一组人群的数据，想将他们进行分组。放入离散的年龄框中
    ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
    # 如果按年龄分成18-25，26-35,36-60,61以上的若干组，可以使用pandas中的cut
    bins = [18, 25, 35, 60, 100]  # 定义箱子的边

这里，ages是要用来分箱的离散变量，而bins是不同的区间的边界，如 ( 18 , 25 ) , ( 25 , 35 ) , ( 35 , 60 ) , ( 60 , 100 ) (18,25), (25,35), (35,60), (60,100) (18,25),(25,35),(35,60),(60,100)。这些区间的开闭集由参数指定，接下来，我们把ages中的离散值分配到这些区间里去。

cats = pd.cut(ages, bins)
    print('cats:',cats)  # 这是个categories对象，通过bin分成了四个区间，然后返回每个年龄属于哪个区间

输出结果：

cats: [(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (25, 35], (60, 100], (35, 60], (35, 60], (25, 35]]
    Length: 12
    Categories (4, interval[int64]): [(18, 25] < (25, 35] < (35, 60] < (60, 100]]

首先可以看到返回了一个列表，这个列表将ages里的各个元素换成了对应的区间，也就是改元素在bins里面的哪个区间里，就换成哪个区间；后面的length=12，很明显说的是元素的个数。

print('cats.codes:',cats.codes)  # 这里返回一个数组，指明每一个年龄属于哪个区间
    print('cats.categories:',cats.categories)
    print(pd.value_counts(cats))  # 返回结果是每个区间年龄的个数

结果如下：

cats.codes: [0 0 0 1 0 0 2 1 3 2 2 1]
    cats.categories: IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]]
                  closed='right',
                  dtype='interval[int64]')
    (18, 25]     5
    (35, 60]     3
    (25, 35]     3
    (60, 100]    1
    dtype: int64

这里的codes以另一种方式告诉我们ages中的元素属于哪个区间，用的是索引值，比如ages中第一个元素为20，在区间 ( 18 , 25 ) (18,25) (18,25)之间，而该区间在bins中的索引是0，所以codes中第一个元素为0；categories返回的是关于cut函数的一些基本信息，比如有哪些区间啦，区间开闭集情况啦(此处closed=right说明集合是左开右闭，以及区间元素的类别啦(int64))；这里还有一个命令：pd.value\_counts(cats)，该命令返回的是每个区间中的元素的个数算是一个计数函数。

# 与区间的数学符号一致，小括号表示开放，中括号表示封闭，可以通过right参数改变
    print('pd.cut(ages, bins, right=False):',pd.cut(ages, bins, right=False))

结果如下：

pd.cut(ages, bins, right=False): [[18, 25), [18, 25), [25, 35), [25, 35), [18, 25), ..., [25, 35), [60, 100), [35, 60), [35, 60), [25, 35)]
    Length: 12
    Categories (4, interval[int64]): [[18, 25) < [25, 35) < [35, 60) < [60, 100)]

上面说了，默认的情况下，区间是左开右闭，如果我想要左闭右开怎么办呢？那就可以通过right参数来设置，设置为False，则左闭右开。

group_names = ['Youth', 'YoungAdults', 'MiddleAged', 'Senior']
    data = pd.cut(ages, bins, labels=group_names)
    print(data)
    print(pd.value_counts(data))

结果显示如下：

[Youth, Youth, Youth, YoungAdults, Youth, ..., YoungAdults, Senior, MiddleAged, MiddleAged, YoungAdults]
    Length: 12
    Categories (4, object): [Youth < YoungAdults < MiddleAged < Senior]
    Youth          5
    MiddleAged     3
    YoungAdults    3
    Senior         1
    dtype: int64

前面讲DataFrame格式的时候，我们曾讲过如何给数据集的列命名，如果这里我们也想给不同的区间命名，那么该如何操作呢？就是通过labels参数来设置，我们首先将想要设置的形成按顺序放在一个列表中，然后让labels等于该列表即可。

# 如果将箱子的边替代为箱子的个数，pandas将根据数据中的最大值和最小值计算出等长的箱子
    data2 = np.random.rand(20)
    print(pd.cut(data2, 4, precision=2))  # precision=2将十进制进度限制在2位

结果显示如下：

[(0.02, 0.24], (0.24, 0.46], (0.67, 0.89], (0.24, 0.46], (0.67, 0.89], ..., (0.46, 0.67], (0.67, 0.89], (0.02, 0.24], (0.02, 0.24], (0.67, 0.89]]
    Length: 20
    Categories (4, interval[float64]): [(0.02, 0.24] < (0.24, 0.46] < (0.46, 0.67] < (0.67, 0.89]]

上面的情况是我们自己指定了区间的长度，让cut去分箱，如果数据范围比较大，我们不想花时间去分区间，那该怎么弄呢？我们可以让cut命令自己去分区间。此处我们首先生成20个0-1之间的随机数，此处我们想分成四个等长的箱子，我们只要在cut命令中输入一个4即可pandas将根据数据中的最大值和最小值计算出等长的箱子。

# qcut是另一个分箱相关的函数，基于样本分位数进行分箱。取决于数据的分布，使用cut不会使每个箱子具有相同数据数量的数据点，而qcut，使用样本的分位数，可以获得等长的箱
    data3 = np.random.randn(1000)  # 正态分布
    cats = pd.qcut(data3, 4)
    print(pd.value_counts(cats))

结果显示如下：

(0.721, 3.024]      250
    (0.0634, 0.721]     250
    (-0.635, 0.0634]    250
    (-3.645, -0.635]    250
    dtype: int64

此处我们首先生成1000个标准正态分布的数据列表，此处的qcut可以使得我们分成的箱子中具有同样数目的元素。

**to\_datetime()函数**：  
今天又学了一个pandas函数，pd.to\_datetime()。  
可以将指定数据转换为相应格式的时间类型数据  
pandas.to\_datetime(arg,format=None,unit=None)

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>arg</td> 
   <td>需要转换类型的数据</td> 
  </tr> 
  <tr> 
   <td>format</td> 
   <td>所输入数据的时间格式</td> 
  </tr> 
  <tr> 
   <td>unit</td> 
   <td>最小时间间隔，如’D’代表一天</td> 
  </tr> 
 </tbody> 
</table>

**函数实例**

1.  将dateframe数据框中object型数据转换成datetime型数据  
    在本例中，我们读取一个CSV文档，文档内容如下：

date
    0  10/20/2018 13:48:08
    1  10/19/2018 13:52:30
    2  10/20/2018 14:53:58
    3  10/18/2018 20:01:24
    4  10/18/2018 16:58:32

接下来我们将object型数据转换为相应类型的datetime64型数据

new_date = pd.to_datetime(date_data['date'], format='%m/%d/%Y %H:%M:%S')
    print(new_date)

结果显示如下：

0   2018-10-20 13:48:08
    1   2018-10-19 13:52:30
    2   2018-10-20 14:53:58
    3   2018-10-18 20:01:24
    4   2018-10-18 16:58:32
    Name: date, dtype: datetime64[ns]

1.  datetime型与object型数据相互转换  
    to\_datetime()：object转为datetime  
    strftime()：datetime转为object

#原数据
    df = pd.DataFrame({ 'year': [2015, 2016],'month': [2, 3],'day': [4, 5]})
    print(df)
    >>>
       year  month  day
    0  2015      2    4
    1  2016      3    5
    
    #将指定数据转为相应类型的datetime64型数据
    df['df_time']=pd.to_datetime(df)
    print(df)
    >>>
       year  month  day    df_time
    0  2015      2    4 2015-02-04
    1  2016      3    5 2016-03-05
    
    #将时间型转为字符型
    df_object=df_time.map(lambda x:x.strftime('%Y/%m/%d'))
    print(df_object)
    >>>
    0    2015/02/04
    1    2016/03/05
    dtype: object

1.  求时间类型数据的周期(即计算出目标日期对应星期几)

#weekday_name属性是针对元素级进行操作的，所以这里利用map函数
    df['weekday']=df['df_time'].map(lambda x:x.weekday_name)
    print(df)
    >>>
       year  month  day    df_time    weekday
    0  2015      2    4 2015-02-04  Wednesday
    1  2016      3    5 2016-03-05   Saturday

1.  计算程序运行时间

import datetime
     
    starttime = datetime.datetime.now()
     #long running
    endtime = datetime.datetime.now()
     
    print ((endtime - starttime).seconds)