ps:还有一些没学完，但是这些已经leisi了
基础使用
pandas基础的创建单元
s = pd.Series([1, 3, 6, np.nan, 44, 1])
dates = pd.date_range('1-1-1', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=['a', 'b', 'c', 'd'])
创建一个类似excel的二维数据 左边那一栏 上面那一栏
df = pd.DataFrame({
'a': 1,
'b': pd.Timestamp('20221020'),
'c': pd.Series(1, index=list(range(5,9)), dtype='float32'),
'd': np.array([3] * 4, dtype='int32'),
'e': pd.Categorical(["test", "train", "test", "train"]),
'f': 'foo'
})
0 1.0
1 3.0
2 6.0
3 NaN
4 44.0
5 1.0
dtype: float64
DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03', '2001-01-04',
'2001-01-05', '2001-01-06'],
dtype='datetime64[ns]', freq='D')
a b c d
2001-01-01 -0.475200 1.366880 0.132136 0.925819
2001-01-02 -0.585239 -1.386966 -1.296105 0.061802
2001-01-03 -0.164937 1.313903 -1.428874 -0.184463
2001-01-04 1.492335 1.331895 -0.176759 -2.846150
2001-01-05 -1.186766 1.891096 1.588832 -0.118273
2001-01-06 0.189556 -0.061725 -0.833017 1.085365
a b c d e f
5 1 2022-10-20 1.0 3 test foo
6 1 2022-10-20 1.0 3 train foo
7 1 2022-10-20 1.0 3 test foo
8 1 2022-10-20 1.0 3 train foo
对于dataframe数据的简单查看
a int64
b datetime64[ns]
c float32
d int32
e category
f object
dtype: object
Int64Index([5, 6, 7, 8], dtype='int64')
Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
[[1 Timestamp('2022-10-20 00:00:00') 1.0 3 'test' 'foo']
[1 Timestamp('2022-10-20 00:00:00') 1.0 3 'train' 'foo']
[1 Timestamp('2022-10-20 00:00:00') 1.0 3 'test' 'foo']
[1 Timestamp('2022-10-20 00:00:00') 1.0 3 'train' 'foo']]
a c d
count 4.0 4.0 4.0
mean 1.0 1.0 3.0
std 0.0 0.0 0.0
min 1.0 1.0 3.0
25% 1.0 1.0 3.0
50% 1.0 1.0 3.0
75% 1.0 1.0 3.0
max 1.0 1.0 3.0
5 ... 8
a 1 ... 1
b 2022-10-20 00:00:00 ... 2022-10-20 00:00:00
c 1.0 ... 1.0
d 3 ... 3
e test ... train
f foo ... foo
[6 rows x 4 columns]
sort的操作
print(df.sort_index(axis=1,ascending=False))
1代表对左右的操作 FALSE代表是升序，TRUE是降序
print(df.sort_index(axis=0,ascending=False))
f e d c b a
5 foo test 3 1.0 2022-10-20 1
6 foo train 3 1.0 2022-10-20 1
7 foo test 3 1.0 2022-10-20 1
8 foo train 3 1.0 2022-10-20 1
a b c d e f
8 1 2022-10-20 1.0 3 train foo
7 1 2022-10-20 1.0 3 test foo
6 1 2022-10-20 1.0 3 train foo
5 1 2022-10-20 1.0 3 test foo
选择数据
data = pd.date_range('20221020',periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=data,columns=['a','b','c','d'])
输出，基础的数据
a b c d
2022-10-20 0 1 2 3
2022-10-21 4 5 6 7
2022-10-22 8 9 10 11
2022-10-23 12 13 14 15
2022-10-24 16 17 18 19
2022-10-25 20 21 22 23
获取一列的数据
print(df['a'])
2022-10-20 0
2022-10-21 4
2022-10-22 8
2022-10-23 12
2022-10-24 16
2022-10-25 20
获取多行的数据1
print(df[0:3])
a b c d
2022-10-20 0 1 2 3
2022-10-21 4 5 6 7
2022-10-22 8 9 10 11
获取多行的数据2
print(df['20221020':'20221022'])
a b c d
2022-10-20 0 1 2 3
2022-10-21 4 5 6 7
2022-10-22 8 9 10 11
loc的用法
loc是通过标签来获取数据
获取一行的
print(df.loc['20221022'])
a 8
b 9
c 10
d 11
Name: 2022-10-22 00:00:00, dtype: int32
获取上面那一栏的数据
print(df.loc[:,['a','b']])
a b
2022-10-20 0 1
2022-10-21 4 5
2022-10-22 8 9
2022-10-23 12 13
2022-10-24 16 17
2022-10-25 20 21
获取多个列/行的数据
print(df.loc['2022-10-20',['a','b']])
a 0
b 1
Name: 2022-10-20 00:00:00, dtype: int32
print(df[2:3])
a b c d
2022-10-22 8 9 10 11
a 12
b 13
c 14
d 15
iloc的用法
类似列表的索引
print(df.iloc[3])
一个数据的时候是对行进行一个索取
a 12
b 13
c 14
d 15
Name: 2022-10-23 00:00:00, dtype: int32
第四行第二个数据的选取（因为是类似列表的选取）
print(df.iloc[3,1])
13
切片的取法
类似列表
print(df.iloc[3:5,1:2])
b
2022-10-23 13
2022-10-24 17
多个的筛选
print(df.iloc[[1,3,5],1:2])
b
2022-10-21 5
2022-10-23 13
2022-10-25 21
数据的筛选
对整个的df进行筛选
print(df>8)
a b c d
2022-10-20 False False False False
2022-10-21 False False False False
2022-10-22 False True True True
2022-10-23 True True True True
2022-10-24 True True True True
2022-10-25 True True True True
对整个的df的a列进行筛选
print(df.a>8)
2022-10-20 False
2022-10-21 False
2022-10-22 False
2022-10-23 True
2022-10-24 True
2022-10-25 True
通过筛选结果，来选取数据
print(df[df.a>8])
这是先通过筛选a列，然后以a列作为标准
去筛选出a列所代表的那一行是可以的
进而得出结果
输出
a b c d
2022-10-23 12 13 14 15
2022-10-24 16 17 18 19
2022-10-25 20 21 22 23
值的修改
就是相当与直接赋值发
df.iloc[2,2]=1111
df.loc['20221020','b']=2222
df[df.a>4]=0
df['a']=22222
df['a'] = np.arange(6).reshape(6,1)
df['a'] = pd.Series([1,2,3,4,5,6],index=pd.date_range('20221020',periods=6))
插入行与列
插入列1
df.loc[:, 'charu'] = df['d']-df['a']
直接赋值法，如果df当中没有，就会创建一个
df.insert(loc=2, column='chasini', value=df['d']-df['a'])
插入列2 assign
df1 = df1.assign(f = ['f','f','f'])
print(df1)
插入行
df.loc[5]= [1,2,3,4,5,6]
类似上面的直接赋值法，有则赋值，无则创建
处理丢失的数据
丢弃数据
print(df.dropna(axis=0,how='any'))
填充数据
print(df.fillna(value=0))
判断是否有丢失的数据
print(df.isnull())
print(np.any(df.isnull())==True)
字符串的操作
df = pd.DataFrame(data={'a':['笑死','深圳大学'],
'b':['aa','a']})
df['a']=df['a'].str.replace('深圳','sz')
print(df)
a b
0 笑死 aa
1 sz大学 a
contact合成
先来几个frame
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*2,columns=['a','b','c','d'])
print(df1,df2,df3)
a b c d
0 0.0 0.0 0.0 0.0
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0
a b c d
0 1.0 1.0 1.0 1.0
1 1.0 1.0 1.0 1.0
2 1.0 1.0 1.0 1.0
a b c d
0 2.0 2.0 2.0 2.0
1 2.0 2.0 2.0 2.0
2 2.0 2.0 2.0 2.0
res = pd.concat([df1,df2,df3],axis = 1,ignore_index=True)
0 1 2 3 4 5 6 7 8 9 10 11
0 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0
1 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0
2 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0
比较简单
下面是，如果标签不一样，或者有冲突怎么办？
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['a','b','c','d'],index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['b','c','d','e'],index=[2,3,4])
a b c d
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0
3 0.0 0.0 0.0 0.0
b c d e
2 1.0 1.0 1.0 1.0
3 1.0 1.0 1.0 1.0
4 1.0 1.0 1.0 1.0
如果使用contact，那么他的操作就是一个都不会拉下
如果数据a没有x标签，但是数据b有，那么表现出来a当中的x标签就会是nan
如果数据a，b都有相同的一个标签，那么就会出现2个标签，用于区分
print(pd.concat([df1,df2],axis=0))
print(pd.concat([df1,df2],axis=1))
a b c d e
1 0.0 0.0 0.0 0.0 NaN
2 0.0 0.0 0.0 0.0 NaN
3 0.0 0.0 0.0 0.0 NaN
2 NaN 1.0 1.0 1.0 1.0
3 NaN 1.0 1.0 1.0 1.0
4 NaN 1.0 1.0 1.0 1.0
a b c d b c d e
1 0.0 0.0 0.0 0.0 NaN NaN NaN NaN
2 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
3 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
4 NaN NaN NaN NaN 1.0 1.0 1.0 1.0
所以，为了避免出现nan
contact里面有个参数叫join，他能决定合并的类型
res = pd.concat([df1,df2],join='inner')
res = pd.concat([df1,df2],join='inner',ignore_index=True)
print(res)
默认的axis是0
输出
b c d
1 0.0 0.0 0.0
2 0.0 0.0 0.0
3 0.0 0.0 0.0
2 1.0 1.0 1.0
3 1.0 1.0 1.0
4 1.0 1.0 1.0
merge的合并
merge的特点是只对两个数据进行合并
创建数据
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k2','k3'],
'c':['c0','c1','c2','c3'],
'd':['d0','d1','d2','d3']})
key a b
0 k0 a0 b0
1 k1 a1 b1
2 k2 a2 b2
3 k3 a3 b3
key c d
0 k0 c0 d0
1 k1 c1 d1
2 k2 c2 d2
3 k3 c3 d3
开始合并
res = pd.merge(left,right,on='key')
print(res)
on 表示 key那一栏会被合并，并且默认对于key只会输出相同参数的行列
就是相当于把key变成了index
如果是除了key以外的，有相同的标签，那么也会分裂成两个（下面会讲）
输出
key a b c d
0 k0 a0 b0 c0 d0
1 k1 a1 b1 c1 d1
2 k2 a2 b2 c2 d2
3 k3 a3 b3 c3 d3
就是left里 key1仅对应一个值
而right里面，key1却对应了两个值
这个时候，left的a就会在left与right同一个值的时候，进行一个复制
为了保证数据的完整填充
left = pd.DataFrame({'key1':['k0','k1','k2'],
'a':['a0','a1','a2']})
right = pd.DataFrame({'key1':['k0','k0','k1','k1','k2','k2'],
'c':['c01','c02','c11','c12','c21','c22']})
res = pd.merge(left,right)
print(res)
key1 a c
0 k0 a0 c01
1 k0 a0 c02
2 k1 a1 c11
3 k1 a1 c12
4 k2 a2 c21
5 k2 a2 c22
就是left的al对了2个值
而rigt的al也对了2个值
为了数据的完整性
所以这两个值要分别遍历，因为他们都是属于al这个大家庭
就是
这个是key1的al有两个值a1 ,a2
而key2的al也有两个值c1 ,c2
那么就会输出 a1c1
a1c2
a2c1
a2c2
left = pd.DataFrame({'key':['al','al','k1','k1','k2'],
'a':['a01','a02','a11','a12','a2']})
right = pd.DataFrame({'key':['al','al','k1','k1','k2','k2'],
'c':['c01','c02','c11','c12','c21','c22']})
res = pd.merge(left,right)
print('here',res)
后面的k1同理
输出
key a c
0 al a01 c01
1 al a01 c02
2 al a02 c01
3 al a02 c02
4 k1 a11 c11
5 k1 a11 c12
6 k1 a12 c11
7 k1 a12 c12
8 k2 a2 c21
9 k2 a2 c22
就是两个数据的值是你玩你的，我玩我的，没什么交集
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k4','k5'],
'c':['c0','c1','c2','c3'],
'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,how='inner')
print(res)
因为inner
所以 对于作为index的key来说，之后有k0,k1被输出，其余数据一样
key a b c d
0 k0 a0 b0 c0 d0
1 k1 a1 b1 c1 d1
left
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k4','k5'],
'c':['c0','c1','c2','c3'],
'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,how='left')
print(res)
key a b c d
0 k0 a0 b0 c0 d0
1 k1 a1 b1 c1 d1
2 k2 a2 b2 NaN NaN
3 k3 a3 b3 NaN NaN
outer
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k4','k5'],
'c':['c0','c1','c2','c3'],
'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,how='outer')
print(res)
key a b c d
0 k0 a0 b0 c0 d0
1 k1 a1 b1 c1 d1
2 k2 a2 b2 NaN NaN
3 k3 a3 b3 NaN NaN
4 k4 NaN NaN c2 d2
5 k5 NaN NaN c3 d3
多个key，就是多个相同的标签
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
'a':['a0','a1','a2','a3'],
'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k4','k5'],
'a':['ac0','ac1','ac2','ac3'],
'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,on='key')
print(res)
key a_x b a_y d
0 k0 a0 b0 ac0 d0
1 k1 a1 b1 ac1 d1
改变上面为了区分的后缀 _X _y
使用suffixes=[‘left’,’right’],，靠左的就是附在左边的后缀（具体看代码）
res = pd.merge(left,right,on='key',suffixes=['left','right'])
print(res)
key aleft b aright d
0 k0 a0 b0 ac0 d0
1 k1 a1 b1 ac1 d1
累死。。。
groupyby的使用
先来一个数据
（ ps:这里的key里面有a,b但是column里面也有a,b，请注意区分，实在不想改了）
df = pd.DataFrame({'key':['a','b','a','b','a','b','a','b'],
'key2':['x','y','x','y','m','n','m','n'],
'a':[int(i) for i in range(1,9)],
'b':[int(i) for i in range(9,17)]})
key key2 a b
0 a x 1 9
1 b y 2 10
2 a x 3 11
3 b y 4 12
4 a m 5 13
5 b n 6 14
6 a m 7 15
7 b n 8 16
print(df.groupby('key').sum())
就是对key里面的同类进行一个合并
key里面的a，b有很多，那么就会分成a,b两组（指的是key的值而不是a，b标签）
后面有写就是sum，a里面是和key同类的行，就相加
只会输出，那些可以求和的数据
还有mean…
a b
key
a 16 48
b 20 52
一个方法，可以不让key变成索引，只是单纯的进行归类、
print(df.groupby('key',as_index=False).sum())
key a b
0 a 16 48
1 b 20 52
但是我们又发现key里面也有同类项，所以我们又可以进行一个多次分组
代码：
print(df.groupby(['key','key2']).mean())
a b
key key2
a m 6.0 14.0
x 2.0 10.0
b n 7.0 15.0
y 3.0 11.0
对于分组我们也可以获得我们想要的多个数据
在这里插入代码片print(df.groupby('key').agg([np.sum,np.mean,np.std]))
a b
sum mean std sum mean std
key
a 16 4.0 2.581989 48 12.0 2.581989
b 20 5.0 2.581989 52 13.0 2.581989
当然，我们也可以分别获取我们想要的数据
print(df.groupby('key').agg({'a':np.sum,'b':np.std}))
输出，记得是key里面a的那一列的数据
sum mean std
key
a 16 4.0 2.581989
b 20 5.0 2.581989
and
print(df.groupby('key')['a'].agg([np.sum,np.mean,np.std]))
输出，记得是key里面a的那一列的数据
sum mean std
key
a 16 4.0 2.581989
b 20 5.0 2.581989
因为groupby输出的是一个生成器，所以我们不能直接print
所以我们可以进行一个for循环
g = df.groupby('key')
for name,group in g:
print(name)
print(group)
key key2 a b
0 a x 1 9
2 a x 3 11
4 a m 5 13
6 a m 7 15
b
key key2 a b
1 b y 2 10
3 b y 4 12
5 b n 6 14
7 b n 8 16
我们也是可以直接获取到其中的一份数据
代码
g.get_group('a')
输出
key key2 a b
0 a x 1 9
2 a x 3 11
4 a m 5 13
6 a m 7 15
当然，也可以有二级分组的数据
g = df.groupby(['key','key2'])
for x,y in g:
print(x)
print(y)
但是会复杂很多，分出来的组也会变多
输出
('a', 'm')
key key2 a b
4 a m 5 13
6 a m 7 15
('a', 'x')
key key2 a b
0 a x 1 9
2 a x 3 11
('b', 'n')
key key2 a b
5 b n 6 14
7 b n 8 16
('b', 'y')
key key2 a b
1 b y 2 10
3 b y 4 12
当然，类似上面的方法
我们也可以直接获取到某一个组的数据
print(g.get_group([（'a','x'）))
这里要注意里面要写的是 ( )
输出
key key2 a b
0 a x 1 9
2 a x 3 11
累死了
最后一部分了
multiindex的使用
较难，但是类似groupby
创建数据
df = pd.DataFrame({'key':['a','b','a','b','a','b','a','b'],
'key2':['x','x','y','y','m','m','n','n'],
'a':[int(i) for i in range(1,9)],
'b':[int(i) for i in range(9,17)]})
df = df.sort_values(by='key',ascending=True)
print(df)
key key2 a b
0 a x 1 9
2 a y 3 11
4 a m 5 13
6 a n 7 15
1 b x 2 10
3 b y 4 12
5 b m 6 14
7 b n 8 16
（当然我们也有另外的方式整理数据
print(df.sort_index(axis=0))
0表示对数值方向的数据进行梳理
key key2 a b
0 a x 1 9
1 b x 2 10
2 a y 3 11
3 b y 4 12
4 a m 5 13
5 b m 6 14
6 a n 7 15
7 b n 8 16
))))
然后，我们进行一个分组
ser = df.groupby(['key','key2'])['a'].mean()
print(ser)
key key2
a m 5.0
n 7.0
x 1.0
y 3.0
b m 6.0
n 8.0
x 2.0
y 4.0
我们可以获取到全部的index
print(ser.index)
MultiIndex([('a', 'm'),
('a', 'n'),
('a', 'x'),
('a', 'y'),
('b', 'm'),
('b', 'n'),
('b', 'x'),
('b', 'y')],
names=['key', 'key2'])
然后我们也可以让ser的index有所改变
print('here',ser.unstack())
key2 m n x y
key
a 5.0 7.0 1.0 3.0
b 6.0 8.0 2.0 4.0
然后我们可以得知，unstack的作用就是将数据变成一层一层的，有多个index
然后是选取数据的方法
print(ser.loc['a'])
print(ser.loc['a','m'])
print(ser.loc[:,'m'])
key2
m 5.0
n 7.0
x 1.0
y 3.0
Name: a, dtype: float64
5.0
key
a 5.0
b 6.0
Name: a, dtype: float64
先来几个数据
df = pd.DataFrame({'key':['one','two','one','two','one','two','one','two'],
'key2':['x','x','y','y','m','m','n','n'],
'a':[int(i) for i in range(1,9)],
'b':[int(i) for i in range(9,17)]})
df1 = df.set_index(['key','key2'])
df1 = df1.sort_index()
key key2 a b
one m 5 13
n 7 15
x 1 9
y 3 11
two m 6 14
n 8 16
x 2 10
y 4 12
选取数据，用loc，用法一致
print(df1.loc[('one','m')])
key2 a b
m 5 13
n 7 15
x 1 9
y 3 11
and
print(df1.loc[('one','m')])
a 5
b 13
Name: (one, m), dtype: int64
下一级，如果要去index外的标签数据捏？
print(df1.loc[('one','m'),'a'])
and
print(df1.loc[('one',['m','n']),:])
a b
key key2
one m 5 13
n 7 15
同理，继续下一级
print(df1.loc[('one',['m','n']),'a'])
print(df1.loc[('one',['m','n']),['a','b']])
输出，应该不难吧
key key2
one m 5
n 7
Name: a, dtype: int64
a b
key key2
one m 5 13
n 7 15
万一index的值比较多怎么办捏？
print(df1.loc[(slice(None),['m','n']),:])
Original: https://blog.csdn.net/weixin_73897131/article/details/127583568
Author: 别卷了好吗
Title: pandas学习日记
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/676507/
转载文章受原作者版权保护。转载请注明原作者出处！