Pandas教程

﹏ヽ暗。殇╰゛Y 2024-03-31 12:50 83阅读 0赞

#### 文章目录 ####

*  一. Pandas简介
 *   *  1.1 概念
     *  1.2 优点
     *  1.3 数据类型分类
 *  二. 系列（Series）
 *   *  2.1 简介
     *  2.2 Series创建
     *  2.2 Series数据访问
     *  2.3 系列的基本功能
 *  三. 数据帧（DataFrame）
 *   *  3.1 简介
     *  3.2 构造函数
     *  3.3 操作DataFrame对象
     *  3.4 数据帧基本属性
 *  四. DataFrame基本使用
 *   *  4.1 重建索引
     *  4.2 迭代
     *  4.3 排序
     *  4.4 层次化索引
 *  五. 函数
 *   *  5.1 描述性统计信息函数
     *  5.2 汇总数据
     *  5.3 统计函数

## 一. Pandas简介 ##

### 1.1 概念 ###

> Pandas是一款开放源码的BSD许可的Python库，为Python编程语言提供了高性能，易于使用的数据结构和数据分析工具。广泛的领域，包括金融、经济、统计、分析等学术和商业领域，Pandas是基于Numpy的一种工具，该工具是为了解决数据分析任务而创建的，Pandas纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具

### 1.2 优点 ###

1.  快速高效的DataFrame对象，具有默认和自定义索引
2.  将数据从不同文件格式加载到内存中的数据对象工具
3.  丢失数据的数据对齐和综合处理
4.  集成时间序列功能
5.  基于标签切片，索引和大数据集的子集
6.  可以删除或插入来自数据结构的列
7.  按数据分组进行聚合和转换
8.  高性能合并和数据加入
9.  合并及其他出现在常见数据库（例如基于SQL的）中的关系型运算

### 1.3 数据类型分类 ###

1.  系列（Series）
2.  数据帧（DataFrame）：被广泛使用，是最重要的数据结构之一
3.  面板（Panel）：很少使用呢

> 三种数据结构构建在Numpy数组之上，这意味着它们很快。考虑这些数据结构最好的方法是，较高维数据结构是其较低维数据结构的容器，如下：

<table> 
 <thead> 
  <tr> 
   <th>数据结构</th> 
   <th>维数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>系列</td> 
   <td>1</td> 
   <td>1D标记均匀数组，大小不变</td> 
  </tr> 
  <tr> 
   <td>数据帧</td> 
   <td>2</td> 
   <td>一般2D标记，大小可变的表结构与潜在的异质类型的列</td> 
  </tr> 
  <tr> 
   <td>面板</td> 
   <td>3</td> 
   <td>一般3D标记，大小可变数组</td> 
  </tr> 
 </tbody> 
</table>

## 二. 系列（Series） ##

### 2.1 简介 ###

能够保存任何类型的谁（整数、字符串、浮点数和Python对象等）的一维标记数组，轴标签统称为索引

### 2.2 Series创建 ###

`pandas.Series(data=None,index=None,dtype=None,copy=None)`

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>data</td> 
   <td>数据采取各种形式，如：ndarray，list，constants</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>索引值必须是唯一的和散列的，与数据的长度相同</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>数据类型，如果没有，将推断数据类型</td> 
  </tr> 
  <tr> 
   <td>copy</td> 
   <td>复制数据，默认为false</td> 
  </tr> 
 </tbody> 
</table>

> 创建一个空系列

import pandas as pd
    #创建一个空系列
    s=pd.Series()

> 从ndarray创建一个系列：如果数据是ndarray，则传递的索引必须具有相同的长度。如果没有传递索引值，那么默认索引将是范围(n)，其中n是数组的长度

import numpy as np
    import pandas as pd
    x=np.array([1,2,3,4,5])
    s=pd.Series(x)  #不指定index
    t=pd.Series(x,index=(10,20,30,40,50)) #指定index
    print(s)
    print(t)

![在这里插入图片描述][9ce04a7313d2487eaf1e4084559a9e4c.png]

> 从字典创建一个索引：字典可以作为输入传递，如果没有指定索引，则按排序顺序取得字典键以构造索引。如果传递了索引，索引中与标签对于的数据中的值将被拉出

import numpy as np
    import pandas as pd
    d={
        'name':'jakiechai','sex':'man','homesite':'beijing'}
    s=pd.Series(d) #不传递index
    t=pd.Series(d,index=('homesite','name','sex','age'))
    print(s)
    print(t)

![在这里插入图片描述][e3a5077d959e4b74aacac2263cc71b33.png]

> 从标量创建一个系列：如果数据是标量值，则必须提供索引，将重复该值以匹配索引的长度

s=pd.Series(5,index=[0,1,2,3,4,5,6])
    print(s)

![在这里插入图片描述][fd4f1a31fa4b457b80a41de16eeb534a.png]

### 2.2 Series数据访问 ###

> 从具体有位置的系列中访问数据：系列中的数据可以使用类似于ndarray中的数据来访问

import numpy as np
    import pandas as pd
    x=np.array([1,2,3,4,5])
    s=pd.Series(x,index=[1,2,3,4,5])  #不指定index
    print("下标拿：\n",s[1])
    print("切片拿：\n",s[2:])

![在这里插入图片描述][724744f18f3840c88af59bb98d7d18b0.png]

> 使用标签检索数据（索引）：一个系列就像一个固定大小的字典，可以通过索引标签获取和设置值

import numpy as np
    import pandas as pd
    d={
        'name':'jakiechai','sex':'man','homesite':'beijing'}
    s=pd.Series(d) 
    print(s['name'])
    print(s[['name','sex']])

![在这里插入图片描述][9ae9471e271040b89934fa5ce1918d6c.png]

### 2.3 系列的基本功能 ###

> 基本属性

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>axes</td> 
   <td>返回行轴标签列表</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>返回对象的数据类型</td> 
  </tr> 
  <tr> 
   <td>empty</td> 
   <td>返回系列为空，则返回true</td> 
  </tr> 
  <tr> 
   <td>ndim</td> 
   <td>返回底层数据的维数，默认定义1</td> 
  </tr> 
  <tr> 
   <td>size</td> 
   <td>返回基础数据中的元素数个数</td> 
  </tr> 
  <tr> 
   <td>values</td> 
   <td>将系列作为ndarray返回</td> 
  </tr> 
 </tbody> 
</table>

s=pd.Series(np.random.randn(5))
    print("axes:",s.axes)
    print("dtype:",s.dtype)
    print("ndim:",s.ndim)
    print("size:",s.size)
    print('values:',s.values)

![在这里插入图片描述][a4432b6eef2e4bb5a9f1418e9ab9d21e.png]

> 基本方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>head()</td> 
   <td>head()返回前n行数据，默认为5，可以自己设定</td> 
  </tr> 
  <tr> 
   <td>tail()</td> 
   <td>tail()返回最后n行，默认为5，可以自己指定</td> 
  </tr> 
 </tbody> 
</table>

s=pd.Series(np.random.randn(5))
    print(s.head(2))
    print(s.tail(2))

![在这里插入图片描述][f8d46ee6a0484130ae96206f53cb00d7.png]

<table> 
 <thead> 
  <tr> 
   <th>文本操作函数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>len()</td> 
   <td>计算字符串长度</td> 
  </tr> 
  <tr> 
   <td>lower()</td> 
   <td>将Series/Index中的字符串转换为小写</td> 
  </tr> 
  <tr> 
   <td>upper()</td> 
   <td>将Series/Index中的字符串转换为大写</td> 
  </tr> 
  <tr> 
   <td>swapcase()</td> 
   <td>变换字母的大小写</td> 
  </tr> 
  <tr> 
   <td>title()</td> 
   <td>转为标题天模式</td> 
  </tr> 
  <tr> 
   <td>strip()</td> 
   <td>帮助从两侧的系列/索引中的每个字符串中删除空格（包括换行符）</td> 
  </tr> 
  <tr> 
   <td>split(‘’)</td> 
   <td>用给定的模式拆分每个字符串</td> 
  </tr> 
  <tr> 
   <td>get_dummies()</td> 
   <td>返回具有单热编码值的数据帧(DataFrame)</td> 
  </tr> 
  <tr> 
   <td>cat(sep=‘’)</td> 
   <td>使用给定的分隔符连接系列/索引元素</td> 
  </tr> 
  <tr> 
   <td>contains(pattern)</td> 
   <td>如果元素中包含子字符串，则返回每个元素的布尔值True，否则为False</td> 
  </tr> 
  <tr> 
   <td>replace(a,b)</td> 
   <td>将值a替换为值b</td> 
  </tr> 
  <tr> 
   <td>repeat(value)</td> 
   <td>重复每个元素指定的次数</td> 
  </tr> 
  <tr> 
   <td>count(parttern)</td> 
   <td>返回模式中每个元素的出现次数</td> 
  </tr> 
  <tr> 
   <td>startwith(pattern)</td> 
   <td>如果系列/索引中的元素以模式开始，则返回true</td> 
  </tr> 
  <tr> 
   <td>endwith(parttern)</td> 
   <td>如果系列/索引中的元素以模式结束，则返回true</td> 
  </tr> 
  <tr> 
   <td>find(parttern)</td> 
   <td>返回模式第一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>findall(pattern)</td> 
   <td>返回模式的所有出现的列表</td> 
  </tr> 
  <tr> 
   <td>islower()</td> 
   <td>检查系列/索引中每个字符串中所有字符是否小写，返回布尔值</td> 
  </tr> 
  <tr> 
   <td>isupper()</td> 
   <td>检查系列/索引中每个字符串中的所有字符是否大写，返回布尔值</td> 
  </tr> 
  <tr> 
   <td>isnumeric()</td> 
   <td>检查系列/索引中每个字符串中的所有字符是否为数字，返回布尔值</td> 
  </tr> 
 </tbody> 
</table>

s=pd.Series(['    Tom','Willim Rick','John','Alberat',np.nan,'1234','SteveMinsu'])
    print("len(）方法:",s.str.len())
    print("lower(）方法:",s.str.lower())
    print("strip(）方法:",s.str.strip())
    print("split(）方法:",s.str.split(" "))
    print("cat(）方法:",s.str.cat(sep="-"))

![在这里插入图片描述][9eb0011b76d7428c900353c13b813c15.png]

## 三. 数据帧（DataFrame） ##

### 3.1 简介 ###

> 数据帧可以理解为一张表格，即数据以行和列的表格方式排列，其有如下的功能特点：
> 
> 1.  潜在的列是不同的类型
> 2.  大小可变
> 3.  标记轴（行和列）
> 4.  可以对行和列执行算术运算

### 3.2 构造函数 ###

`DataFrame(data=None,index=None,columns=None,dtype=None,copy=False)`

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>data</td> 
   <td>采用各种形式，如:Ndarray，series，map，lists，dict（每一个键值对代表一列），constant和另一个DataFrame对象</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)</td> 
  </tr> 
  <tr> 
   <td>column</td> 
   <td>对于列标签，可选的默认语法是-np.arange(n)</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>每列的数据类型</td> 
  </tr> 
  <tr> 
   <td>copy</td> 
   <td>如果默认值为False，则此命令（或任何它）用于复制数据</td> 
  </tr> 
 </tbody> 
</table>

> 创建DataFrame对象

df=pd.DataFrame()  #创建空的DataFrame
    print(df)
    li=[1,2,3,4,5]
    df=pd.DataFrame(li)
    print(df)
    data=[['sunck',18],['kaige,19'],['huazai',20]]
    df=pd.DataFrame(data,columns=['name','age'],dtype='f',index=[1,2,3])
    print(df)

![在这里插入图片描述][a4140da9bc7b40e08c3eefba02d9f61f.png]

### 3.3 操作DataFrame对象 ###

> 列操作

data={
        
        'one': pd.Series([1,2,3],index=['a','b','c']),
        'two': pd.Series([4,5,6,7],index=['a','b','c','d'])
    }
    df=pd.DataFrame(data)
    print(df['one':]) #选择列
    df['tree']=pd.Series([9,10,11],index=['a','b','c']) #添加列
    del df['one'] #删除列
    df.pop('one') #删除列

> 行操作

data={
        
        'one': pd.Series([1,2,3],index=['a','b','c']),
        'two': pd.Series([4,5,6,7],index=['a','b','c','d'])
    }
    df=pd.DataFrame(data)
    #1. 行选择
    ##标签选择loc
    print(df.loc['b'])
    ##按整数位置选择iloc
    print(df.iloc[2])
    ##行切片拿
    print(df[2:4])
    
    #2. 添加行
    df=df.append(pd.DataFrame([[200,300]],columns=['one','two'],index=['e']))
    print(df)
    
    #3. 删除行
    df.drop(['a','b'])

### 3.4 数据帧基本属性 ###

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>T</td> 
   <td>转置行和列</td> 
  </tr> 
  <tr> 
   <td>axes</td> 
   <td>返回一个列，行轴标签和列轴标签作为唯一的成员</td> 
  </tr> 
  <tr> 
   <td>dtypes</td> 
   <td>返回此对象中的数据类型</td> 
  </tr> 
  <tr> 
   <td>empty</td> 
   <td>如果为空，则返回true否则返回false</td> 
  </tr> 
  <tr> 
   <td>ndim</td> 
   <td>返回维度</td> 
  </tr> 
  <tr> 
   <td>shape</td> 
   <td>返回表示的DataFrame对象中的维度的元组</td> 
  </tr> 
  <tr> 
   <td>size</td> 
   <td>返回元素个数</td> 
  </tr> 
  <tr> 
   <td>values</td> 
   <td>数据以numpy形式返回</td> 
  </tr> 
 </tbody> 
</table>

data={
        
        'name': pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack']),
        'Age':pd.Series([25,26,27,28,45,34,23]),
        'Rating':pd.Series([1,2,3,4,5,6,7])
    }
    df=pd.DataFrame(data)
    print(df)
    print("-------------")
    print(df.T)
    print("-------------")
    print(df.axes)
    print("-------------")
    print(df.dtypes)
    print("-------------")
    print(df.ndim)
    print("-------------")
    print(df.shape)
    print("-------------")
    print(df.size)
    print("-------------")
    print(df.values)
    print("-------------")

![在这里插入图片描述][bf2b12d5dea94ceeb8e0e94325760de9.png]

## 四. DataFrame基本使用 ##

### 4.1 重建索引 ###

> 重建索引会更改DataFrame的行标签和列标签，重新索引意味着符合数据以匹配特定轴上的一组给定的标签，可以通过索引来实现多个操作：
> 
> 1.  重新排列现有数据以匹配一组新的索引
> 2.  在没有标签数据的标签位置插入缺省值标记

**API:**  
`reindex(labels=None,index=None,columns=None,axis=None,method=none,copy=True,level=None,fill_value=nan,limit=None,tolerance=None)`

用于重构索引

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>index</td> 
   <td>行索引</td> 
  </tr> 
  <tr> 
   <td>columns</td> 
   <td>列索引</td> 
  </tr> 
  <tr> 
   <td>method</td> 
   <td>填充模式包括pad/fill(向前填充值)、bfill/backfill(向后填充值)、nearest(从最近的索引值填充)</td> 
  </tr> 
  <tr> 
   <td>limit</td> 
   <td>限制</td> 
  </tr> 
 </tbody> 
</table>

import numpy as np
    import pandas as pd
    data={
        
        'A':pd.date_range(start="2019-01-01",periods=20,freq="D"),
        'X':np.linspace(0,19,num=20),
        'Y':np.random.rand(20),
        'C':np.random.choice(["low","medium","hight"],20).tolist(),
        'D':np.random.normal(100,10,size=(20)).tolist()
    }
    df=pd.DataFrame(data)
    print(df)
    #重建索引
    df2_reindex=df.reindex(index=(0,2,5),columns=['A','C'])
    print(df2_reindex)
    df1=pd.DataFrame(np.random.randn(10,3),columns=['A','X','Y'])
    df2_reindex=df.reindex_like(df1)
    print(df2_reindex)

![在这里插入图片描述][0364233672a34098b8a1ba4036a6298f.png]  
`rename()`  
允许基于一些映射（字典或系列）或任意函数来重新标记一个轴（rename方法提供了一个inplace命名参数，默认为False，表示在原来基础上拷贝再修改，为True时则直接在原来的对象上修改）

### 4.2 迭代 ###

pandas对象之间的基本迭代的行为取决于类型。当迭代一个系列时，它被视为数组式，基本迭代产生这些值。其他数据结构，如：DataFrame和Panel，遵循类似的惯例迭代对象的键

> 迭代列

import numpy as np
    import pandas as pd
    df=pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
    for colName in df:
        print(colName)  #迭代列名
        print(df[colName]) #迭代列

![在这里插入图片描述][437f4da60ec94ecb8ad7bf0611ba256d.png]

> 迭代行

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>iteritems()</td> 
   <td>迭代(key, value)对</td> 
  </tr> 
  <tr> 
   <td>iterrows()</td> 
   <td>将行迭代为(索引，系列）对</td> 
  </tr> 
  <tr> 
   <td>itertuples()</td> 
   <td>以namedtuples的形式迭代</td> 
  </tr> 
 </tbody> 
</table>

`iteritems()`  
将每个列作为键，将值与值作为键和列值迭代为series对象

import numpy as np
    import pandas as pd
    df=pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
    for key,value in df.iteritems():
        print(key)
        print(value)
        print("------------")

![在这里插入图片描述][f1121f4f7d0b449c93b1e9a6323befd2.png]  
`iterrows()`  
返回迭代器，产生每个索引值以及保护每行数据的序列

import numpy as np
    import pandas as pd
    df=pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
    for index,row in df.iterrows():
        print(index)
        print(row)
        print("----------")

![在这里插入图片描述][b451cc393fa7474aa02a11613c0695f6.png]  
`itertuples()`

for row in df.itertuples():
        print(row,row[0]) #得到的是元组
        print("---------")

![在这里插入图片描述][b238630f038b4c31b348dd421358721d.png]

> 注意：不要尝试在迭代时修改任何对象。迭代是用于读取的，迭代器返回原始对象（视图）的副本，因此更改将不会反映在原始对象上（而是原始对象的一个副本）

### 4.3 排序 ###

pandas有两种排序方法，它们分别是按标签和按实际值

> 按标签排序

`sort_index(axis=0,leve=None,ascending=True,inplace=False,kind='quicksort',na_position='last',sort_remainding=True,by=None)`

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>axis</td> 
   <td>值为0逐行排序，值为1逐列排序</td> 
  </tr> 
  <tr> 
   <td>ascending</td> 
   <td>值为True升序排序</td> 
  </tr> 
  <tr> 
   <td>inplace</td> 
   <td>是否真正改变原对象</td> 
  </tr> 
  <tr> 
   <td>kind</td> 
   <td>排序算法，默认使用快排序</td> 
  </tr> 
 </tbody> 
</table>

df=pd.DataFrame(np.random.randn(10,2),columns=['col1','col2'],index=[1,4,2,5,6,8,9,10,12,56])
    print(df)
    sorterdf=df.sort_index()
    sorterdf

![在这里插入图片描述][0ead002d7db949d6bafe0ca9474f9d96.png]

> 按值排序

`sort_values(by,axis=0,ascending=True,inplace=False,kind='quiksort',na_position='last')`

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>by</td> 
   <td>使用要与其排序的Data Frame的名称</td> 
  </tr> 
 </tbody> 
</table>

df=pd.DataFrame(np.random.randn(10,2),columns=['col1','col2'],index=[1,4,2,5,6,8,9,10,12,56])
    print(df)
    sorteddf=df.sort_values(by='col1')
    sorteddf

![在这里插入图片描述][df8b8f5395884148a6aca59465c2aec6.png]

### 4.4 层次化索引 ###

1.  多层次行索引

> 隐式构造

s=pd.Series(np.random.rand(4),index=[['a','b','c','d'],[1,2,1,2]])
    s2=pd.DataFrame(s,columns=['one'])
    s2

![在这里插入图片描述][df04d89adac34fef8ae6a86aa20a22d2.png]

> 显示构造

mindex=pd.MultiIndex.from_arrays([['a','a','b','b'],[1,2,1,2]]) #数组方式创建
    mindex2=pd.MultiIndex.from_tuples([("a",1),("a",2),("b",1),("b",2)]) #元组
    mindex3=pd.MultiIndex.from_product([["a","b"],[1,2]]) #product创建
    s=pd.Series(np.random.rand(4),index=[['a','a','b','b'],[1,2,1,2]])
    df=pd.DataFrame(s,index=mindex)
    print("数组创建：\n",df)
    df=pd.DataFrame(s,index=mindex)
    print("元组创建：\n",df)
    df=pd.DataFrame(s,index=mindex)
    print("product创建：\n",df)

![在这里插入图片描述][0f1baadb9652456f83ecbf00ee551e38.png]  
2. 操作索引

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>stack()</td> 
   <td>将列索引变为行索引</td> 
  </tr> 
  <tr> 
   <td>unstack()</td> 
   <td>将行索引变为列索引</td> 
  </tr> 
 </tbody> 
</table>

score=np.random.randint(0,150,(3,10))
    mindex=pd.MultiIndex.from_product([list("ABCDE"),['期中','期末']])
    df=pd.DataFrame(data=score,index=["python",'java','c'],columns=mindex)
    print(df.stack(level=0)) #将第一层的行索引变为列索引
    print(df.unstack())

![在这里插入图片描述][a940902e525b4246a394c7b7764e6b8f.png]

## 五. 函数 ##

### 5.1 描述性统计信息函数 ###

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>count()</td> 
   <td>非空观测数量</td> 
  </tr> 
  <tr> 
   <td>sum()</td> 
   <td>所有值之和</td> 
  </tr> 
  <tr> 
   <td>mean()</td> 
   <td>所有值的平均值</td> 
  </tr> 
  <tr> 
   <td>median()</td> 
   <td>所有值的中位数</td> 
  </tr> 
  <tr> 
   <td>mode()</td> 
   <td>值的模值</td> 
  </tr> 
  <tr> 
   <td>std()</td> 
   <td>值的标准偏差</td> 
  </tr> 
  <tr> 
   <td>min()</td> 
   <td>所有值中的最小值</td> 
  </tr> 
  <tr> 
   <td>max()</td> 
   <td>所有值中的最大值</td> 
  </tr> 
  <tr> 
   <td>abs()</td> 
   <td>绝对值</td> 
  </tr> 
  <tr> 
   <td>prod()</td> 
   <td>数组元素的乘积</td> 
  </tr> 
  <tr> 
   <td>cumsum()</td> 
   <td>累计总和</td> 
  </tr> 
  <tr> 
   <td>cumprod()</td> 
   <td>累计乘积</td> 
  </tr> 
 </tbody> 
</table>

### 5.2 汇总数据 ###

`describe()`函数是用来计算有关DataFrame列的统计信息的摘要

data={
        
        "name":pd.Series(['A','B','C','D','E']),
        'age':pd.Series([30,28,45,12,55]),
        'rating':pd.Series([4.32,5.34,1.23,2.33,6.33])
    }
    df=pd.DataFrame(data)
    print(df)
    df.describe()

![在这里插入图片描述][a5ff0e209a4e42d493762a6ae76cf237.png]

### 5.3 统计函数 ###

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>pct_change()</td> 
   <td>系列，DataFrame和Panel都有pct_change()函数。此函数将每个元素与其前一个元素进行比较，并计算变化百分比</td> 
  </tr> 
  <tr> 
   <td>cov()</td> 
   <td>协方差适用于系列数据，Series对象有一个方法cov用来计算序列对象之间的协方差。Na将自动被排除。当应用于DataFrame时，协方差方法计算所有列之间的协方差(cov)值</td> 
  </tr> 
  <tr> 
   <td>corr()</td> 
   <td>相关性显示了任何两个数值（系列）之间的线性关系，有多种方法来计算pearson(默认)，spearman和kendall之间的相关性</td> 
  </tr> 
  <tr> 
   <td>rank()</td> 
   <td>数据排名为元素数组中的每个元素生成排名。在关系的情况下，分配平均等级</td> 
  </tr> 
 </tbody> 
</table>

[9ce04a7313d2487eaf1e4084559a9e4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/abe0b5c332ae499cb53d3c4ba591d05c.png
[e3a5077d959e4b74aacac2263cc71b33.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a18dd7c89ef74f93b967d0ba4b9bedaa.png
[fd4f1a31fa4b457b80a41de16eeb534a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ff76f58f64f84717b84b85ae89a47d74.png
[724744f18f3840c88af59bb98d7d18b0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/53d04af55b1041c193cf8e627643178e.png
[9ae9471e271040b89934fa5ce1918d6c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a813a41e85004655881eff0f3a2e47d7.png
[a4432b6eef2e4bb5a9f1418e9ab9d21e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/edf3bbddffa444fc8d07f4a5952f2951.png
[f8d46ee6a0484130ae96206f53cb00d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/1edfc023e9ef48faafc0ded16353aa66.png
[9eb0011b76d7428c900353c13b813c15.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/11b2ee371440410ca6ed9a2a3c4e0deb.png
[a4140da9bc7b40e08c3eefba02d9f61f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4da2ecc6070a4d858e4effba134d13a7.png
[bf2b12d5dea94ceeb8e0e94325760de9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/80fa6fd70ada457ba3f307615ba457f4.png
[0364233672a34098b8a1ba4036a6298f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/36fb3291c76542e5a6810278f4127097.png
[437f4da60ec94ecb8ad7bf0611ba256d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/0b2920a237944bd7ba02e050bcfbe68f.png
[f1121f4f7d0b449c93b1e9a6323befd2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/86a0d2c9b0d84abfa1008cfdd2bf324d.png
[b451cc393fa7474aa02a11613c0695f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d23d2e97f4194fa38b45284936a46bbc.png
[b238630f038b4c31b348dd421358721d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/7a12864849e14ff480b084bc75e31257.png
[0ead002d7db949d6bafe0ca9474f9d96.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/1580952a594b469f9274192fa0a1c8b7.png
[df8b8f5395884148a6aca59465c2aec6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/7b56736258854640ac0267b418bf2e4f.png
[df04d89adac34fef8ae6a86aa20a22d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/821fdab8d485494d92fab38fcf7730e0.png
[0f1baadb9652456f83ecbf00ee551e38.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f7875efd05ed40cf930b70396fa7b6ea.png
[a940902e525b4246a394c7b7764e6b8f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4e78001d3319464684459ec3a99cdad6.png
[a5ff0e209a4e42d493762a6ae76cf237.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c30b51e954e14c478cb94126ea248e30.png