大数据—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()函数
  • value_counts()和get()

• 指定某个元素的个别操作

  • 查看某列符条件的值
  • 删除某列符条件的值
  • 修改某列的某个数值

• 添加数据

---

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

---

fillna()填充空值

• 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  10.0   7.0
c  8  9  10.0  20.0

---

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
f     True

---

• 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()函数对行索引执行求长度的操作，返回行索引的长度，长度一致的一组。

---

数据聚合

用内置函数聚合函数

sum()	计算每组的总和。
mean()	计算每组的平均值。
count()	计算每组的非空值数量（不包括NaN）。
max()	找出每组的最大值。
min()	找出每组的最小值。
std()	计算每组的标准差。
var()	计算每组的方差。
median()	计算每组的中位数。
prod()	计算每组的乘积。
first() 和 last()	分别返回每组的第一个和最后一个值（按索引顺序）。
nunique()	返回每组的唯一值数量。
size()	返回每组的数量。

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

---

数据获取

value_counts() 函数能够快速提供数据每个值出现的次数

get() 函数在分组后直接查看想要的组

import pandas as pd
df = pd.DataFrame({"A":[1,2,3],"B":[4,5,6],"C":[7,8,9],"D":["a","a","b"]})
print(df)
# 运行返回：
   A  B  C  D
0  1  4  7  a
1  2  5  8  a
2  3  6  9  b 

# 得到一个可迭代对象
print(df.groupby("D"))
# 运行返回
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000017E56CCE690>

[print(i) for i in df.groupby("D")]
# 运行返回：
('a',    A  B  C  D
0  1  4  7  a
1  2  5  8  a)
('b',    A  B  C  D
2  3  6  9  b)

# value_counts()
# 该函数能够快速提供数据每个值出现的次数
print(df.groupby("D").value_counts())
# 运行返回：
D  A  B  C
a  1  4  7    1
   2  5  8    1
b  3  6  9    1

print(df.groupby("D")["A"].value_counts())
# 运行返回：
D  A
a  1    1
   2    1
b  3    1

# get()
# 在分组后直接查看想要的组
df = df.groupby("D")["A"].value_counts()
print(df.get("a"))
A
1    1
2    1

---

指定某个元素的个别操作

查看某列符条件的值

# 创建数组
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')


#查看 A列 大于2，小于5的行
print(df[(df["A"] > 2) & (df["A"] < 5)])
#运行返回
   A  B   C  D key
2  3  8  13  3   a
3  4  9  14  2   b


### "str.countains" 方法
# 参数 "case = False" 表示不区分大小写进行搜索（如果需要区分大小写，可以设置为 `True`）
# 参数 "na = False" 表示如果遇到 NaN 值，将其视为 False（如果需要将 NaN 视为 True，则可以设置为 `True`）
# 注意！！！这种方法适用于列中的值是 字符串 类型的情况

#查看key列包含“a”的行
print(df[df["key"].str.contains("A",case = False)])
#运行返回
   A  B   C  D key
0  1  6  11  5   a
1  2  7  12  4   a
2  3  8  13  3   a

删除某列符条件的值

# 创建数组
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


#删除 A列小于2的行 或者 key列为“b”的行
print(df.drop(df[(df["A"] < 2) | (df["key"] == "b")].index))
#运行返回
   A  B   C  D key
1  2  7  12  4   a
2  3  8  13  3   a

---

修改某列的某个数值

# 创建数组
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

---

添加数据行或列

---

添加列

---

直接赋值法

语法：df [“新列名”] = 新列的值

import pandas as pd
# 创建数组
df = pd.DataFrame([[1,2,3,4],[0,5,8,7],[1,9,10,11],[0,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   0   5   8   7
c   1   9  10  11
d   0  12  13  14
f  11  12  13  14

# 语法：df["新列名"]=新列的值
# 直接命名列名为"abc"，添加列数据["a","b","c","d","e"]
df["abc"] = ["a","b","c","d","e"]
print(df)
# 运行返回：
    0   1   2   3 abc
a   1   2   3   4   a
b   0   5   8   7   b
c   1   9  10  11   c
d   0  12  13  14   d
f  11  12  13  14   e

---

在指定位置插入列

insert()函数

语法：DataFrame.insert(loc, column, value,allow_duplicates = False)

参数	说明
loc	必要字段，int类型数据，表示插入新列的列位置，原来在该位置的列将向右移。
column	必要字段，插入新列的列名。
value	必要字段，新列插入的值。如果仅提供一个值，将为所有行设置相同的值。可以是int，string，float等，甚至可以是series /值列表。

import pandas as pd
# 创建数组
df = pd.DataFrame([[1,2,3,4],[0,5,8,7],[1,9,10,11],[0,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   0   5   8   7
c   1   9  10  11
d   0  12  13  14
f  11  12  13  14


# 在第二个位置添加列
# df.insert(位置，"列名"，数据)
df.insert(2,"abc",["a","b","c","d","e"])

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

---

添加行

注意！添加行要加df.loc[“行名”] = [数据]

import pandas as pd
# 创建数组
df = pd.DataFrame([[1,2,3,4],[0,5,8,7],[1,9,10,11],[0,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   0   5   8   7
c   1   9  10  11
d   0  12  13  14
f  11  12  13  14


# 注意！添加行要加df.loc[""]
df.loc["abc"] = ["a","b","c","d"]
print(df)
# 运行返回：
      0   1   2   3
a     1   2   3   4
b     0   5   8   7
c     1   9  10  11
d     0  12  13  14
f    11  12  13  14
abc   a   b   c   d