一、概述

Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来，享有数据分析“三剑客之一”的盛名（NumPy、Matplotlib、Pandas）。Pandas 已经成为 Python 数据分析的必备高级工具，它的目标是成为强大、灵活、可以支持任何编程语言的数据分析工具。
它主要实现了数据分析的五个重要环节：

• 加载数据
• 整理数据
• 操作数据
• 构建数据模型

• 分析数据

  Pandas主要特点

  Pandas 主要包括以下几个特点：

• 它提供了一个简单、高效、带有默认标签（也可以自定义标签）的 DataFrame 对象。

• 能够快速得从不同格式的文件中加载数据（比如 Excel、CSV 、SQL文件），然后将其转换为可处理的对象；
• 能够按数据的行、列标签进行分组，并对分组后的对象执行聚合和转换操作；
• 能够很方便地实现数据归一化操作和缺失值处理；
• 能够很方便地对 DataFrame 的数据列进行增加、修改或者删除的操作；
• 能够处理不同格式的数据集，比如矩阵数据、异构数据表、时间序列等；
• 提供了多种处理数据集的方式，比如构建子集、切片、过滤、分组以及重新排序等。

  Pandas内置数据结构

  pandas有两个主要数据结构：Series和DataFrame。

安装

pip install pandas

二、Pandas Series(一维)

Series 结构，也称 Series 序列，是 Pandas 常用的数据结构之一，它是一种类似于一维数组的结构，由一组数据值（value）和一组标签（索引）组成，其中标签与数据值之间是一一对应的关系。
Series 可以保存任何数据类型，比如整数、字符串、浮点数、Python 对象等，它的标签默认为整数，从 0 开始依次递增。Series 的结构图，如下所示：

通过标签我们可以更加直观地查看数据所在的索引位置。

创建Series对象

import pandas as pd
s=pd.Series( data, index, dtype, copy)

可以使用数组、字典、标量值或者 Python 对象来创建 Series 对象。

import pandas as pd
import numpy as np
# 输出数据为空
# 创建一个空Series对象
s = pd.Series()
print(s)
# ndarray创建Series对象
data = np.array(['a', 'b', 'c', 'd'])
s = pd.Series(data)
print(s)
#“显式索引”的方法定义索引标签
data = np.array(['a','b','c','d'])
#自定义索引标签（即显示索引）
s = pd.Series(data,index=[100,101,102,103])
print(s)
#dict创建Series对象
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print(s)
#标量创建Series对象
s = pd.Series(5, index=[0, 1, 2, 3])
print(s)

访问Series数据

# 1) 位置索引访问
s = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print(s[0])  # 位置下标
print(s['a'])  # 标签下标
# 切片的方式访问 Series 序列中的数据
print(s[:3])
print(s[-3:])
#2) 索引标签访问
#索标签访问单个元素值
print(s['a'])
#索引标签访问多个元素值
print(s[['a','c','d']])

Series常用属性

Series 的常用属性和方法。在下表列出了 Series 对象的常用属性。

s = pd.Series(np.random.randn(5))
print(s)
#1) axes
print(s.axes)
#2) dtype
print(s.dtype)
#3) empty
print (s.empty)
#4) ndim
print (s.ndim)
#5) size
#series的长度大小
print(s.size)
#6) values
print(s.values)
# 7) index
# 该属性用来查看 Series 中索引的取值范围
print(s.index)
#隐式索引
s1=pd.Series([1,2,5,8])
print(s1.index)

Series常用方法

1) head()&tail()查看数据

import pandas as pd
import numpy as np
s = pd.Series(np.random.randn(5))
print ("The original series is:")
print (s)
#返回前三行数据
print (s.head(3))

2) isnull()&nonull()检测缺失值

isnull() 和 nonull() 用于检测 Series 中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少。

• isnull()：如果为值不存在或者缺失，则返回 True。
• notnull()：如果值不存在或者缺失，则返回 False。

其实不难理解，在实际的数据分析任物中，数据的收集往往要经历一个繁琐的过程。在这个过程中难免会因为一些不可抗力，或者人为因素导致数据丢失的现象。这时，我们可以使用相应的方法对缺失值进行处理，比如均值插值、数据补齐等方法。

import pandas as pd
#None代表缺失数据
s=pd.Series([1,2,5,None])
print(pd.isnull(s))  #是空值返回True
print(pd.notnull(s)) #空值返回False

三、Pandas DataFrame（二维）

DataFrame是一个表格型的数据类型，每列值类型可以不同，是最常用的pandas对象。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。DataFrame中的数据是以一个或多个二维块存放的（而不是列表、字典或别的一维数据结构）。

DataFrame 的每一行数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列标签。因此 DataFrame 其实是从 Series 的基础上演变而来。在数据分析任务中 DataFrame 的应用非常广泛，因为它描述数据的更为清晰、直观。

DataFrame 结构类似于 Execl 的表格型，表格中列标签的含义如下所示：

• Regd.No：表示登记的序列号
• Name：学生姓名
• Marks：学生分数

同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应。上述表格的行标签从 0 到 5，共记录了 5 条数据（图中将行标签省略）。当然你也可以用“显式索引”的方式来设置行标签。

下面对 DataFrame 数据结构的特点做简单地总结，如下所示：

• DataFrame 每一列的标签值允许使用不同的数据类型；
• DataFrame 是表格型的数据结构，具有行和列；
• DataFrame 中的每个数据值都可以被修改。
• DataFrame 结构的行数、列数允许增加或者删除；
• DataFrame 有两个方向的标签轴，分别是行标签和列标签；
• DataFrame 可以对行和列执行算术运算。

  创建DataFrame对象

  创建 DataFrame 对象的语法格式如下：
  

  import pandas as pd
  pd.DataFrame( data, index, columns, dtype, copy)

  参数说明：

Pandas 提供了多种创建 DataFrame 对象的方式，主要包含以下五种，分别进行介绍。

1) 创建空的DataFrame对象

使用下列方式创建一个空的 DataFrame，这是 DataFrame 最基本的创建方法。

import pandas as pd
df = pd.DataFrame()
print(df)

2) 列表创建DataFame对象

可以使用单一列表或嵌套列表来创建一个 DataFrame。
单一列表创建 DataFrame：

import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print(df)

使用嵌套列表创建 DataFrame 对象：

data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print(df)

3) 字典嵌套列表创建

data 字典中，键对应的值的元素长度必须相同（也就是列表长度相同）。如果传递了索引，那么索引的长度应该等于数组的长度；如果没有传递索引，那么默认情况下，索引将是 range(n)，其中 n 代表数组长度。

data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print(df)

注意：这里使用了默认行标签，也就是 range(n)。它生成了 0,1,2,3，并分别对应了列表中的每个元素值。
添加自定义的行标签：

import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print(df)

4) 列表嵌套字典创建DataFrame对象

列表嵌套字典可以作为输入数据传递给 DataFrame 构造函数。默认情况下，字典的键被用作列名。

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print(df)

列索引操作DataFrame

DataFrame 可以使用列索（columns index）引来完成数据的选取、添加和删除操作。

1) 列索引选取数据列

import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df ['one'])

2) 列索引添加数据列

import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
#使用df['列']=值，插入新的数据列
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print(df)
#将已经存在的数据列做相加运算
df['four']=df['one']+df['three']
print(df)

3) 列索引删除数据列

通过 del 和 pop() 都能够删除 DataFrame 中的数据列。

import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']),
   'three' : pd.Series([10,20,30], index=['a','b','c'])}
df = pd.DataFrame(d)
print ("Our dataframe is:")
print(df)
#使用del删除
del df['one']
print(df)
#使用pop方法删除
df.pop('two')
print (df)

行索引操作DataFrame

1) 标签索引选取

import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df.loc['b'])

2) 整数索引选取

通过将数据行所在的索引位置传递给 iloc 函数，也可以实现数据行选取。

import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print (df.iloc[2]）

3) 切片操作多行选取

import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
#左闭右开
print(df[2:4])

4) 添加数据行

使用 append() 函数，可以将新的数据行添加到 DataFrame 中，该函数会在行末追加数据行。

import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
#在行末追加新数据行
df = df.append(df2)
print(df)

5) 删除数据行

使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。

import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
print(df)
#注意此处调用了drop()方法
df = df.drop(0)
print (df)

常用属性和方法汇总

DataFrame 的属性和方法，与 Series 相差无几，如下所示：

d = {'Name': pd.Series(['c语言中文网', '编程帮', "百度", '360搜索', '谷歌', '微学苑', 'Bing搜索']),
     'years': pd.Series([5, 6, 15, 28, 3, 19, 23]),
     'Rating': pd.Series([4.23, 3.24, 3.98, 2.56, 3.20, 4.6, 3.8])}
# 构建DataFrame
df = pd.DataFrame(d)
# 1) T（Transpose）转置 返回 DataFrame 的转置，也就是把行和列进行交换。
# 输出DataFrame的转置
print(df.T)
# 2) axes 返回一个行标签、列标签组成的列表。
# 输出行、列标签
print(df.axes)
# 3) dtypes 返回每一列的数据类型。
# 输出行、列标签
print(df.dtypes)
# 4) empty
# 返回一个布尔值，判断输出的数据对象是否为空，若为 True 表示对象为空。
# 判断输入数据是否为空
print(df.empty)
# 5) ndim
# 返回数据对象的维数。DataFrame 是一个二维数据结构。
# DataFrame的维度
print(df.ndim)
# 6) shape
# 返回一个代表 DataFrame 维度的元组。返回值元组 (a,b)，其中 a 表示行数，b 表示列数。
# DataFrame的形状
print(df.shape)
# 7) size
# 返回 DataFrame 中的元素数量。
# DataFrame的中元素个数
print(df.size)
# 8) values
# 以 ndarray 数组的形式返回 DataFrame 中的数据。
# DataFrame的数据
print(df.values)
# 9) head()&tail()查看数据
# 如果想要查看 DataFrame 的一部分数据，可以使用 head() 或者 tail() 方法。其中 head() 返回前 n 行数据，默认显示前 5 行数据。
# tail() 返回后 n 行数据
# 获取后2行数据
print(df.tail(2))
# 10) shift()移动行或列
# 如果您想要移动 DataFrame 中的某一行/列，可以使用 shift() 函数实现。它提供了一个periods参数，该参数表示在特定的轴上移动指定的步幅。
# shif() 函数的语法格式如下：
# DataFrame.shift(periods=1, freq=None, axis=0)
# peroids    类型为int，表示移动的幅度，可以是正数，也可以是负数，默认值为1。
# freq    日期偏移量，默认值为None，适用于时间序。取值为符合时间规则的字符串。
# axis    如果是 0 或者 "index" 表示上下移动，如果是 1 或者 "columns" 则会左右移动。
# fill_value    该参数用来填充缺失值。
# 移动幅度为3
info = pd.DataFrame({'a_data': [40, 28, 39, 32, 18],
                     'b_data': [20, 37, 41, 35, 45],
                     'c_data': [22, 17, 11, 25, 15]})
# 移动幅度为3
info.shift(periods=3)
# 将缺失值和原数值替换为52
info.shift(periods=3, axis=1, fill_value=52)
#注意：fill_value 参数不仅可以填充缺失值，还也可以对原数据进行替换。

四、Pandas使用自定义函数

自定义的函数，或者把其他库中的函数应用到 Pandas 对象中，有以下三种方法：

• 1) 操作整个 DataFrame 的函数：pipe()
• 2) 操作行或者列的函数：apply()
• 3) 操作单一元素的函数：applymap()

  操作整个数据表

  通过给 pipe() 函数传递一个自定义函数和适当数量的参数值，从而操作 DataFrme 中的所有元素。 ```python

  自定义一个函数，计算两个元素的加和

  def adder(ele1, ele2): return ele1 + ele2

自定义的函数对 DataFrame 进行操作

df = pd.DataFrame(np.random.randn(4, 3, columns=[‘c1’, ‘c2’, ‘c3’]))

传入自定义函数以及要相加的数值3

df.pipe(adder, 3)

<a name="uiTcI"></a>
## 操作行或列
如果要操作  DataFrame 的某一行或者某一列，可以使用 apply() 方法，该方法与描述性统计方法类似，都有可选参数 axis，并且默认按列操作。
```python
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean)
#默认按列操作，计算每一列均值
print(df.apply(np.mean))
#传递轴参 axis=1， 表示逐行进行操作
print (df.apply(np.mean,axis=1))
#求每一列中，最大值与最小值之差。
print(df.apply(lambda x: x.max() - x.min()))

操作单一元素

DataFrame 数据表结构的 applymap() 和 Series 系列结构的 map() 类似，它们都可以接受一个 Python 函数，并返回相应的值。

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
#自定义函数lambda函数
print(df['col1'].map(lambda x:x*100))
print(df.applymap(lambda x:x*10))
print(df.apply(np.mean))

五、Pandas的基本功能

数据索引：

Series和DataFrame的索引是Index类型，Index对象是不可修改，可通过索引值或索引标签获取目标数据，也可通过索引使序列或数据框的计算、操作实现自动化对齐。索引类型index的常用方法：

• .append(idx)：连接另一个Index对象，产生新的Index对象
• .diff(idx)：计算差集，产生新的Index对象
• .intersection(idx)：计算交集
• .union(idx)：计算并集
• .delete(loc)：删除loc位置处的元素
• .insert(loc,e)：在loc位置增加一个元素

  重置索引：

  重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

  重置行列标签

  df.reindex(index, columns ,fill_value, method, limit, copy )：

index/columns为新的行列自定义索引；fill_value为用于填充缺失位置的值；method为填充方法，ffill当前值向前填充，bfill向后填充；limit为最大填充量；copy 默认True，生成新的对象，False时，新旧相等不复制。

import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
   'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   'x': np.linspace(0,stop=N-1,num=N),
   'y': np.random.rand(N),
   'C': np.random.choice(['Low','Medium','High'],N).tolist(),
   'D': np.random.normal(100, 10, size=(N)).tolist()
})
#重置行、列索引标签
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])
print(df_reindexed)

填充元素值

reindex_like() 提供了一个可选的参数method，使用它来填充相应的元素值，参数值介绍如下：

• pad/ffill：向前填充值；
• bfill/backfill：向后填充值；
• nearest：从距离最近的索引值开始填充。

  import pandas as pd
  import numpy as np
  df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
  df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
  #使df2和df1行标签相同
  print(df2.reindex_like(df1))
  #向前填充
  print(df2.reindex_like(df1,method='ffill'))

  限制填充行数

  reindex_like() 还提供了一个额外参数 limit，该参数用来控制填充的最大行数。

  import pandas as pd
  import numpy as np
  df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
  df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
  print (df2.reindex_like(df1))
  #最多填充2行
  print (df2.reindex_like(df1,method='ffill',limit=2))

  重命名标签

  rename() 方法允许您使用某些映射(dict或Series)或任意函数来对行、列标签重新命名，

  import pandas as pd
  import numpy as np
  df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
  print (df1)
  #对行和列重新命名
  print (df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},index = {0 : 'apple', 1 : 'banana', 2 : 'durian'}))

  rename() 方法提供了一个 inplace 参数，默认值为 False，表示拷贝一份原数据，并在复制后的数据上做重命名操作。若 inplace=True 则表示在原数据的基础上重命名。

  删除指定索引：

  默认返回的是一个新对象。
  .drop()：能够删除Series和DataFrame指定行或列索引。删除一行或者一列时，用单引号指定索引，删除多行时用列表指定索引。如果删除的是列索引，需要增加axis=1或axis=’columns’作为参数。增加inplace=True作为参数，可以就地修改对象，不会返回新的对象。

  索引、选取和过滤

  
  df.loc[行标签，列标签]：通过标签查询指定的数据，第一个值为行标签，第二值为列标签。当第二个参数为空时，查询的是单个或多个行的所有列。如果查询多个行、列的话，则两个参数用列表表示。
  df.iloc[行位置，列位置]：通过默认生成的数字索引查询指定的数据。
  

  遍历，排序，去重

  遍历

  ```python

  for

  N=20 df = pd.DataFrame({ ‘A’: pd.date_range(start=’2016-01-01’,periods=N,freq=’D’), ‘x’: np.linspace(0,stop=N-1,num=N), ‘y’: np.random.rand(N), ‘C’: np.random.choice([‘Low’,’Medium’,’High’],N).tolist(), ‘D’: np.random.normal(100, 10, size=(N)).tolist() }) print(df) for col in df: print (col)

内置迭代方法

如果想要遍历 DataFrame 的每一行，我们下列函数：

1) iteritems()：以键值对 (key,value) 的形式遍历；

2) iterrows()：以 (row_index,row) 的形式遍历行;

3) itertuples()：使用已命名元组的方式对行遍历。

for key,value in df.iteritems(): print (key,value)

for row_index,row in df.iterrows(): print (row_index,row)

for row in df.itertuples(): print(row)

<a name="AUR4T"></a>
### 排序
Pands 提供了两种排序方法，分别是按标签排序和按数值排序。
```python
# 行标签乱序排列，列标签乱序排列
unsorted_df = pd.DataFrame(np.random.randn(10, 2), index=[1, 6, 4, 2, 3, 5, 9, 8, 0, 7], columns=['col2', 'col1'])
print(unsorted_df)
# sort_index() 方法对行标签排序，指定轴参数（axis）
# 或者排序顺序。或者可以对 DataFrame 进行排序。默认情况下，按照行标签序排序。
sorted_df = unsorted_df.sort_index()
print(sorted_df)
# 1) 排序顺序
# 通过将布尔值传递给ascending参数，可以控制排序的顺序（行号顺序）
sorted_df = unsorted_df.sort_index(ascending=False)
print(sorted_df)
# 按列标签排序
# 通过给 axis 轴参数传递 0 或 1，可以对列标签进行排序。默认情况下，axis=0 表示按行排序；而 axis=1 则表示按列排序。
sorted_df = unsorted_df.sort_index(axis=1)
print(sorted_df)
# 按值排序
# 与标签排序类似，sort_values() 表示按值排序。它接受一个by参数，该参数值是要排序数列的  DataFrame 列名。
sorted_df = unsorted_df.sort_values(by=['col1', 'col2'])
print(sorted_df)

排序算法

sort_values() 提供了参数kind用来指定排序算法。这里有三种排序算法：

• mergesort
• heapsort
• quicksort

默认为 quicksort(快速排序) ，其中 Mergesort 归并排序是最稳定的算法。

import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')
print (sorted_df)

去重

函数格式

drop_duplicates()函数的语法格式如下：

df.drop_duplicates(subset=['A','B','C'],keep='first',inplace=True)

参数说明如下：

• subset：表示要进去重的列名，默认为 None。
• keep：有三个可选参数，分别是 first、last、False，默认为 first，表示只保留第一次出现的重复项，删除其余重复项，last 表示只保留最后一次出现的重复项，False 则表示删除所有重复项。
• inplace：布尔值参数，默认为 False 表示删除重复项后返回一个副本，若为 Ture 则表示直接在原数据上删除重复项。 ```python

  1) 默认保留第一次出现的重复项

import pandas as pd

data = {

'A': [1, 0, 1, 1],
'B': [0, 2, 5, 0],
'C': [4, 0, 4, 4],
'D': [1, 0, 1, 1]

} df = pd.DataFrame(data=data)

默认保留第一次出现的重复项

df.drop_duplicates()

2) keep=False删除所有重复项

df.drop_duplicates(keep=False)

3) 根据指定列标签去重

去除所有重复项，对于B列来说两个0是重复项

df.drop_duplicates(subset=[‘B’], keep=False)

简写，省去subset参数

df.drop_duplicates([‘B’],keep=False)

print(df)

4) 指定多列同时去重

last只保留最后一个重复项

df.drop_duplicates([‘Age’, ‘Group ID’], keep=’last’) ```

Pandas处理字符串

常用的字符串处理函数如下表所示：

注意：上述所有字符串函数全部适用于 DataFrame 对象，同时也可以与 Python 内置的字符串函数一起使用，这些函数在处理 Series/DataFrame 对象的时候会自动忽略缺失值数据（NaN）。

算术运算

Pandas数据分析

统计分析、相关分析

适用于Series和DataFrame的基本统计分析函数：传入axis=’columns’或axis=1将会按行进行运算。
.describe()：针对各列的多个统计汇总，用统计学指标快速描述数据的概要。
.sum()：计算各列数据的和
.count()：非NaN值的数量
.mean( )/.median()：计算数据的算术平均值、算术中位数
.var()/.std()：计算数据的方差、标准差
.corr()/.cov()：计算相关系数矩阵、协方差矩阵，是通过参数对计算出来的。Series的corr方法用于计算两个Series中重叠的、非NA的、按索引对齐的值的相关系数。DataFrame的corr和cov方法将以DataFrame的形式分别返回完整的相关系数或协方差矩阵。
.corrwith()：利用DataFrame的corrwith方法，可以计算其列或行跟另一个Series或DataFrame之间的相关系数。传入一个Series将会返回一个相关系数值Series（针对各列进行计算），传入一个DataFrame则会计算按列名配对的相关系数。
.min()/.max()：计算数据的最小值、最大值
.diff()：计算一阶差分，对时间序列很有效
.mode()：计算众数，返回频数最高的那（几）个
.mean()：计算均值
.quantile()：计算分位数（0到1）
.isin()：用于判断矢量化集合的成员资格，可用于过滤Series中或DataFrame列中数据的子集
适用于Series的基本统计分析函数，DataFrame[列名]返回的是一个Series类型。
.unique()：返回一个Series中的唯一值组成的数组。
.value_counts()：计算一个Series中各值出现的频率。
.argmin()/.argmax()：计算数据最大值、最小值所在位置的索引位置（自动索引）
.idxmin()/.idxmax()：计算数据最大值、最小值所在位置的索引（自定义索引）

分组

• DataFrame.groupby()：分组函数，使用方法参考https://blog.csdn.net/cymy001/article/details/78300900
• pandas.cut()：根据数据分析对象的特征，按照一定的数值指标，把数据分析对象划分为不同的区间部分来进行研究，以揭示其内在的联系和规律性。类似给成绩设定优良中差，比如：0-59分为差，60-70分为中，71-80分为优秀等等。使用方法参考
  https://blog.csdn.net/weixin_39541558/article/details/80578529
  https://blog.csdn.net/missyougoon/article/details/83986511

  Pandas读写文本格式的数据

  pandas提供了一些用于将表格型数据读取为DataFrame对象的函数。下表对它们进行了总结，其中read_csv()、read_table()、to_csv()是用得最多的。
  

Pandas执行SQL操作

参考

Pandas缺失值处理

在许多数据分析工作中，缺失数据是经常发生的。对于数值数据，pandas使用浮点值NaN（np.nan）表示缺失数据，也可将缺失值表示为NA（Python内置的None值）。

• .info()：查看数据的信息，包括每个字段的名称、非空数量、字段的数据类型。
• .isnull()：返回一个同样长度的值为布尔型的对象（Series或DataFrame），表示哪些值是缺失的，.notnull()为其否定形式。

.dropna()：删除缺失数据。对于Series对象，dropna返回一个仅含非空数据和索引值的Series。对于DataFrame对象，dropna默认删除含有缺失值的行；如果想删除含有缺失值的列，需传入axis = 1作为参数；如果想删除全部为缺失值的行或者列，需传入how=’all’作为参数；如果想留下一部分缺失数据，需传入thresh = n作为参数，表示每行至少n个非NA值。
.fillna(value,method,limit,inplace)：填充缺失值。value为用于填充的值（比如0、’a’等）或者是字典（比如{‘列’:1,’列’:8,……}为指定列的缺失数据填充值）；method默认值为ffill，向前填充，bfill为向后填充；limit为向前或者向后填充的最大填充量。inplace默认会返回新对象，修改为inplace=True可以对现有对象进行就地修改。
参考文档