大数据应用——pandas基础教程

标签：11 10 基础教程 df NaN 索引 应用 print pandas

目录

pandas数据结构
Series结构如下
创建Series对象
获取数据
DataFrame结构
创建DataFrame对象
DataFrame使用
读取数据
数据查看
索引操作
基础索引
loc 索引和 iloc 索引
重置索引
rename 函数
赋值修改索引
索引排序
多重索引
嵌套列表创造多重索引
MultiIndex类
MultiIndex.from_tuples()：将元组列表转化为MultiIndex
MultiIndex.from_arrays()：将数组列表转化为MultiIndex
多重索引查看数据
交换分层顺序
排序分层
数据清洗
处理空值
isnull()检查空值
notnull()函数
dropna()删除空值
fiilna()填充空值
ffill()函数
bfill()函数
重复值的处理
duplicated
drop_duplicates
异常值的处理
更改数据类型
数据合并
merge()主键合并数据
join() 根据行索引合并数据
combine_first()合并重叠数据
旋转数据
groupby()分组聚合
数据分组
按列分组
用Series对象分组
用函数分组
数据聚合
用内置函数聚合函数
agg()面向列的聚合
对每一列数据用同一个函数
用多种函数聚合数据
对不同列使用不同的函数
apply()函数
指定某个元素的个别操作
查看某列符条件的值
删除某列符条件的值
修改某列的某个数值

---

pandas数据结构

Series结构如下

Series 类似于一维数组的对象，可以保存任何类型的数据，由一组数据和相关的索引两部分组成

• Series结构如下

index（索引）	element（数据）
0	1
1	2
2	3
3	4
4	5

---

创建Series对象

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

• data ：传入的数据
• index： 索引，必须是唯一的，且数据长度相同，如没有传入则默认生成从0~N的整数索引
• dtype ：数据的类型
• cope：是否复制数据，默认为False

---

创建对象

# 生成数据
print(pandas.Series([1,2,3,4,5]))
# 运行返回：（左列为索引，右列为数据）
	0	1
	1 	2 
	2 	3 
	3 	4
	4 	5

添加索引

# 添加索引
print(pd.Series(data=['a','b','c','d','e'],index=[1,2,3,4,5]))
# 运行返回：（左列为索引，右列为数据）
	a    1
	b    2
	c    3
	d    4
	e    5

使用字典（dict）生成数组

# 键为索引，值为数据
print(pd.Series({'a':1,'b':2,'c':3,'d':4,'e':5}))
# 运行返回：（左列为索引，右列为数据）
	a    1
	b    2
	c    3
	d    4
	e    5

---

获取数据

index获取索引 和 values获取数据

sr = pd.Series({'a':1,'b':2,'c':3,'d':4,'e':5})

# 获取索引
print(sr.index)
# 运行返回：
	Index(['a', 'b', 'c', 'd', 'e'], dtype='object')


# 获取数据
print(sr.values)
# 运行返回：
	[1 2 3 4 5]

索引数据

sr = pd.Series({'a':1,'b':2,'c':3,'d':4,'e':5})

# 按照索引名索引
print(sr['a'])
# 运行返回：
	1

# 按位置索引
print(sr[3])
# 运行返回：
	4

---

DataFrame

• DataFrame是一个类似于二维数组或表格的对象，由索引和数据组成，于Series不同的是DataFrame有行索引和列索引。

创建DataFrame对象

pandas.DataFrame(data=None,index=None,columns=None)

• data ：传入的数据
• index：行标签，如没有传入则默认生成从0~N的整数索引
• columns：列表签，如没有传入则默认生成从0~N的整数索引

---

列表创建

print(pandas.DataFrame([['a','b','c'],['d','e','f']['g','h','i']]))
# 运行返回:
   0  1  2
0  a  b  c
1  d  e  f
2  g  h  i

字典创建：

print(pd.DataFrame({"a":[1,2,3],"b":[4,5,6],"c":[7,8,9]})
# 运行返回：
	a	b	c
	1	4	7
	2	5	8
	3	6	9

指定索引

# columns 指定列索引
print(pd.DataFrame([['a','b','c'],['d','e','f']],columns=['No1','No2','No3']))
# 运行返回：
  No1 No2 No3
0   a   b   c
1   d   e   f


# 指定行索引
print(pd.DataFrame([['a','b','c'],['d','e','f']],index=['No1','No2']))
# 运行返回：
     0  1  2
No1  a  b  c
No2  d  e  f

---

DataFrame使用

读取数据

导入库

# as 是给pandas起别名方便后续使用
 import pandas as pd

导入数据：

# xxx为文件路径
df = pd.read_csv(r"xxx")	## 导入csv 文件
df = pd .read_excel(r"xxx")	## 导入excel 文件

导出数据：

# df 为要导出的数据 
# xxx为文件路径
df . to_csv ("xxx")	 ## 导出为csv 文件
df .to_excel ("xxx") ##  导出为excel 文件

有时候会报错是因为编码格式的问题，主要的编码格式有 “utf-8” ，“gbk”。
在导入的时候加上encoding=“编码格式”
如：pd.read_csv(r"xxx"，encoding=“gbk”)

---

数据查看

维度查看：

# 维度查看
df.shape

每一列数据的格式：

# 每一列数据的格式：
df.dtypes

某一列格式：

# 某一列格式：
df['B'].dtype

查看某一列的唯一值

# 查看某一列的唯一值：
df['B'].unique()

查看数据表的值：

# 查看数据表的值：
df.values 

查看数据表的行索引：

# 查看数据表的行索引：
df.index

查看列索引：

# 查看列索引：
df.columns

查看前5行数据、后5行数据：

# 查看前5行数据、后5行数据：
# 括号内加参数，查看指定数量
df.head() 	#默认前5行数据
df.tail()   #默认后5行数据

---

索引操作

基础索引

# 创建数组
df = pd.DataFrame([[1,2,3,4,5,6],[7,8,9,10,11,12],[13,14,15,16,17,18]],columns=['a','b','c','d','e','f'])

print(df)
# 运行返回：
    a   b   c   d   e   f
0   1   2   3   4   5   6
1   7   8   9  10  11  12
2  13  14  15  16  17  18


# 获取b列数据
print(df["b"])
# 运行返回：# b列数据
0     2
1     8
2    14

     
#  获取不连续的Series对象
print(df[["b","d"]])	# 注意是两个“[[]]”
# 运行返回：
    b   d
0   2   4
1   8  10
2  14  16


# 使用切片获取数据
# 获取前两行的数据
print(df[:2])
# 运行返回：
   a  b  c   d   e   f
0  1  2  3   4   5   6
1  7  8  9  10  11  12


# 综合使用
# 先通过切片获取前两行数据
# 再通过不连续索引获取b，d列的数据
print(df[:2][['b','d']])	# 注意是两个“[[]]”
# 运行返回：
   b   d
0  2   4
1  8  10

---

loc索引 和 iloc索引

• loc标签索引 和 iloc位置索引

# 创建数组
df = pd.DataFrame([[1,2,3,4,5,6],[7,8,9,10,11,12]],columns=['a','b','c','d','e','f'])

print(df)
# 运行返回：
   a  b  c   d   e   f
0  1  2  3   4   5   6
1  7  8  9  10  11  12


# loc 标签索引
print(df.loc[:,["a","c"]])

# iloc 位置索引
print(df.iloc:,[0,2])

# 上述两种方式运行返回相同：
   a  c
0  1  3
1  7  9

---

重置索引

rename 函数

• 用字典更改索引

df = pd.DataFrame([[1,2,3,4,5,6],[7,8,9,10,11,12]],columns=['a','b','c','d','e','f'])


print(df)
# 运行返回：
   a  b  c   d   e   f
0  1  2  3   4   5   6
1  7  8  9  10  11  12


# 可添加 inplace=True 参数，更改源数据
print(df.rename(index={0:'A',1:'B'}))
# 运行返回：
   a  b  c   d   e   f
A  1  2  3   4   5   6
B  7  8  9  10  11  12


# 可添加 inplace=True 参数，更改源数据
print(df.rename(columns={'a':1,'b':2,'c':3,'d':4,'e':5,'f':6}))
# 运行返回：
   1  2  3   4   5   6
0  1  2  3   4   5   6
1  7  8  9  10  11  12

---

赋值修改索引

• 给列索引，行索引赋值来修改索引

df = pd.DataFrame([[1,2,3,4,5,6],[7,8,9,10,11,12]],columns=['a','b','c','d','e','f'])


print(df)
# 运行返回;
   a  b  c   d   e   f
0  1  2  3   4   5   6
1  7  8  9  10  11  12


# 给 index 赋值
df.index = ["A", "B"]
print(df)
# 运行返回：
   a  b  c   d   e   f
A  1  2  3   4   5   6
B  7  8  9  10  11  12


# 给 columns 赋值
df.columns = [1,2,3,4,5,6]
# 运行返回：
   1  2  3   4   5   6
0  1  2  3   4   5   6
1  7  8  9  10  11  12

---

索引排序

df = pd.DataFrame([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20]],index=[4,2,3,1])


print(df)
# 运行返回：
    0   1   2   3   4
4   1   2   3   4   5
2   6   7   8   9  10
3  11  12  13  14  15
1  16  17  18  19  20


# ascending 参数是否为升序
print(df.sort_index(ascending=True))
# 运行返回：
    0   1   2   3   4
1  16  17  18  19  20
2   6   7   8   9  10
3  11  12  13  14  15
4   1   2   3   4   5


# ascending=False 降序排列
print(df.sort_index(ascending=False))
# 运行返回：
    0   1   2   3   4
4   1   2   3   4   5
3  11  12  13  14  15
2   6   7   8   9  10
1  16  17  18  19  20

---

多重索引

嵌套列表创造多重索引

# 创建表
# 注意必须保持列表长度一致
df = pd.DataFrame(
    [[1,2],[3,4],[5,6],[7,8],[9,10],[11,12],[13,14],[15,16],[17,18]],
    index=[["A","A","A","B","B","B","c","c","c"],['a','b','c','d','e','f','g','h','i']]
)


print(df)
# 运行返回：
      0   1
A a   1   2
  b   3   4
  c   5   6
B d   7   8
  e   9  10
  f  11  12
c g  13  14
  h  15  16
  i  17  18


print(df.loc["A"])
# 运行返回：
   0  1
a  1  2
b  3  4
c  5  6

---

MultiIndex类

导入库
from pandas import MultiIndex

• MultiIndex.from_tuples()：将元组列表转化为MultiIndex
• MultiIndex.from_arrays()：将数组列表转化为MultiIndex
• MultiIndex.from_product()：从多个集合的笛卡乘积中创建一个MultiIndex

MultiIndex.from_tuples()：将元组列表转化为MultiIndex

import pandas as pd
from pandas import MultiIndex

# 先创建一个MultiIndex对象
mul_index = MultiIndex.from_tuples(
	# 元组的第一个元素是外层索引，第二个元素是内层索引
    tuples=[('A','a1'),('A','a2'),('B','b1'),('B','b2')],
    # names传入列表，表示两层索引的名称。 
    names=["外层索引","内层索引"]
)

# 再创建个DataFrame，把刚创建的MultiIndex对象传给index。
df = pd.DataFrame([[1,1,1,1],[2,2,2,2],[3,3,3,3],[4,4,4,4]],index=mul_index)


print(df)
# 运行返回：
           0  1  2  3
外层索引 内层索引
A    a1    1  1  1  1
     a2    2  2  2  2
B    b1    3  3  3  3
     b2    4  4  4  4

MultiIndex.from_arrays()：将数组列表转化为MultiIndex

import pandas as pd
from pandas import MultiIndex

df = MultiIndex.from_arrays(
	# arrays传入一个嵌套列表，表示多重轴索引。
	# 第一个列表是外层索引，第二个是内层索引。
    arrays=[['A','A','B','B']，['a1','a2','b1','b2']],
    # names传入列表，表示两层索引的名称。 
    names=["外层索引","内层索引"]
)

df = pd.DataFrame([[1,1,1,1],[2,2,2,2],[3,3,3,3],[4,4,4,4]],index=df)

print(df)
# 运行返回：
           0  1  2  3
外层索引 内层索引
A    a1    1  1  1  1
     a2    2  2  2  2
B    b1    3  3  3  3
     b2    4  4  4  4

---

多重索引查看数据

import pandas as pd
from pandas import MultiIndex
df = MultiIndex.from_arrays(
    arrays=[['A','A','B','B'],['a1','a2','b1','b2']],
    names=["外层索引","内层索引"]
)

df = pd.DataFrame([[1,2,3,4],[5,6,7,8],[11,12,13,14],[15,16,17,18]],index=df)
print(df)
# 运行返回：
            0   1   2   3
外层索引 内层索引
A    a1     1   2   3   4        
     a2     5   6   7   8        
B    b1    11  12  13  14        
     b2    15  16  17  18 


# 用外索引查看数据
# 查看“A”的数据
print(df.loc["A"])
# 运行返回：
      0  1  2  3
内层索引
a1    1  2  3  4
a2    5  6  7  8


# 用内索引查看数据
# 查看a1的数据
print(df.loc["A","a2"])
# 或着df.loc["B"].loc["b1"]也行
# 返回的是一个Series类型的对象
# 运行返回：
0    5
1    6
2    7
3    8
Name: (A, a2), dtype: int64 

---

交换分层顺序

• swaplevel() 函数

print(df)
# 运行返回:
            0   1   2   3
外层索引 内层索引
A    a1     1   2   3   4        
     a2     5   6   7   8        
B    b1    11  12  13  14        
     b2    15  16  17  18 


print(df.swaplevel())
# 运行返回：
            0   1   2   3
内层索引 外层索引
a1   A      1   2   3   4        
a2   A      5   6   7   8        
b1   B     11  12  13  14        
b2   B     15  16  17  18 

---

排序分层

• sort_index()

df = MultiIndex.from_arrays(
    arrays=[['1','2','3','4'],['44','33','22','11']],
    names=["外层索引","内层索引"]
)

df = pd.DataFrame([[1,2,3,4],[5,6,7,8],[11,12,13,14],[15,16,17,18]],index=df)
print(df):
# 运行返回：
            0   1   2   3
外层索引 内层索引
1    44     1   2   3   4        
2    33     5   6   7   8        
3    22    11  12  13  14        
4    11    15  16  17  18   


# ascending参数True升序，Fales降序
print(df.sort_index(ascending=False))
# 运行返回：
            0   1   2   3
外层索引 内层索引
4    11    15  16  17  18        
3    22    11  12  13  14        
2    33     5   6   7   8        
1    44     1   2   3   4   

---

数据清洗

处理空值

isnull()检查空值

import pandas as pd
df = pd.DataFrame([[1,2,3,4],[4,5,None,7],[8,9,10,11]])
print(df)
# 运行返回：
   0  1     2   3
0  1  2   3.0   4
1  4  5   NaN   7
2  8  9  10.0  11


print(df.isnull())
# 运行返回：
       0      1      2      3
0  False  False  False  False
1  False  False   True  False
2  False  False  False  False

---

notnull()函数

• notnul()函数的功能与isnull()函数一样 不同点在于isnull()遇到空值返回的是False，而notnull()返回的是True。

---

dropna()删除空值

• dropna() 主要用于删除空值和缺失值的行或列。
• axis：确定过滤行或列 0或index，删除包含缺失值的行，默认为0 1或colunmns：删除包含缺失值的列
• how： 确定过滤的标准 any ：默认值，如果存在NaN值，则删除该行或该列。 all：如果所有值都是NaN，则删除改行或该列
• threshl：表示有效数据（非空值）至少要多少个才保留该列或行，否则就删除该行或列。
• subset：在的特定的列中寻找空值。
• inplace：是否修改源数据。

df = pd.DataFrame([[1,2,None,4],[4,5,None,7],[8,9,10,11]],index=['a','b','c'])
print(df)
# 运行返回：
   0  1     2   3
a  1  2   NaN   4
b  4  5   NaN   7
c  8  9  10.0  11


# 删除有空值的行
print(df.dropna(axis=0))
# 运行返回：
   0  1     2   3
c  8  9  10.0  11

# 删除用空值的列
print(df.dropna(axis=1))
# 运行返回：
   0  1   3
a  1  2   4
b  4  5   7
c  8  9  11


# 删除有效值小于2的值：
print(df.dropna(axis=1,thresh=2))
# 运行返回：
   0  1   3
a  1  2   4
b  4  5   7
c  8  9  11

---

fiilna()填充空值

• value：用来填充的数据
• limit：可以连续传播的最大数量，默认为None。

df = pd.DataFrame([[1,2,None,4],[4,5,None,7],[8,9,10,11]],index=['a','b','c'])
print(df)
# 运行返回：
   0  1     2   3
a  1  2   NaN   4
b  4  5   NaN   7
c  8  9  10.0  11


# 填充空值
print(df.fillna(value="a"))
# 运行返回：
   0  1     2   3
a  1  2     a   4
b  4  5     a   7
c  8  9  10.0  11


# 创建数组
df = pd.DataFrame([[1,2,3,4],[4,5,None,7],[8,9,10,None]],index=['a','b','c'])
print(df)
# 运行返回：
   0  1     2    3
a  1  2   3.0  4.0
b  4  5   NaN  7.0
c  8  9  10.0  NaN


# 用字典指定列填充
# 键为列标签，字典的值为要填充的值
print(df.fillna({2:10,3:20})) 
# 运行返回：
   0  1     2    3
a  1  2   3.0  4.0
b  4  5     b  7.0
c  8  9  10.0    c

---

ffill()函数

• 将前一个有效数据向后传播，填充空值

# 创建数组
df = pd.DataFrame([[1,2,3,4],[4,5,None,7],[8,9,10,None],[11,12,13,None]],index=['a','b','c','d'])
print(df)
# 运行返回：
    0   1     2    3
a   1   2   3.0  4.0
b   4   5   NaN  7.0
c   8   9  10.0  NaN
d  11  12  13.0  NaN


# 将前一个有效数据向后传播，填充空值
df = df.ffill()
# 运行返回：
    0   1     2    3
a   1   2   3.0  4.0
b   4   5   3.0  7.0
c   8   9  10.0  7.0
d  11  12  13.0  7.0

---

bfill()函数

• 将后一个有效数据向前传播，填充空值

# 创建数组
df = pd.DataFrame([[1,2,3,4],[4,5,None,7],[8,9,10,None],[11,12,13,None]],index=['a','b','c','d'])
print(df)
# 运行返回：
    0   1     2     3
a   1   2   3.0   4.0
b   4   5   NaN   7.0
c   8   9  10.0   NaN
d  11  12  13.0  14.0


# 将后一个有效数据向前传播，填充空值
print(df.dfill())
# 运行返回：
    0   1     2     3
a   1   2   3.0   4.0
b   4   5  10.0   7.0
c   8   9  10.0  14.0
d  11  12  13.0  14.0

---

重复值的处理

duplicated

• subset：用于指定识别重复的列标签，默认识别所有的列，注意：要全部列都重复才会标记。
• keep：参数
  • first：从前向后查找，除第一次以外，其余都标记为重复，默认为此选项。
  • last： 从后向前查找，除最后一次以外，其余都标记为重复。
  • False：所有相同的都标记为重复。

df = pd.DataFrame([[1,2,3,4],[1,5,8,7],[1,9,10,11],[11,12,13,14],[11,12,13,14]],index=['a','b','c','d','f'])
print(df)
# 运行返回:
    0   1   2   3
a   1   2   3   4
b   1   5   8   7
c   1   9  10  11
d  11  12  13  14
f  11  12  13  14

# 默认识别所有的列
print(df.duplicated())
# 运行返回：
a    False
b    False
c    False
d    False
f     True

# 识别指定值的重复值
print(df.duplicated(subset=0))
# 运行返回：
a    False
b     True
c     True
d    False

---

• keep

df = pd.DataFrame([[1,2,3,4],[1,5,8,7],[1,9,10,11],[11,12,13,14]],index=['a','b','c','d'])
print(df)
# 运行返回：
    0   1   2   3
a   1   2   3   4
b   1   5   8   7
c   1   9  10  11
d  11  12  13  14

# first（）
# 从前向后查找，保留第一个值
print(df.duplicated(subset=0,keep="first"))
# 运行返回：
a    False
b     True
c     True
d    False

# last（）
#  从后向前查找，保留最后值
print(df.duplicated(subset=0,keep="last"))
# 运行返回：
a     True
b     True
c    False
d    False


# False
print(df.duplicated(subset=0,keep=False))
# 运行返回：
a     True
b     True
c     True
d    False

---

drop_duplicates

• 删除重复值

• subset：用于指定识别重复的一行删除，默认识别所有的列，注意：要全部列都重复才会删除。
• keep：参数
  • first：从前向后查找，除第一次以外，其余都标记为重复，默认为此选项。
  • last： 从后向前查找，除最后一次以外，其余都标记为重复。
  • False：所有相同的都标记为重复。

# 创建数组
df = pd.DataFrame([[1,2,3,4],[1,5,8,7],[1,9,10,11],[11,12,13,14]],index=['a','b','c','d'])
print(df)
# 运行返回：
    0   1   2   3
a   1   2   3   4
b   1   5   8   7
c   1   9  10  11
d  11  12  13  14


print(df.drop_duplicates(subset=0,keep="first"))
# 运行返回：
    0   1   2   3
a   1   2   3   4
d  11  12  13  14


print(df.drop_duplicates(subset=0,keep="last"))
# 运行返回：
    0   1   2   3
c   1   9  10  11
d  11  12  13  14


print(df.drop_duplicates(subset=0,keep=False))
# 运行返回：
    0   1   2   3
d  11  12  13  14

---

异常值的处理

• 正态分布3 "3σ"法则
• μ为平均值，σ为方差
  • 数值分布在μ−σ<X<μ+σ之间的概论为68.26
  • 数值分布在μ−2σ<X<μ+2σ之间的概论为95.44
  • 数值分布在μ−3σ<X<μ+3σ}=99.74

---

更改数据类型

• dtypes函数查看数据的类型

• astyp函数强制转换数据类型
  • dtype参数：表示数据要转换成的类型
  • errors参数：转换错误的处理的方法，有 raise 或 errors 两种参数。
    • raise：碰到错误时允许发生异常，就会报错。
    • errors：就会跳过异常，保持原来数据格式，继续转换后面的数据。

df = pd.DataFrame({"a":['b',6,4,5,6,5,4,5],"b":[5,6,4,5,6,5,4,5]})

# 查看数据类型
print(df.dtypes)
# 运行返回：
a    object
b     int64


# 查看数据
print(df)
# 运行返回：
   a  b
0  b  5
1  6  6
2  4  4
3  5  5
4  6  6
5  5  5
6  4  4
7  5  5



# 将b列转换成"float64"类型
print(df["b"].astype(dtype="float64"))
# 运行返回：
0    5.0
1    6.0
2    4.0
3    5.0
4    6.0
5    5.0
6    4.0
7    5.0


# 如果将字符("a"列)转换为浮点数(“float64”)则会报错
print(df["b"].astype(dtype="float64",errors="raise"))
# 无法将字符串转换成浮点数
# ValueError: could not convert string to float: 'b'


# 将字符("a"列)转换成”float64“格式,把errors参数设置为"ignore",跳过错误。
df = df.astype(dtype="float64",errors="ignore")
print(type(df[0]))
print(type(df[1]))
# 运行返回：
<class 'str'>
<class 'int'>

---

数据合并

concat()轴向堆叠数据

• axis ：表示连接的轴向，0或1。
• join：表示连接的方式，inner为内连接，outer为外连接。
• ignore_index：接收布尔值，默认为False，True表示清除现有索引并重置索引值。
• keys：接收序列，添加最外层索引。

# 创建列表
a = pd.DataFrame({"a":[1,2,3,4,5],"b":[6,7,8,9,10]})
b = pd.DataFrame({"c":[11,12,13,14,15],"d":[16,17,18,19,20]})

# 查看数据
print(a)
print(b)
# 运行返回：
   a   b
0  1   6
1  2   7
2  3   8
3  4   9
4  5  10
    c   d
0  11  16
1  12  17
2  13  18
3  14  19
4  15  20



# axis = 0
# 表示连接的轴向，0或1
print(pd.concat([a,b],axis=0))
# 运行返回：
     a     b     c     d
0  1.0   6.0   NaN   NaN
1  2.0   7.0   NaN   NaN
2  3.0   8.0   NaN   NaN
3  4.0   9.0   NaN   NaN
4  5.0  10.0   NaN   NaN
0  NaN   NaN  11.0  16.0
1  NaN   NaN  12.0  17.0
2  NaN   NaN  13.0  18.0
3  NaN   NaN  14.0  19.0
4  NaN   NaN  15.0  20.0

# axis = 1
# 表示连接的轴向，0或1
print(pd.concat([a,b],axis=1))
# 运行返回：
   a   b   c   d
0  1   6  11  16
1  2   7  12  17
2  3   8  13  18
3  4   9  14  19
4  5  10  15  20



# ignore_index = False
print(pd.concat([a,b],axis=0,ignore_index=False))
# 运行返回：
     a     b     c     d
0  1.0   6.0   NaN   NaN
1  2.0   7.0   NaN   NaN
2  3.0   8.0   NaN   NaN
3  4.0   9.0   NaN   NaN
4  5.0  10.0   NaN   NaN
0  NaN   NaN  11.0  16.0
1  NaN   NaN  12.0  17.0
2  NaN   NaN  13.0  18.0
3  NaN   NaN  14.0  19.0
4  NaN   NaN  15.0  20.0

# ignore_index = True
# True表示清除现有索引并重置索引值。
print(pd.concat([a,b],axis=0,ignore_index=True))
# 运行返回：
     a     b     c     d
0  1.0   6.0   NaN   NaN
1  2.0   7.0   NaN   NaN
2  3.0   8.0   NaN   NaN
3  4.0   9.0   NaN   NaN
4  5.0  10.0   NaN   NaN
5  NaN   NaN  11.0  16.0
6  NaN   NaN  12.0  17.0
7  NaN   NaN  13.0  18.0
8  NaN   NaN  14.0  19.0
9  NaN   NaN  15.0  20.0



# 添加 keys = ['A','B']
# 当axis = 0 时
#  keys：接收序列，添加最外层索引。
print(pd.concat([a,b],axis=0,keys=['A','B']))
# 运行返回：
       a     b     c     d
A 0  1.0   6.0   NaN   NaN
  1  2.0   7.0   NaN   NaN
  2  3.0   8.0   NaN   NaN
  3  4.0   9.0   NaN   NaN
  4  5.0  10.0   NaN   NaN
B 0  NaN   NaN  11.0  16.0
  1  NaN   NaN  12.0  17.0
  2  NaN   NaN  13.0  18.0
  3  NaN   NaN  14.0  19.0
  4  NaN   NaN  15.0  20.0

# 当axis = 1 时
#  keys：接收序列，添加最外层索引
print(pd.concat([a,b],axis=1,keys=['A','B']))
# 运行返回：
   A       B    
   a   b   c   d
0  1   6  11  16
1  2   7  12  17
2  3   8  13  18
3  4   9  14  19
4  5  10  15  20

• join：表示连接的方式，inner为内连接，outer为外连接。

a = pd.DataFrame({"a":[1,2,3,4,5],"b":[6,7,8,9,10]})
b = pd.DataFrame({"b":[6,7,8,9,10],"c":[11,12,13,14,15]})

# 查看数据
print(a)
print(b)
# 运行返回：
   a   b
0  1   6
1  2   7
2  3   8
3  4   9
4  5  10
    b   c
0   6  11
1   7  12
2   8  13
3   9  14
4  10  15



# join="inner" 表示内连接，仅返回交集（重叠）的部分。
print(pd.concat([a,b],axis=0,join="inner"))
# 运行返回：
    b
0   6
1   7
2   8
3   9
4  10
0   6
1   7
2   8
3   9
4  10

# join="outer" 表示外连接,返回两组数据的并集部分。
print(pd.concat([a,b],axis=0,join="outer"))
# 运行返回：
     a   b     c
0  1.0   6   NaN
1  2.0   7   NaN
2  3.0   8   NaN
3  4.0   9   NaN
4  5.0  10   NaN
0  NaN   6  11.0
1  NaN   7  12.0
2  NaN   8  13.0
3  NaN   9  14.0
4  NaN  10  15.0

---

merge()主键合并数据

left：参与合并的左侧DataFrame对象
right：参与合并的右侧DataFrame对象
how：表示连接方法。
no：用于连接的键

a = pd.DataFrame({"a":[1,2,3,4,5],"b":[6,7,8,9,10]})
b = pd.DataFrame({"b":[6,7,8,9,10],"c":[11,12,13,14,15]})

# 查看数据
print(a)
print(b)
# 运行返回：
   a   b
0  1   6
1  2   7
2  3   8
3  4   9
4  5  10
    b   c
0   6  11
1   7  12
2   8  13
3   9  14
4  10  15



# left：参与合并的左侧DataFrame对象
# right：参与合并的右侧DataFrame对象

# left=a,right=b
print(pd.merge(left=a,right=b))
# 运行返回：
   a   b   c
0  1   6  11
1  2   7  12
2  3   8  13
3  4   9  14
4  5  10  15

# left=b,right=a
print(pd.merge(left=b,right=a))
    b   c  a
0   6  11  1
1   7  12  2
2   8  13  3
3   9  14  4
4  10  15  5

• on：用于连接的列名，必须存在于左右两个DataFrame中对象中。

# 创建数组
a = pd.DataFrame({"key":[1,2,3,4,5],"a":[1,2,3,4,5],"b":[6,7,8,9,10]})
b = pd.DataFrame({"key":[1,2,3,4,5],"b":[6,7,8,9,10],"c":[11,12,13,14,15]})

print(a)
print(b)
# 运行返回：
   key  a   b
0    1  1   6
1    2  2   7
2    3  3   8
3    4  4   9
4    5  5  10
   key   b   c
0    1   6  11
1    2   7  12
2    3   8  13
3    4   9  14
4    5  10  15


# 设置 on = ["key","b"]
print(pd.merge(left=a,right=,on=["key","b"]))
# 运行返回： 
   key  a   b   c
0    1  1   6  11
1    2  2   7  12
2    3  3   8  13
3    4  4   9  14
4    5  5  10  15

---

join() 根据行索引合并数据

no：用于连接列名。
how：可以从 left，right，outer，inner 中选一个。
sort：接收布尔值，对合并的数据进行排序。

• how

inner	取行索引的交集
outer	取行索引的并集
left	使用左边df的行索引
right	使用右边df的行索引

# 创建数组
a = pd.DataFrame({"key":[1,2,3,4,5],"a":[1,2,3,4,5]},index=[1,2,3,4,5])
b = pd.DataFrame({"b":[6,7,8,9,10],"c":[11,12,13,14,15]},index=[1,2,3,4,6])

print(a)
# 运行返回：
   key  a
1    1  1
2    2  2
3    3  3
4    4  4
5    5  5

print(b)
# 运行返回：
    b   c
1   6  11
2   7  12
3   8  13
4   9  14
6  10  15



# inner	取行索引的交集
print(a.join(b,how="inner"))
# 运行返回:
   key  a  b   c
1    1  1  6  11
2    2  2  7  12
3    3  3  8  13
4    4  4  9  14


# outer	取行索引的并集
print(a.join(b,how="outer"))
# 运行返回：
   key    a     b     c
1  1.0  1.0   6.0  11.0
2  2.0  2.0   7.0  12.0
3  3.0  3.0   8.0  13.0
4  4.0  4.0   9.0  14.0
5  5.0  5.0   NaN   NaN
6  NaN  NaN  10.0  15.0


# left	使用左边df的行索引
print(a.join(b,how="left"))
# 运行返回：
   key  a    b     c
1    1  1  6.0  11.0
2    2  2  7.0  12.0
3    3  3  8.0  13.0
4    4  4  9.0  14.0
5    5  5  NaN   NaN


# right	使用右边df的行索引
print(a.join(b,how="right"))
# 运行返回：
   key    a   b   c
1  1.0  1.0   6  11
2  2.0  2.0   7  12
3  3.0  3.0   8  13
4  4.0  4.0   9  14
6  NaN  NaN  10  15

---

combine_first()合并重叠数据

a = pd.DataFrame({'A':[None,1,2,3],'B':[None,2,None,4],'key':[1,2,3,4]})
b = pd.DataFrame({"A":[6,7,8],"B":[11,12,13]},)

print(a)
# 运行返回：
     A    B  key
0  NaN  NaN    1
1  1.0  2.0    2
2  2.0  NaN    3
3  3.0  4.0    4

print(b)
# 运行返回：
   A   B
0  6  11
1  7  12
2  8  13


# 合并重叠数据
print(a.combine_first(b))
     A     B  key
0  6.0  11.0    1
1  1.0   2.0    2
2  2.0  13.0    3
3  3.0   4.0    4

---

旋转数据

• stack() 函数

stack() 可以将数据的列旋转成行

• level：默认为-1表示操作内层索引，0表示操作外层索引。
• dropna：传入布尔值，表示是否将旋转后的空值删除，默认为删除。

a = pd.DataFrame({'A':[None,1,2,3],'B':[None,2,None,4],'key':[1,2,3,4]})

print(a)
# 运行返回：
     A    B  key
0  NaN  NaN    1
1  1.0  2.0    2
2  2.0  NaN    3
3  3.0  4.0    4


# stack()可以将数据的列旋转成行
print(a.stack(dropna=False))
# 运行返回：
0  A      NaN
   B      NaN
   key    1.0
1  A      1.0
   B      2.0
   key    2.0
2  A      2.0
   B      NaN
   key    3.0
3  A      3.0
   B      4.0
   key    4.0

---

• unstack() 函数

unstack() 可以将数据的列索引旋转成行索引

• level：默认为-1表示操作内层索引，0表示操作外层索引。
• fill_values：可以将旋转产生的空值，指定数据填充。

a = pd.DataFrame({'A':[None,1,2,3],'B':[None,2,None,4],'key':[1,2,3,4]})

print(a)
# 运行返回：
     A    B  key
0  NaN  NaN    1
1  1.0  2.0    2
2  2.0  NaN    3
3  3.0  4.0    4


# unstack()可以将数据的列索引旋转成行索引
print(a.unstack())
# 运行返回：
A    0    NaN
     1    1.0
     2    2.0
     3    3.0
B    0    NaN
     1    2.0
     2    NaN
     3    4.0
key  0    1.0
     1    2.0
     2    3.0
     3    4.0

---

• pivot() 轴向旋转

index：用于创建新的DataFrame对象的行索引，如果未设置，则使用原DataFrame对象的索引。
columns：用于创建新的DataFrame对象中的值。
values：用于填充新的DataFrame对象的值。

a = pd.DataFrame({"出售日期":['5月25日','5月25日','5月25日','6月18日','6月18日','6月18日'],"商品名称":['荣耀','小米','oppo','荣耀','小米','oppo'],"价格":[999,1399,1399,800,1200,1250]})
  
print(a)
# 运行返回：
    出售日期  商品名称    价格
0  5月25日    荣耀   999
1  5月25日    小米  1399
2  5月25日  oppo  1399
3  6月18日    荣耀   800
4  6月18日    小米  1200
5  6月18日  oppo  1250


# 重新组织数组
print(a.pivot(index="出售日期",columns="商品名称",values="价格"))
# 运行返回：
商品名称   oppo    小米   荣耀
出售日期
5月25日  1399  1399  999
6月18日  1250  1200  800

---

groupby()分组聚合

数据分组

---

按列分组

a = pd.DataFrame({
    "key":['c','b','c','a','b','b','a','c','a'],
    "data":[2,4,6,8,10,1,144,16,18]
                  })
print(a)
# 运行返回：
  key  data
0   c     2
1   b     4
2   c     6
3   a     8
4   b    10
5   b     1
6   a   144
7   c    16
8   a    18



# 让df对象按key列分组
print(a.groupby("key"))
# 运行返回：得到一个可迭代代对象
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001A25F735550> 


# 用for循环遍历
for i in a.groupby("key"):
    print(i)
# 运行返回：
('a',   key  data
3   a     8
6   a   144
8   a    18)
('b',   key  data
1   b     4
4   b    10
5   b     1)
('c',   key  data
0   c     2
2   c     6
7   c    16)

---

用Series对象分组

a = pd.DataFrame({
    "key":['c','b','c','a','b','b','a','c','a'],
    "data":[2,4,6,8,10,1,144,16,18]
                  })
print(a)
# 运行返回：
  key  data
0   c     2
1   b     4
2   c     6
3   a     8
4   b    10
5   b     1
6   a   144
7   c    16
8   a    18



# 用Series对象分组
# 创建Series对象
s = pd.Series(['a','b','c','c','b','a','d','d','d'])
# 分组
for i in a.groupby(s):
    print(i)
# 运行返回：
('a',   key  data    
0   c     2
5   b     1)
('b',   key  data    
1   b     4
4   b    10)
('c',   key  data    
2   c     6
3   a     8)
('d',   key  data
6   a   144
7   c    16
8   a    18)
# 传入的Series对象中，相同字段参数的对应行在一组。
# 列表中'a'对应索引0和5，则第0行和第5行在一组。



# 长度不相等的Series对象分组
# 创建Series对象
s = pd.Series(['a','b','a','b'])
# 分组
for i in a.groupby(s):
    print(i)
# 运行返回：
('a',   key  data    
0   c     2
2   c     6)
('b',   key  data
1   b     4
3   a     8)
# 在长度不同相等时
# 只有4行数据，则只用分组前4行.
# 列表中'a'对应索引0和2，则第0行和第2行在一组。

---

用函数分组

# 创建数组
a = pd.DataFrame({
    "A":[1,2,3,4,5],
    "B":[6,7,8,9,10],
    "C":[11,12,13,14,15]
    },index=['a','bb','ccc','ddd','e'])
# 查看数组
print(a)
# 运行返回：
     A   B   C
a    1   6  11       
bb   2   7  12       
ccc  3   8  13       
ddd  4   9  14       
e    5  10  1


# 用len函数分组
for i in a.groupby(len):
    print(i)
# 运行返回：
(1,    A   B   C     
a  1   6  11
e  5  10  15)        
(2,     A  B   C
bb  2  7  12)        
(3,      A  B   C    
ccc  3  8  13        
ddd  4  9  14)
# 用len函数分组，就以行索引的长度分组，则索引长度一样的分在一组。
# len()函数对行索引执行求长度的操作，返回行索引的长度，长度一致的一组。

---

数据聚合

用内置函数聚合函数

a = pd.DataFrame({
    "key":['c','b','c','a','b','b','a','c','a'],
    "data":[2,4,6,8,10,1,144,16,18]
                  })
print(a)
# 运行返回：
  key  data
0   c     2
1   b     4
2   c     6
3   a     8
4   b    10
5   b     1
6   a   144
7   c    16
8   a    18


# 用列分组
# 按key列分组，求每个分组的平均值
print(a.groupby("key").mean())
#  运行返回：
          data
key
a    56.666667
b     5.000000
c     8.000000

---

agg()面向列的聚合

• func：表示用于聚合数据的函数，可以是单个函数或函数列表。
• axis：表示函数用于轴的方向，默认为0。

对每一列数据用同一个函数

a = pd.DataFrame({
    "A":[1,2,3,4,5],
    "B":[6,7,8,9,10],
    "C":[11,12,13,14,15],
    "D":[5,4,3,2,1],
    "key":['a','a','a','b','b']
    }  
print(a)
# 运行返回：
   A   B   C  D key
0  1   6  11  5   a
1  2   7  12  4   a
2  3   8  13  3   a
3  4   9  14  2   b
4  5  10  15  1   b


# dict()：转化成列表
# 按key列分组
print(dict([x for x in a.groupby("key")]))
#运行返回：
{'a':    A  B   C  D key
0  1  6  11  5   a
1  2  7  12  4   a
2  3  8  13  3   a, 'b':    A   B   C  D key
3  4   9  14  2   b
4  5  10  15  1   b}


# 输出a组数据
print(dict([x for x in a.groupby("key")])["a"])
   A  B   C  D key
0  1  6  11  5   a
1  2  7  12  4   a
2  3  8  13  3   a


# 求每个分组的值
print(a.groupby("key").agg(sum))
# 运行返回：
     A   B   C   D
key
a    6  21  36  12
b    9  19  29   3

---

用多种函数聚合数据

a = pd.DataFrame({
    "A":[1,2,3,4,5],
    "B":[6,7,8,9,10],
    "C":[11,12,13,14,15],
    "D":[5,4,3,2,1],
    "key":['a','a','a','b','b']
    }  
print(a)
# 运行返回：
   A   B   C  D key
0  1   6  11  5   a
1  2   7  12  4   a
2  3   8  13  3   a
3  4   9  14  2   b
4  5  10  15  1   b


# 用两种数据聚合，向agg()中传入列表。
print(a.groupby("key").agg([sum,len]))
# 运行返回：
	A	 A	 B	 B	 C	 C	 D	 D
	sum len sum len sum len sum len
key
a 	6 	3 	21 	3 	36 	3 	12 	3
b 	9 	2 	19 	2 	29 	2 	3 	2
# 生成的DataFrame对象有两层索引，内层索引为传入的len和sum。

---

对不同列使用不同的函数

a = pd.DataFrame({
    "A":[1,2,3,4,5],
    "B":[6,7,8,9,10],
    "C":[11,12,13,14,15],
    "D":[5,4,3,2,1],
    "key":['a','a','a','b','b']
    }  
print(a)
# 运行返回：
   A   B   C  D key
0  1   6  11  5   a
1  2   7  12  4   a
2  3   8  13  3   a
3  4   9  14  2   b
4  5  10  15  1   b


# 用字典格式传入函数
# 字典的键为列，值为要传入的函数：{"列名":"函数名"}
print(a.groupby("key").agg({"A":'sum',"B":'max',"C":'mean'}))
# 运行返回：
     A   B     C
key
a    6   8  12.0
b    9  10  14.5

---

apply()函数

• func：表示用于某行或某列的函数。
• axis：表示函数用于轴的方向，默认为0。

# 创建数组
a = pd.DataFrame({
    "A":[1,2,3,4,5],
    "B":[6,7,8,9,10],
    "C":[11,12,13,14,15],
    "D":[5,4,3,2,1],
    "key":['a','a','a','b','b']
    }  
print(a)
# 运行返回：
   A   B   C  D key
0  1   6  11  5   a
1  2   7  12  4   a
2  3   8  13  3   a
3  4   9  14  2   b
4  5  10  15  1   b


# 定义一个函数，将每个元素加10。
def jia(a):
    return a.iloc[:,:4] + 10
# 用apply()函数将定义的jia()函数应用到列表中。 
print(a.groupby("key").apply(jia))
# 运行返回：
        A   B   C   D
key
a   0  11  16  21  15
    1  12  17  22  14
    2  13  18  23  13
b   3  14  19  24  12
    4  15  20  25  11

---

指定某个元素的个别操作

查看某列符条件的值

# 创建数组
df = pd.DataFrame({
    "A":[1,2,3,4,5],
    "B":[6,7,8,9,10],
    "C":[11,12,13,14,15],
    "D":[5,4,3,2,1],
    "key":['a','a','a','b','b']
    }  
print(df)
# 运行返回：
   A   B   C  D key
0  1   6  11  5   a
1  2   7  12  4   a
2  3   8  13  3   a
3  4   9  14  2   b
4  5  10  15  1   b


# 查看A列中小于3的行
print(df[df["A"] < 3 ]["A"])
# 运行返回： 
0    1
1    2

# 查看数组中A列不等于3的行
print(df[df["A"] != 3 ])
# 运行返回：
   A   B   C  D key
0  1   6  11  5   a
1  2   7  12  4   a
3  4   9  14  2   b
4  5  10  15  1   b

# 查看A列中等于3的行索引
print(df[df["A"] == 3 ].index)
# 运行返回：
Index([2], dtype='int64')

删除某列符条件的值

# 创建数组
df = pd.DataFrame({
    "A":[1,2,3,4,5],
    "B":[6,7,8,9,10],
    "C":[11,12,13,14,15],
    "D":[5,4,3,2,1],
    "key":['a','a','a','b','b']
    }  
print(df)
# 运行返回：
   A   B   C  D key
0  1   6  11  5   a
1  2   7  12  4   a
2  3   8  13  3   a
3  4   9  14  2   b
4  5  10  15  1   b



# 删除A列中小于3的行
df = df.drop(df[df["A"] < 3 ].index)
print(df)
# 运行返回：
   A   B   C  D key
2  3   8  13  3   a
3  4   9  14  2   b
4  5  10  15  1   b

---

修改某列的某个数值

# 创建数组
df = pd.DataFrame({
    "A":[1,2,3,4,5],
    "B":[6,7,8,9,10],
    "C":[11,12,13,14,15],
    "D":[5,4,3,2,1],
    "key":['a','a','a','b','b']
    }  
print(df)
# 运行返回：
   A   B   C  D key
0  1   6  11  5   a
1  2   7  12  4   a
2  3   8  13  3   a
3  4   9  14  2   b
4  5  10  15  1   b


# 修改某列的某个数值
df.loc[0,'A'] = 'xxx'
print(df)
# 运行返回：
     A   B   C  D key
0  xxx   6  11  5   a
1    2   7  12  4   a
2    3   8  13  3   a
3    4   9  14  2   b
4    5  10  15  1   b


# 修改A列中小于3的数据为"xxx"
# 找出A列中小于3的数据的索引
a = df[df["B"] <= 8 ].index
# 修改数据
df.loc[a,'B'] = 'xxx'
print(df)
# 运行返回：
   A    B   C  D key
0  1  xxx  11  5   a
1  2  xxx  12  4   a
2  3  xxx  13  3   a
3  4    9  14  2   b
4  5   10  15  1   b

标签：11,10,基础教程,df,NaN,索引,应用,print,pandas
From： https://blog.csdn.net/lyx52Hertz/article/details/136902272