一、DataFrame简介

DataFrame是一个带有索引的二维数据结构，每列可以有自己的名字，并且可以有不同的数据类型。你可以把它想象成一个excel表格或者数据库中的一张表，DataFrame是最常用的Pandas对象。如下图所示：

Pandas中的DataFrame可以使用下列函数构建：

import pandas as pd
pd.DataFrame(data=None, index:Union[Collection, NoneType]=None, \
             columns:Union[Collection, NoneType]=None,\
             dtype:Union[str, numpy.dtype, _ForwardRef('ExtensionDtype'),\
                         NoneType]=None, copy:bool=False)

参数	说明	是否必要
data	ndarray（结构化或同类），可迭代，dict或DataFrame、Dict可以包含Series，数组，常量或类似列表的对象	必要
index	设置行标签，如果未提供列标签，则为(0,1,2,…,n)，长度必须与行长度一致	非必要
columns	设置列标签，如果未提供列标签，则为(0,1,2,…,n)，长度必须与列长度一致	非必要
dtype	每列的数据类型，如果没有，则推断	非必要
copy	默认为False，从输入中复制数据。	非必要

二、创建DataFrame

2.1 创建空DataFrame

import pandas as pd
pd.DataFrame()

2.2 列表创建DataFrame

import pandas as pd
lst = [1,2,3]
pd.Series(lst)

0    1
1    2
2    3
dtype: int64

import pandas as pd
lst = [1,2,3]
# 有点类似于Series
pd.DataFrame(lst)

	0
0	1
1	2
2	3

import pandas as pd
lst = [[1,2,3],[2,3,4]]
pd.DataFrame(lst)

	0	1	2
0	1	2	3
1	2	3	4

# 列表内的元素不等时自动为NaN
lst = [[1,2,3],[2,3,4,5]]
pd.DataFrame(lst)

	0	1	2	3
0	1	2	3	NaN
1	2	3	4	5.0

2.3 字典创建DataFrame

import pandas as pd
dic = {"a":1,"b":2}
# pd.DataFrame(data=dic)
# 这种方式是不行的，因为Data必须死类似列表的数据

import pandas as pd
data = {'Name':['小明', '小猪', '蘑菇头', '毛台'],'Age':[18,34,29,22]}
pd.DataFrame(data)

	Name	Age
0	小明	18
1	小猪	34
2	蘑菇头	29
3	毛台	22

# 字典里面的元组也可以，因为也类似于列表对象
import pandas as pd
data = {'Name':('小明', '小猪', '蘑菇头', '毛台'),'Age':[18,34,29,22]}
pd.DataFrame(data)

	Name	Age
0	小明	18
1	小猪	34
2	蘑菇头	29
3	毛台	22

Series字典创建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'])}
pd.DataFrame(d) 
# 自动根据行列索引将数据对齐，缺少的为NaN

	one	two
a	1.0	1
b	2.0	2
c	3.0	3
d	NaN	4

2.4 二维数组创建DataFrame

这里仅仅只有二维数组（矩阵）能够创建出DataFrame，其余都不可。【NumPy数组学习参考】

import numpy as np
import pandas as pd
x = np.arange(15).reshape(5,3)
pd.DataFrame(x,index=["a","b","c","d","e"],columns=["A","B","C"])
# 注意行列标签的长度一定要与行列长度一致，否则出错

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

三、DataFrame的增删改查

本节引例

import numpy as np
import pandas as pd
x = np.arange(15).reshape(5,3)
df = pd.DataFrame(x,index=["a","b","c","d","e"],columns=["A","B","C"])
df

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

3.1 DataFrame的增

3.1.1 行增加

利用append方法将它们拼接起来，注意参数中的ignore_index=True，如果不把这个参数设为True，新排的数据块索引不会重新排列。

df111 = df.copy()
a = df111[:2] # 前两行
b = df111[2:] # 后面三行
a.append(b,ignore_index=True)

	A	B	C
0	0	1	2
1	3	4	5
2	6	7	8
3	9	10	11
4	12	13	14

用.concat()的方法来进行拼接，与append类似

pd.concat([a,b],ignore_index=True)

	A	B	C
0	0	1	2
1	3	4	5
2	6	7	8
3	9	10	11
4	12	13	14

loc法

# 注意行元素个数一定要相同，否则出错,增加在末尾
df112 = df.copy()
df112.loc["f"] = list(range(3))# 新增不同元素
df112.loc["g"] = 3 # 新增相同元素
df112

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14
f	0	1	2
g	3	3	3

若需指定行位置添加，可以通过DataFrame.T先将其行列互换，添加后再次转置回来即可。

3.1.2 列增加

新增空白列，注意空白不是缺失值，NaN才是缺失值

df121 = df.copy()
df121["C"] = ""
df121

	A	B
a	0	1
b	3	4
c	6	7
d	9	10
e	12	13

只能在末尾新增，同时可创建列索引

df122 = df.copy()
df122["D"] = 3 # 新增相同原素
df122["E"] = list(range(len(df4))) # 新增不同元素(长度一定要相同)
df122

	A	B	C	D	E
a	0	1	2	3	0
b	3	4	5	3	1
c	6	7	8	3	2
d	9	10	11	3	3
e	12	13	14	3	4

如果需要在指定的位置添加新的一列，用insert( )函数

df.insert(loc, column, value, allow_duplicates=False)

参数	说明
loc	插入索引(int型)。 0 <= loc <= len（columns）
column	str，数字或可哈希对象，插入列的标签。
value	int,Series或类似数组的值
allow_duplicates	布尔值，可选

df123 = df.copy().T
df123.insert(2,"D","")
df123.T

	A	B	C
a	0	1	2
b	3	4	5
D
c	6	7	8
d	9	10	11
e	12	13	14

3.2 DataFrame的删

DataFrame.drop(labels=None,axis=0, index=None, columns=None, inplace=False)

参数	说明
labels	就是要删除的行列的名字，用列表给定
axis	默认为0，指删除行，因此删除columns时要指定axis=1
index	直接指定要删除的行
columns	直接指定要删除的列
inplace=False	默认该删除操作不改变原数据，而是返回一个执行删除操作后的dataframe
inplace=True	则会直接在原数据上进行删除操作，删除后无法返回

df.pop(item) # item 要弹出的列的标签。

3.2.1 行删除

根据行索引，指定位置删除行

# axis为0表示删除行。inplace为True表示直接对原表修改。
df211 = df.copy()
df211.drop("a",axis=0,inplace=True)
df211

	A	B	C
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

df211.drop(["b","c"])

	A	B	C
d	9	10	11
e	12	13	14

3.2.2 列删除

根据列索引，指定位置删除列

# axis为1表示删除列,inplace为True表示直接对原表修改。
df221 = df.copy()
df221.drop("A",axis=1,inplace=True)
df221

	B	C
a	1	2
b	4	5
c	7	8
d	10	11
e	13	14

pop法

df222 = df.copy()
df222.pop("A")
df222

	B	C
a	1	2
b	4	5
c	7	8
d	10	11
e	13	14

del法

del df222["B"]
df222

	C
a	2
b	5
c	8
d	11
e	14

3.3 DataFrame的改

3.3.1 根据索引更改行

df31 = df.copy()
df31.loc["a"] = "" # 更改行
df31

	A	B	C
a
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

3.3.2 根据索引更改列

df32 = df.copy()
df32["A"] = ""
df32

	B	C
a	1	2
b	4	5
c	7	8
d	10	11
e	13	14

3.3.3 通过行列索引更改指定位置元素

df33 = df.copy()
df33.loc["a"]["A"] = 2
df33.iloc[0,2] = "a"
df33

	A	B	C
a	2	1	a
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

3.4 DataFrame的查

3.4.1 查看行

获取某一行，或者多行行

df41 = df.copy()
df41[2:3]

	A	B	C
c	6	7	8

df41[:3]

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8

获取某行或某几行

df41.loc["a"] # 按index选取行

A    0
B    1
C    2
Name: a, dtype: int32

df41.loc["a":"c"] # 选取index "a"到“c”的行

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8

df41.iloc[1:2,:]

	A	B	C
b	3	4	5

获取指定位置元素

df41.loc["a"]["A"] # 根据索引查看指定位置元素

df41.iloc[0,2] # 查看第一行第三列的元素

df41.at["a","B"]

df41.iat[1,2] # 查看第二行第三列的元素

获取指定位置多个元素

df41.iloc[0:3,1:3]

	B	C
a	1	2
b	4	5
c	7	8

查看前n行

df41.head(2)

	A	B	C
a	0	1	2
b	3	4	5

查看后n行

df41.tail(2)

	A	B	C
d	9	10	11
e	12	13	14

3.4.2 查看列

df42 = df.copy()
df42[["A"]]

	A
a	0
b	3
c	6
d	9
e	12

df42[["A","B"]]

	A	B
a	0	1
b	3	4
c	6	7
d	9	10
e	12	13

df42.iloc[:,1:3]

	B	C
a	1	2
b	4	5
c	7	8
d	10	11
e	13	14

get访问列（结果为一个Series）

df42.get("B")

a     1
b     4
c     7
d    10
e    13
Name: B, dtype: int32

# 从Series 中继续访问
df42.get("B").get("a")

通过属性访问，结果也是Series

df42.A

a     0
b     3
c     6
d     9
e    12
Name: A, dtype: int32

# 从Series 中继续访问
df42.A.a

df42.A[:2] # 访问前两行

a    0
b    3
Name: A, dtype: int32

df42[:2] # 获取整个DataFrame的前两行

	A	B	C
a	0	1	2
b	3	4	5

# 对DataFrame行列位置互换，相当于矩阵转置
df42.T

	a	b	c	d	e
A	0	3	6	9	12
B	1	4	7	10	13
C	2	5	8	11	14

# 对所有信息进行反转
df42[::-1]

	A	B	C
e	12	13	14
d	9	10	11
c	6	7	8
b	3	4	5
a	0	1	2

四、DataFrame的统计相关操作

import numpy as np
import pandas as pd
x = np.arange(15).reshape(5,3)
df = pd.DataFrame(x,index=["a","b","c","d","e"],columns=["A","B","C"])
df

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

查看基本信息情况

df.info()

<class 'pandas.core.frame.DataFrame'>
Index: 5 entries, a to e
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   A       5 non-null      int32
 1   B       5 non-null      int32
 2   C       5 non-null      int32
dtypes: int32(3)
memory usage: 100.0+ bytes

查看列索引信息

df.columns

Index(['A', 'B', 'C'], dtype='object')

查看行索引信息

df.index

Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

获取列表的值，结果为二维数组

df.values

array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11],
       [12, 13, 14]])

查看各列的统计值（纯数据）

df.describe()

	A	B	C
count	5.000000	5.000000	5.000000
mean	6.000000	7.000000	8.000000
std	4.743416	4.743416	4.743416
min	0.000000	1.000000	2.000000
25%	3.000000	4.000000	5.000000
50%	6.000000	7.000000	8.000000
75%	9.000000	10.000000	11.000000
max	12.000000	13.000000	14.000000

查看每列的数据数目有多少个

df.count()

A    5
B    5
C    5
dtype: int64

查看各列的平均值

df.mean()

A    6.0
B    7.0
C    8.0
dtype: float64

各列最大值

df.max()

A    12
B    13
C    14
dtype: int32

各列最小值

df.min()

A    0
B    1
C    2
dtype: int32

按列统计表中的空值的数量

df.isnull().sum()

A    0
B    0
C    0
dtype: int64

按列统计表中大于10的元素个数

df.where(df>10).count()

A    1
B    1
C    2
dtype: int64

根据列名A属性进行分组，统计每一组的分布情况

df.groupby("A").count()

	B	C
A
0	1	1
3	1	1
6	1	1
9	1	1
12	1	1

筛选出符合条件的行显示出来

df[df["A"]>3]

	A	B	C
c	6	7	8
d	9	10	11
e	12	13	14

所有行都显示，不符合条件的显示为NaN

df.where(df["B"]>3)

	A	B	C
a	NaN	NaN	NaN
b	3.0	4.0	5.0
c	6.0	7.0	8.0
d	9.0	10.0	11.0
e	12.0	13.0	14.0

行相关计算

df

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

df["A累加计算"] = df["A"] + df["A"].shift()
df

	A	B	C	A累加计算
a	0	1	2	NaN
b	3	4	5	3.0
c	6	7	8	9.0
d	9	10	11	15.0
e	12	13	14	21.0

列相关计算，都是一一对应关系

df

	A	B	C	A累加计算
a	0	1	2	NaN
b	3	4	5	3.0
c	6	7	8	9.0
d	9	10	11	15.0
e	12	13	14	21.0

df["A"] = df["C"] + df["A"]
df

	A	B	C	A累加计算
a	2	1	2	NaN
b	8	4	5	3.0
c	14	7	8	9.0
d	20	10	11	15.0
e	26	13	14	21.0

df["A"] = df["A"] * 3
df

	A	B	C	A累加计算
a	6	1	2	NaN
b	24	4	5	3.0
c	42	7	8	9.0
d	60	10	11	15.0
e	78	13	14	21.0

df["D"] = df["A"] + df["B"] +df["C"]*2
df

	A	B	C	A累加计算	D
a	6	1	2	NaN	11
b	24	4	5	3.0	38
c	42	7	8	9.0	65
d	60	10	11	15.0	92
e	78	13	14	21.0	119

import numpy as np
import pandas as pd
x = np.arange(15).reshape(5,3)
df = pd.DataFrame(x,index=["a","b","c","d","e"],columns=["A","B","C"])
df

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

值的算术中值(中位数)

df.median()

A    6.0
B    7.0
C    8.0
dtype: float64

贝塞尔修正样本标准差

df.std()

A    4.743416
B    4.743416
C    4.743416
dtype: float64

无偏方差

df.var()

A    22.5
B    22.5
C    22.5
dtype: float64

无偏协方差（二元）

df.cov()

	A	B	C
A	22.5	22.5	22.5
B	22.5	22.5	22.5
C	22.5	22.5	22.5

样品偏斜度（三阶矩）

df.skew()

A    0.0
B    0.0
C    0.0
dtype: float64

样品峰度（四阶矩）

df.kurt()

A   -1.2
B   -1.2
C   -1.2
dtype: float64

样本分位数（百分位上的值）

df.quantile(0.75)

A     9.0
B    10.0
C    11.0
Name: 0.75, dtype: float64

相关性计算，计算相关性时用到的方法有：

pearson：标准相关系数（默认）

kendall：Kendall Tau相关系数

Spearman：Spearman等级相关

df.corr(method="pearson")

	A	B	C
A	1.0	1.0	1.0
B	1.0	1.0	1.0
C	1.0	1.0	1.0

rank 函数求出数据的排名顺序，排序方法有：

average：组的平均排名

min：该组中的最低排名

max：该组中最高的排名

first：按排列顺序出现在数组中

dense：类似于“最小”，但组之间的排名始终增加1

df

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

df.B.c = 33
df.B.a = 25
df.B.rank(method="min")

a    4.0
b    1.0
c    5.0
d    2.0
e    3.0
Name: B, dtype: float64

有时需要对不同窗口的中数据进行一个统计，通过 rolling 我们可以实现，设置 window=2 来保证窗口长度为 2，设置 on=“A” 来保证这一列来滑动窗口（默认不设置，表示根据索引来欢动）。有些结果是缺失值，导致这个结果的原因是因为在计算时，窗口中默认需要的最小数据个数与窗口长度一致，这里可以设置 min_periods=1 来修改下。

df

	A	B	C
a	0	1	2
b	3	4	5
c	6	7	8
d	9	10	11
e	12	13	14

df.rolling(window=2, on="A").sum() # 计算累加 ，A不计算

	A	B	C
a	0	NaN	NaN
b	3	5.0	7.0
c	6	11.0	13.0
d	9	17.0	19.0
e	12	23.0	25.0

df.rolling(window=2, on="A",min_periods=1).sum() # 计算累加 ，A不计算

	A	B	C
a	0	1.0	2.0
b	3	5.0	7.0
c	6	11.0	13.0
d	9	17.0	19.0
e	12	23.0	25.0

df.expanding(min_periods=1)["A","B"].sum() # 计算累加

	A	B
a	0.0	1.0
b	3.0	5.0
c	9.0	12.0
d	18.0	22.0
e	30.0	35.0

上面的方式只能生成一个结果，有时候想要同时求出多个结果（如求和与均值），则可利用agg方法：

df.rolling(window=2, min_periods=1)["A"].agg([np.sum, np.mean,np.std]) # 计算累加、均值和标准差

	sum	mean	std
a	0.0	0.0	NaN
b	3.0	1.5	2.12132
c	9.0	4.5	2.12132
d	15.0	7.5	2.12132
e	21.0	10.5	2.12132

# 如果传入一个字典，可以为生成的统计结果重命名
df.rolling(window=2, min_periods=1)["A"].agg({"A_sum":np.sum,"A_mean":np.mean,"A_std":np.std})

	A_sum	A_mean	A_std
a	0.0	0.0	NaN
b	3.0	1.5	2.12132
c	9.0	4.5	2.12132
d	15.0	7.5	2.12132
e	21.0	10.5	2.12132

DataFrame的基础应用

一、DataFrame简介

二、创建DataFrame

2.1 创建空DataFrame

2.2 列表创建DataFrame

2.3 字典创建DataFrame

2.4 二维数组创建DataFrame

三、DataFrame的增删改查

3.1 DataFrame的增

3.1.1 行增加

3.1.2 列增加

3.2 DataFrame的删

3.2.1 行删除

3.2.2 列删除

3.3 DataFrame的改

3.3.1 根据索引更改行

3.3.2 根据索引更改列

3.3.3 通过行列索引更改指定位置元素

3.4 DataFrame的查

3.4.1 查看行

3.4.2 查看列

四、DataFrame的统计相关操作

测试人员都是画画大神，让我看看谁还不会用代码图？

GIS實驗之房價數據可視化分析

GIS實驗之加權泰森多邊形的應用

Python爬蟲實戰練習（疫情數據獲取）

DataFrame的基礎應用

DataFrame的索引操作以及拼接與關聯

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結