pandas学习

sunnyboy_4

已于 2022-11-25 16:19:06 修改

阅读量188

点赞数

分类专栏： Python机器学习文章标签： pandas 学习 python

于 2022-11-25 16:18:11 首次发布

本文链接：https://blog.csdn.net/u012228523/article/details/128040015

版权

Python机器学习专栏收录该内容

15 篇文章 0 订阅

订阅专栏

import pandas as pd

result = pd.Series([2,2,3,4,5,5]).unique() #去除值中重复值每个值，只保留一个
print(result)

[2 3 4 5]

count = pd.Series([2,2,3,4,5,5]).nunique() #去除值中重复值，每个值只保留一个，并且统计数量
print(count)
print(pd.Series([2,2,3,4,5,5]).value_counts()) #统计值中各数据出现次数

4
2    2
5    2
3    1
4    1
dtype: int64

#将Series看着字典
s_1 = pd.Series(data=[2,3,4,5,10],index = list('ABCDE'))
print(s_1)
print(s_1['C'])
print(s_1.keys)
print(s_1.index)
print(s_1.values)
print(s_1.items()) #获取索引和值对
print('B' in s_1) #判断是否包含某个索引
s_1['C'] = 30 #修改某个索引值
print(s_1)

A     2
B     3
C     4
D     5
E    10
dtype: int64
4
<bound method Series.keys of A     2
B     3
C     4
D     5
E    10
dtype: int64>
Index(['A', 'B', 'C', 'D', 'E'], dtype='object')
[ 2  3  4  5 10]
<zip object at 0x7fcc0b54a440>
True
A     2
B     3
C    30
D     5
E    10
dtype: int64

#通过索引，切片，布尔达表达式访问数据
s_1 = pd.Series(data=[2,3,4,5,10],index = list('ABCDE'))

print(s_1[2]) #第三个值 6
print(s_1['A':'B']) #包括A和D对应的值
print(s_1[1:4]) #包括1但是不包括4
print(s_1 > 5)  #所有大于5的值

4
A    2
B    3
dtype: int64
B    3
C    4
D    5
dtype: int64
A    False
B    False
C    False
D    False
E     True
dtype: bool

#索引器：loc,iloc
s_2 = pd.Series(range(2,12,2),index=range(1,6))
print(s_2)
print(s_2.iloc[2]) #隐式索引
print(s_2.loc[2]) #显示索引
print(s_2[2:4]) #包括2不包括4
print(s_2.loc[2:4]) #包括2包括4

1     2
2     4
3     6
4     8
5    10
dtype: int64
6
4
3    6
4    8
dtype: int64
2    4
3    6
4    8
dtype: int64

#series常用方法
s_3 = pd.Series([8,4,7,3],index=list('ACBD'))
print(s_3)
print("======")
print(s_3.sort_index()) #根据索引排序
print(s_3.sort_values()) #根据值排序
print(s_3.rank()) #排名
#print(s_3.reindex(list('BCFE'))) #重新设置索引
print(s_3.reindex(list('BCFEQ'),fill_value=0)) #重新设置索引,缺省值 0补齐
import numpy as np
print(np.square(s_3))
print(s_3 + s_3)

A    8
C    4
B    7
D    3
dtype: int64
======
A    8
B    7
C    4
D    3
dtype: int64
D    3
C    4
B    7
A    8
dtype: int64
A    4.0
C    2.0
B    3.0
D    1.0
dtype: float64
B    7
C    4
F    0
E    0
Q    0
dtype: int64
A    64
C    16
B    49
D     9
dtype: int64
A    16
C     8
B    14
D     6
dtype: int64

基本机构之DataFream(既有行索引，又有列索引的二维数组)
类似于Excel表或关系型数据库中的二维表

可通过值为一维ndarray，list, dict或者Series的字典或列表；二维的ndarray；单个Series、列表、一维数组，此时DataFrame中只有一列；其他的DataFrame等创建；

#DataFrame 创建实例
names = ['张三','李四','王五']
ages = [20,18,19]
d1 = pd.DataFrame({'姓名':names,'年龄':ages})
print(d1)
d2 = pd.DataFrame([names,ages])
print(d2)

   姓名  年龄
0  张三  20
1  李四  18
2  王五  19
    0   1   2
0  张三  李四  王五
1  20  18  19

import pandas as pd
import numpy as np
names = ['张三','李四','王五']
ages = [20,18,19]
s_names = pd.Series(names,index=['A','B','C'])
s_ages = pd.Series(ages,index=['B','C','D'])
d3 = pd.DataFrame({'姓名':s_names,'年龄':s_ages})
print(d3)
print(pd.DataFrame([names,ages]))
d4 = pd.DataFrame(np.random.randint(10,30,(3,4)))
print(d4)
s_name = {'A01':'江西财大','A05':'南昌大学','A08':'江西农大'}
s_type = {'A05':'综合类','A01':'财经类','A06':'师范类'}
d5 = pd.DataFrame({"学校名称":s_name,"学校类型":s_type})
print(d5)

    姓名    年龄
A   张三   NaN
B   李四  20.0
C   王五  18.0
D  NaN  19.0
    0   1   2
0  张三  李四  王五
1  20  18  19
    0   1   2   3
0  22  22  12  22
1  27  29  24  12
2  15  21  29  14
     学校名称 学校类型
A01  江西财大  财经类
A05  南昌大学  综合类
A08  江西农大  NaN
A06   NaN  师范类

dataframe中数据访问

1、以列的索引为关键字，获取某一列数据，例如d_1[列索引]，结果为Series对象，可进一步获取某个数据，例如d_1[列索引][行索引]，需要使用两个中括号，不能合并； 2、如果列的索引为字符串，则可以列名为属性名，获取某一列数据，例如d_1.属性名，前提是列名符合标识符的命名规范。如果列名不符合规范或与 DataFrame 中属性相同，例如shape、index等，则不能用属性形式。

s_names = pd.Series(['张三','李四','王麻子','赵六','钱七'],index=list('ABCDE'))
s_ages = pd.Series([18,20,18,19],index=list('ABCD'))
d_1 = pd.DataFrame({"姓名":s_names,"年龄":s_ages})
print(d_1)
print(d_1['姓名'])
print(d_1.姓名)
print(d_1['姓名'] is d_1.姓名) #是否为同一对象
print(d_1['姓名']['B'])

    姓名    年龄
A   张三  18.0
B   李四  20.0
C  王麻子  18.0
D   赵六  19.0
E   钱七   NaN
A     张三
B     李四
C    王麻子
D     赵六
E     钱七
Name: 姓名, dtype: object
A     张三
B     李四
C    王麻子
D     赵六
E     钱七
Name: 姓名, dtype: object
True
李四

将datafream看做二维数组

支持行转置，布尔表达式等
支持行切片，不支持列切片，若想访问多数据列，可将多个列索引放在列表中，例如d_1[[列1，列2]]

print(d_1.T)
print(d_1[d_1.年龄 == 18]) #布尔表达式
print(d_1[1:3]) #行切片，隐式索引
print(d_1['A':'D']) #行切片，显示索引
print(d_1[['年龄','姓名']]) #同时获取多列信息
print(d_1.iloc[3,1]) #根据位置取值
# print(d_1.iloc[1:3,0:1]) #根据位置切片
print(d_1.loc["D","姓名"])#根据显示索引取值
print(d_1.loc['A':'D','姓名':'年龄'])

       A     B     C     D    E
姓名    张三    李四   王麻子    赵六   钱七
年龄  18.0  20.0  18.0  19.0  NaN
    姓名    年龄
A   张三  18.0
C  王麻子  18.0
    姓名    年龄
B   李四  20.0
C  王麻子  18.0
    姓名    年龄
A   张三  18.0
B   李四  20.0
C  王麻子  18.0
D   赵六  19.0
     年龄   姓名
A  18.0   张三
B  20.0   李四
C  18.0  王麻子
D  19.0   赵六
E   NaN   钱七
19.0
赵六
    姓名    年龄
A   张三  18.0
B   李四  20.0
C  王麻子  18.0
D   赵六  19.0

dataframe常见属性

shape:获取形状信息，结果为一个元组
dtypes:获取各字段的数据类型，结果为Series
values:获取数据内容，结果为二维数组
columns:获取列索引，即字段名称，结果为index
index:获取行索引，即行的标签结果为index
axes:同时获取行和列索引，结果为index列表

print(d_1.shape)
print(d_1.dtypes)
print(d_1.values)
print(d_1.columns)
print(d_1.index)
print(d_1.axes)

(5, 2)
姓名     object
年龄    float64
dtype: object
[['张三' 18.0]
 ['李四' 20.0]
 ['王麻子' 18.0]
 ['赵六' 19.0]
 ['钱七' nan]]
Index(['姓名', '年龄'], dtype='object')
Index(['A', 'B', 'C', 'D', 'E'], dtype='object')
[Index(['A', 'B', 'C', 'D', 'E'], dtype='object'), Index(['姓名', '年龄'], dtype='object')]

dataframe常见方法

d_1 = pd.DataFrame(np.random.randint(10,30,(20,10)),index=[chr(x) for x in range(116,96,-1)],columns=[chr(x) for x in range(65,75)])
print(d_1)

    A   B   C   D   E   F   G   H   I   J
t  22  23  11  22  26  14  16  28  28  15
s  26  22  13  12  22  18  17  17  27  16
r  12  19  18  13  27  15  17  25  24  23
q  26  22  24  19  27  16  18  27  25  17
p  23  25  12  12  19  21  19  21  24  17
o  24  10  16  16  10  21  14  25  21  18
n  24  10  20  23  10  10  17  10  26  16
m  29  24  11  11  29  13  16  19  28  15
l  10  24  20  13  26  12  27  21  19  11
k  26  14  11  10  24  15  10  17  27  29
j  14  28  25  21  16  19  27  12  26  17
i  21  26  17  15  21  13  27  15  29  22
h  13  13  10  27  24  27  25  29  19  13
g  12  25  20  29  24  26  13  14  13  22
f  11  22  12  11  13  16  12  26  22  23
e  21  11  23  24  21  13  28  16  26  13
d  23  18  24  13  21  16  18  20  29  14
c  19  11  17  22  28  23  11  29  13  14
b  27  16  18  28  19  10  22  17  11  14
a  16  25  10  19  15  13  28  28  25  28

print(d_1.info()) #基本信息，包括行列索引信息，每列非空元素数量，每列元素数据的类型，整体所占内存大小等
print(d_1.head(5)) #获取前N行数据
print(d_1.tail(3))#获取后N行数据

<class 'pandas.core.frame.DataFrame'>
Index: 20 entries, t to a
Data columns (total 10 columns):
 #   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   A       20 non-null     int64
 1   B       20 non-null     int64
 2   C       20 non-null     int64
 3   D       20 non-null     int64
 4   E       20 non-null     int64
 5   F       20 non-null     int64
 6   G       20 non-null     int64
 7   H       20 non-null     int64
 8   I       20 non-null     int64
 9   J       20 non-null     int64
dtypes: int64(10)
memory usage: 1.7+ KB
None
    A   B   C   D   E   F   G   H   I   J
t  22  23  11  22  26  14  16  28  28  15
s  26  22  13  12  22  18  17  17  27  16
r  12  19  18  13  27  15  17  25  24  23
q  26  22  24  19  27  16  18  27  25  17
p  23  25  12  12  19  21  19  21  24  17
    A   B   C   D   E   F   G   H   I   J
c  19  11  17  22  28  23  11  29  13  14
b  27  16  18  28  19  10  22  17  11  14
a  16  25  10  19  15  13  28  28  25  28

print(d_1.describe())#数据的整体描述信息，包括：非空值数量，平均值，标准差，最小值，最大值

               A          B         C          D          E         F  \
count  20.000000  20.000000  20.00000  20.000000  20.000000  20.00000   
mean   19.950000  19.400000  16.60000  18.000000  21.100000  16.55000   
std     6.091193   6.021016   5.11345   6.189975   5.793826   4.90408   
min    10.000000  10.000000  10.00000  10.000000  10.000000  10.00000   
25%    13.750000  13.750000  11.75000  12.750000  18.250000  13.00000   
50%    21.500000  22.000000  17.00000  17.500000  21.500000  15.50000   
75%    24.500000  24.250000  20.00000  22.250000  26.000000  19.50000   
max    29.000000  28.000000  25.00000  29.000000  29.000000  27.00000   

              G         H          I          J  
count  20.00000  20.00000  20.000000  20.000000  
mean   19.10000  20.80000  23.100000  17.850000  
std     6.00789   5.99649   5.485867   5.018649  
min    10.00000  10.00000  11.000000  11.000000  
25%    15.50000  16.75000  20.500000  14.000000  
50%    17.50000  20.50000  25.000000  16.500000  
75%    25.50000  26.25000  27.000000  22.000000  
max    28.00000  29.00000  29.000000  29.000000

print(d_1.count())#统计各列中非空值的数量，结果为series
print(d_1.sample(2,axis=0)) #随机抽取4行
print(d_1.sample(2,axis=1)) #随机抽取4列

A    20
B    20
C    20
D    20
E    20
F    20
G    20
H    20
I    20
J    20
dtype: int64
    A   B   C   D   E   F   G   H   I   J
c  19  11  17  22  28  23  11  29  13  14
h  13  13  10  27  24  27  25  29  19  13
    J   H
t  15  28
s  16  17
r  23  25
q  17  27
p  17  21
o  18  25
n  16  10
m  15  19
l  11  21
k  29  17
j  17  12
i  22  15
h  13  29
g  22  14
f  23  26
e  13  16
d  14  20
c  14  29
b  14  17
a  28  28

#apply(fun,axis) 对每一行或者每一列元素执行函数
print(d_1.apply(np.sum,axis=1))#对列执行加和 相当于对行压缩
print(d_1.apply(np.sum,axis=0))#对行执行加和 相当于对列压缩

t    205
s    190
r    193
q    221
p    193
o    175
n    166
m    195
l    183
k    183
j    205
i    206
h    200
g    198
f    168
e    196
d    196
c    187
b    182
a    207
dtype: int64
A    399
B    388
C    332
D    360
E    422
F    331
G    382
H    416
I    462
J    357
dtype: int64

print(d_1.applymap(np.square)) #对每个元素求平方
print(d_1.to_dict(orient="list")) #转换为字典

     A    B    C    D    E    F    G    H    I    J
t  484  529  121  484  676  196  256  784  784  225
s  676  484  169  144  484  324  289  289  729  256
r  144  361  324  169  729  225  289  625  576  529
q  676  484  576  361  729  256  324  729  625  289
p  529  625  144  144  361  441  361  441  576  289
o  576  100  256  256  100  441  196  625  441  324
n  576  100  400  529  100  100  289  100  676  256
m  841  576  121  121  841  169  256  361  784  225
l  100  576  400  169  676  144  729  441  361  121
k  676  196  121  100  576  225  100  289  729  841
j  196  784  625  441  256  361  729  144  676  289
i  441  676  289  225  441  169  729  225  841  484
h  169  169  100  729  576  729  625  841  361  169
g  144  625  400  841  576  676  169  196  169  484
f  121  484  144  121  169  256  144  676  484  529
e  441  121  529  576  441  169  784  256  676  169
d  529  324  576  169  441  256  324  400  841  196
c  361  121  289  484  784  529  121  841  169  196
b  729  256  324  784  361  100  484  289  121  196
a  256  625  100  361  225  169  784  784  625  784
{'A': [22, 26, 12, 26, 23, 24, 24, 29, 10, 26, 14, 21, 13, 12, 11, 21, 23, 19, 27, 16], 'B': [23, 22, 19, 22, 25, 10, 10, 24, 24, 14, 28, 26, 13, 25, 22, 11, 18, 11, 16, 25], 'C': [11, 13, 18, 24, 12, 16, 20, 11, 20, 11, 25, 17, 10, 20, 12, 23, 24, 17, 18, 10], 'D': [22, 12, 13, 19, 12, 16, 23, 11, 13, 10, 21, 15, 27, 29, 11, 24, 13, 22, 28, 19], 'E': [26, 22, 27, 27, 19, 10, 10, 29, 26, 24, 16, 21, 24, 24, 13, 21, 21, 28, 19, 15], 'F': [14, 18, 15, 16, 21, 21, 10, 13, 12, 15, 19, 13, 27, 26, 16, 13, 16, 23, 10, 13], 'G': [16, 17, 17, 18, 19, 14, 17, 16, 27, 10, 27, 27, 25, 13, 12, 28, 18, 11, 22, 28], 'H': [28, 17, 25, 27, 21, 25, 10, 19, 21, 17, 12, 15, 29, 14, 26, 16, 20, 29, 17, 28], 'I': [28, 27, 24, 25, 24, 21, 26, 28, 19, 27, 26, 29, 19, 13, 22, 26, 29, 13, 11, 25], 'J': [15, 16, 23, 17, 17, 18, 16, 15, 11, 29, 17, 22, 13, 22, 23, 13, 14, 14, 14, 28]}

d_2 = pd.DataFrame(np.random.randint(50,80,(5,4)),columns=list('ABCD'),index=list('abcde'))
print(d_1.append(d_2))

    A   B   C   D     E     F     G     H     I     J
t  22  23  11  22  26.0  14.0  16.0  28.0  28.0  15.0
s  26  22  13  12  22.0  18.0  17.0  17.0  27.0  16.0
r  12  19  18  13  27.0  15.0  17.0  25.0  24.0  23.0
q  26  22  24  19  27.0  16.0  18.0  27.0  25.0  17.0
p  23  25  12  12  19.0  21.0  19.0  21.0  24.0  17.0
o  24  10  16  16  10.0  21.0  14.0  25.0  21.0  18.0
n  24  10  20  23  10.0  10.0  17.0  10.0  26.0  16.0
m  29  24  11  11  29.0  13.0  16.0  19.0  28.0  15.0
l  10  24  20  13  26.0  12.0  27.0  21.0  19.0  11.0
k  26  14  11  10  24.0  15.0  10.0  17.0  27.0  29.0
j  14  28  25  21  16.0  19.0  27.0  12.0  26.0  17.0
i  21  26  17  15  21.0  13.0  27.0  15.0  29.0  22.0
h  13  13  10  27  24.0  27.0  25.0  29.0  19.0  13.0
g  12  25  20  29  24.0  26.0  13.0  14.0  13.0  22.0
f  11  22  12  11  13.0  16.0  12.0  26.0  22.0  23.0
e  21  11  23  24  21.0  13.0  28.0  16.0  26.0  13.0
d  23  18  24  13  21.0  16.0  18.0  20.0  29.0  14.0
c  19  11  17  22  28.0  23.0  11.0  29.0  13.0  14.0
b  27  16  18  28  19.0  10.0  22.0  17.0  11.0  14.0
a  16  25  10  19  15.0  13.0  28.0  28.0  25.0  28.0
a  77  52  65  57   NaN   NaN   NaN   NaN   NaN   NaN
b  74  50  77  77   NaN   NaN   NaN   NaN   NaN   NaN
c  74  79  62  50   NaN   NaN   NaN   NaN   NaN   NaN
d  77  60  64  58   NaN   NaN   NaN   NaN   NaN   NaN
e  66  56  79  79   NaN   NaN   NaN   NaN   NaN   NaN


/var/folders/2s/7x6vd9311ds7xh_gn5tvvg2c0000gn/T/ipykernel_6964/2841885800.py:2: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.
  print(d_1.append(d_2))

DataFrame的合并操作

DataFrame中提供了一个join()方法用于将其他DataFrame中的列合并到当前DataFrame中，类似于数据库中的连接，支持内连接（只保留两个对象中都存在的行索引对应的数据）、外连接（保留两个对象中，只要有一方存在的行索引对应的数据，如果另一方不存在则相应值为NaN）、左连接（只保留左边对象中的所有行索引对应的数据）和右连接（只保留左边对象中的所有行索引对应的数据）等，默认情况采用左连接。join()方法合并数据时，默认根据两个对象的行索引进行匹配连接，如果有相同列名，则需指定后缀以区分，否则会出错，也可通过on参数指定合并时参考的列，此时需将该列作为其他对象的行索引，也就是说让另一个对象的行索引和当前对象的on进行匹配。

s_names = pd.Series(['张三','李四','王五','赵六','钱七'],index=list("ZBCDE"))
s_ages = pd.Series([18,20,18,19],index=list('ADBC'))
s_nums = pd.Series(["001","003","006","008"],index=list("ADCE"))
s_names_2 = pd.Series(["张三","李四","孙五","周六"],index=list('ADCE'))
d1 = pd.DataFrame({"姓名":s_names,"年龄":s_ages})
d2 = pd.DataFrame({"姓名":s_names_2,"学号":s_nums})
print(d1)
print(d2)
print(d1.join(d2,rsuffix="_r")) #默认左连接 根据行索引相等匹配
print(d1.join(d2.set_index("姓名"),on="姓名")) #默认左连接  根据姓名相同匹配
print(d1.join(d2.set_index("姓名"),on="姓名",how="right")) #右连接  根据姓名相同匹配
print(d1.join(d2.set_index("姓名"),on="姓名",how="inner")) #内连接  根据姓名相同匹配 相当于索引的交集
print(d1.join(d2.set_index("姓名"),on="姓名",how="outer")) #外连接  根据姓名相同匹配 相当于索引的并集

    姓名    年龄
A  NaN  18.0
B   李四  18.0
C   王五  19.0
D   赵六  20.0
E   钱七   NaN
Z   张三   NaN
   姓名   学号
A  张三  001
D  李四  003
C  孙五  006
E  周六  008
    姓名    年龄 姓名_r   学号
A  NaN  18.0   张三  001
B   李四  18.0  NaN  NaN
C   王五  19.0   孙五  006
D   赵六  20.0   李四  003
E   钱七   NaN   周六  008
Z   张三   NaN  NaN  NaN
    姓名    年龄   学号
A  NaN  18.0  NaN
B   李四  18.0  003
C   王五  19.0  NaN
D   赵六  20.0  NaN
E   钱七   NaN  NaN
Z   张三   NaN  001
     姓名    年龄   学号
Z    张三   NaN  001
B    李四  18.0  003
NaN  孙五   NaN  006
NaN  周六   NaN  008
   姓名    年龄   学号
B  李四  18.0  003
Z  张三   NaN  001
      姓名    年龄   学号
A    NaN  18.0  NaN
B     李四  18.0  003
C     王五  19.0  NaN
D     赵六  20.0  NaN
E     钱七   NaN  NaN
Z     张三   NaN  001
NaN   孙五   NaN  006
NaN   周六   NaN  008

pandas加载数据

read_excel()：从excel文件中读取数据；
read_csv()：从csv文件中读取数据；
read_clipboard()：从剪切板中数据；
read_html()：从网页中读取数据；
read_json()：从 json 格式文本中读取数据；
read_pickle()：从pickle文件中读取数据；

设置Excel的属性

io：文件路径，可以是本地文件也可以是网络文件，支持xls、xlsx、xlsm等格式；
sheet_name：表单序号或名称，可以是一个列表，表示同时读取多个表单，默认为第一个表单；
hearder：表头，可以是整数或整数列表，默认为第一行；
names：指定列名，默认为表头；
index_col：索引列，可以是整数或整数列表；
usecols：使用到的列，默认加载所有列，如果需要加载某些列可指定这些列的序号；
dtype：指定每一列的数据类型；
skiprows：跳过多少行，常用于表的最开始几行为说明性文档的情景；
nrows：解析多少行；

数据显示的方法及关键属性

get_option(属性名)：获取相应的属性值；
set_option(属性名，值)：设置相应的属性值；
reset_option(属性名)：重置相应的属性值，恢复成默认值；
describe_option(属性名)：获取相应的属性描述信息，包括默认值，当前值等信息；
option_context(属性名)：设置临时的属性值，主要用于上下文管理器中；
显示设置中经常使用到的一些属性如下：
display.max_rows：显示的最大行数，默认为60行，超过60行时，只显示前5行、后5行，其他行用省略号表示，None表示不限制，显示所有行；
display.max_columns：显示的最大列数，默认为0，根据宽度自动确定，显示不下时，中间列用省略号表示，None表示不限制，显示所有；
display.expand_frame_repr：是否换行打印超过宽度的数据，默认为True，当不限制列的数量，同时一行又放不下那么多列信息时，默认会自动换行，可设置为False，这样会添加水平滚动条，在一行显示；
display_max_colwidth：显示的最大列宽，默认为50个字符，超出以省略号表示，None表示不限制；
display.precision：设置小数显示精度，默认为6位。

缺失值处理方法

删除法：直接将包含缺失值的记录删除，常用于缺失值比例非常低，如5%以内；
替换法：用某种值直接替换缺失值，例如连续变量的均值或中位数，离散变量的众数等；
插补法：根据其他已观测值进行预测，例如K近邻、回归插补法等；
Pandas中提供了强大的缺失值处理，相关方法如下：
dropna()：删除包含缺失值的行，可通过axis参数设置删除所在列，通过thresh参数指定阈值，只有非空值大于该阈值的行或列才保留；
fillna()：用指定值填充缺失值，可为不同的列指定不同的填充值，此时传递一个字典，键为列名，值为该列缺失值的填充值，可通过method参数指定填充方式；通过limit参数限定填充的数量；
isna()或isnull()：判断元素是否为缺失值，如果元素为缺失值，则对应位置为True，否则为False。

import pandas as pd
data = pd.read_csv('anime.csv',encoding='utf-8')
print(data.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 12294 entries, 0 to 12293
Data columns (total 7 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   anime_id  12294 non-null  int64  
 1   name      12294 non-null  object 
 2   genre     12232 non-null  object 
 3   type      12269 non-null  object 
 4   episodes  12294 non-null  object 
 5   rating    12064 non-null  float64
 6   members   12294 non-null  int64  
dtypes: float64(1), int64(2), object(4)
memory usage: 672.5+ KB
None

import numpy as np
s_names = ['aa','bb','cc','dd','ee','ff','gg','hh','mm','nn']
s_sex = np.random.choice(['男','女'],size = len(s_names))
s_class = np.random.choice(['A','B','C'],size=len(s_names))
score = np.random.choice(range(50,100),size=len(s_names))
p_1 = pd.DataFrame({'班级':s_class,'姓名':s_names,'性别':s_sex,'分数':score})
print(p_1)
group = p_1.groupby('班级')
print(group.groups)
print(group.agg({'分数':[np.min,np.max]}))
# 当transform作用于单列Series时较为简单 ，对salary列进行transform变换我们可以传入任意的非聚合类函数
# p_1['min_fen'] = group['分数'].transform(lambda x:x - np.min(x)) #按照分组 A，B,C分成三类，去当中最小值，然后分别与分类中的元素进行相减
# print(p_1)
print(group.filter(lambda x:np.mean(x['分数']) > 80))
print(p_1.groupby(['班级','性别'])['分数'].mean())

  班级  姓名 性别  分数
0  B  aa  男  59
1  A  bb  女  94
2  A  cc  女  50
3  C  dd  男  83
4  C  ee  女  74
5  C  ff  男  54
6  A  gg  男  77
7  B  hh  女  63
8  C  mm  女  54
9  C  nn  男  67
{'A': [1, 2, 6], 'B': [0, 7], 'C': [3, 4, 5, 8, 9]}
     分数     
   amin amax
班级          
A    50   94
B    59   63
C    54   83
Empty DataFrame
Columns: [班级, 姓名, 性别, 分数]
Index: []
班级  性别
A   女     72.0
    男     77.0
B   女     63.0
    男     59.0
C   女     64.0
    男     68.0
Name: 分数, dtype: float64

Pandas中的数据合并操作

数据合并是指将多个数据按照一定的规则合并到一起。在实际应用中，常常涉及多个数据的联合操作，而这些数据又保存在不同的文件中，此时需要先进行合并，再执行相关操作。Pandas中提供了一些数据合并的方法，例如merge()、contact()等。
merge()方法，按照某列或某些列将两个数据对象进行合并，与前面介绍的DataFrame中的join()方法非常相似。
left：左边的数据对象；
right：右边的数据对象；
how：连接方式，默认为inner，此外还有left、right、outer等；
on：连接的列名称，必须在两个对象中，默认以两个对象的列名的交集作为连接键；
left_on:左边对象中用于连接的键的列名；
right_on:右边对象中用于连接的键的列名；
left_index:使用左边的行索引作为连接键；
right_index:使用右边的行索引作为连接键；
sort:是否将合并的数据排序，默认为False；
suffixes：列名相同时，指定的后缀。

s_names = pd.Series(['张三','李四','王五','赵六','钱七'],index=list('ABCDE'))
s_ages = pd.Series([18,20,18,19],index=list('ADBC'))
s_nums = pd.Series(['001','003','006','008'],index=list('ADCE'))
s_names_2 = pd.Series(['张三','李四','孙五','周六'],index= list('ADCE'))
d_1 = pd.DataFrame({'姓名':s_names,'年龄':s_ages})
print(d_1)
d_2 = pd.DataFrame({'姓名':s_names_2,'学号':s_nums})
print(d_2)
print(pd.merge(d_1,d_2)) #以姓名作为连接
# print(pd.merge(d_1,d_2,how='left'))
# print(pd.merge(d_1,d_2,how='right'))
# print(pd.merge(d_1,d_2,how='outer')) #相当于并集
print(pd.merge(d_1,d_2,left_index=True,right_index=True))

   姓名    年龄
A  张三  18.0
B  李四  18.0
C  王五  19.0
D  赵六  20.0
E  钱七   NaN
   姓名   学号
A  张三  001
D  李四  003
C  孙五  006
E  周六  008
   姓名    年龄   学号
0  张三  18.0  001
1  李四  18.0  003
  姓名_x    年龄 姓名_y   学号
A   张三  18.0   张三  001
C   王五  19.0   孙五  006
D   赵六  20.0   李四  003
E   钱七   NaN   周六  008

contact()方法，沿着一条轴，将多个对象堆叠起来，关键参数如下：

objs：需合并的对象序列；
axis：指定合并的轴，0/‘index’, 1/‘columns’，默认为0；
join：连接方式，只有inner和outer，默认为outer；
ignore_index：是否忽略索引，默认为False；
verify_integrity:验证完整性，较为耗时，默认为False；

print(pd.concat([d_1,d_2],axis=0))
print(pd.concat([d_1,d_2],axis=1))
print(pd.concat([d_1,d_2],axis=1,join='inner'))

   姓名    年龄   学号
A  张三  18.0  NaN
B  李四  18.0  NaN
C  王五  19.0  NaN
D  赵六  20.0  NaN
E  钱七   NaN  NaN
A  张三   NaN  001
D  李四   NaN  003
C  孙五   NaN  006
E  周六   NaN  008
   姓名    年龄   姓名   学号
A  张三  18.0   张三  001
B  李四  18.0  NaN  NaN
C  王五  19.0   孙五  006
D  赵六  20.0   李四  003
E  钱七   NaN   周六  008
   姓名    年龄  姓名   学号
A  张三  18.0  张三  001
C  王五  19.0  孙五  006
D  赵六  20.0  李四  003
E  钱七   NaN  周六  008