DataFrame基本操作 <二> 加，减，求和，lambda，索引排序（row，cols，非内容）

首先来一个别致的列表创建，我有印象但是从来没用过，突然发现很好用也很优雅

a=list('qwe13qaew')
print(a)

运行结果

['q', 'w', 'e', '1', '3', 'q', 'a', 'e', 'w']

 

实际应用也很有效果，生成两个实例用于练习

df3 = pd.DataFrame(np.arange(12).reshape((3, 4)),
                    index=['Qingdao', 'Jinan', 'Yantai'],
                    columns=list('abcd'))
df4 = pd.DataFrame(np.arange(20).reshape((4, 5)),
                    index=['Qingdao', 'Jinan', 'Yantai', 'Linyi'],
                    columns=list('abcde'))   #这种用法很别致啊直接
print(df3)

print(df4)

运行结果

         a  b   c   d
Qingdao  0  1   2   3
Jinan    4  5   6   7
Yantai   8  9  10  11

          a   b   c   d   e
Qingdao   0   1   2   3   4
Jinan     5   6   7   8   9
Yantai   10  11  12  13  14
Linyi    15  16  17  18  19

加法运算

print（df3 + df4 ）# 注意行列数不同的两个 DataFrame 相加行列的对齐和值填充。

运行结果

         a  b   c   d
Qingdao  0  1   2   3
Jinan    4  5   6   7
Yantai   8  9  10  11
          a   b   c   d   e
Qingdao   0   1   2   3   4
Jinan     5   6   7   8   9
Yantai   10  11  12  13  14
Linyi    15  16  17  18  19
#########################################
            a     b     c     d   e
Jinan     9.0  11.0  13.0  15.0 NaN
Linyi     NaN   NaN   NaN   NaN NaN
Qingdao   0.0   2.0   4.0   6.0 NaN
Yantai   18.0  20.0  22.0  24.0 NaN

相当牛逼，index跟‘name’相同的直接加，不存在的用缺省值定住。

填充后的加法运算

print(df3.add(df4, fill_value=0)) # 注意无效值用 0 填充后的加法运算

print(df3.add(df4, fill_value=100))

运行结果

            a     b     c     d     e
Jinan     9.0  11.0  13.0  15.0   9.0
Linyi    15.0  16.0  17.0  18.0  19.0
Qingdao   0.0   2.0   4.0   6.0   4.0
Yantai   18.0  20.0  22.0  24.0  14.0
             a      b      c      d      e
Jinan      9.0   11.0   13.0   15.0  109.0
Linyi    115.0  116.0  117.0  118.0  119.0
Qingdao    0.0    2.0    4.0    6.0  104.0
Yantai    18.0   20.0   22.0   24.0  114.0

减法运算

s3 = df3.iloc[0]
print(s3)
print(df3 - s3 ) # 减法缺省是按列对齐去减，并广播至每一行。

运行结果

a    0
b    1
c    2
d    3
Name: Qingdao, dtype: int32
         a  b  c  d
Qingdao  0  0  0  0
Jinan    4  4  4  4
Yantai   8  8  8  8

每一行都减去了0,1,2,3

对比一下

s4=[4,5,6,7]
print(df3 - s4) # 减法缺省是按列对齐去减，并广播至每一行。

运算结果

         a  b  c  d
Qingdao -4 -4 -4 -4
Jinan    0  0  0  0
Yantai   4  4  4  4

 

 下边这个也得慢慢理解

s3 = df3['b'] 通过指定轴，按行对齐去减，并广播至每一列。

s3 = df3['b']
df3.sub(s3, axis=0) # 通过指定轴，按行对齐去减，并广播至每一列。

运行结果

         a  b   c   d
Qingdao  0  1   2   3
Jinan    4  5   6   7
Yantai   8  9  10  11
Qingdao    1
Jinan      5
Yantai     9
Name: b, dtype: int32
         a  b  c  d
Qingdao -1  0  1  2   #一行都减去1
Jinan   -1  0  1  2   #这一行都减去5
Yantai  -1  0  1  2   #这一行都减去9

求和

print(df3.sum()  )     # 按行对每一列求和
print(df3.sum(axis=1)) # 按列对每一行求和

#这里就要用到对axis的理解，axis为0是垂直方向，axis为1，就是水平方向，这里不能把0,1理解成行，列，应该理解成垂直与水平

运行结果

         a  b   c   d
Qingdao  0  1   2   3
Jinan    4  5   6   7
Yantai   8  9  10  11
#上边是dfs

a    12
b    15
c    18
d    21
dtype: int64
Qingdao     6
Jinan      22
Yantai     38
dtype: int64

lambda表达式处理语句

垂直方向的最大值-最小值

a=df3.apply(lambda x: x.max() - x.min()) # 按行对每一列自定义处理
print(a)

#这里的行其实就是垂直方向，axis=0的意思
#lambda表达式的意思是每一列（垂直方向就是列）的最大值减去最小值

运行结果

         a  b   c   d
Qingdao  0  1   2   3
Jinan    4  5   6   7
Yantai   8  9  10  11
a    8     #8-0
b    8     #9-1
c    8     #10-2
d    8     #11-3
dtype: int64

水平方向的最大值减去最小值

a=df3.apply((lambda x: x.max() - x.min()), axis=1) # 按列对每一行自定义处理
print(a)

运行结果

         a  b   c   d
Qingdao  0  1   2   3
Jinan    4  5   6   7
Yantai   8  9  10  11
Qingdao    3
Jinan      3
Yantai     3
dtype: int64

对每一个单元应用一个处理

a=df3.applymap(lambda x: '%.2f' % x) # 对每一个单元应用一个处理
print(a)

#转化成显示2位小数的浮点类型。这个我不会写，但是先记住用法，以后回来查

运行结果

         a  b   c   d
Qingdao  0  1   2   3
Jinan    4  5   6   7
Yantai   8  9  10  11
            a     b      c      d
Qingdao  0.00  1.00   2.00   3.00
Jinan    4.00  5.00   6.00   7.00
Yantai   8.00  9.00  10.00  11.00

索引排序
按行索引排序 （垂直方向，index）

a=df3.sort_index() # 按行索引排序
print(a)

#df.sort_index()就是按照垂直方向排序，A-Z的顺序排，j-q-y的顺序

运行结果

         a  b   c   d
Qingdao  0  1   2   3
Jinan    4  5   6   7
Yantai   8  9  10  11
         a  b   c   d
Jinan    4  5   6   7
Qingdao  0  1   2   3
Yantai   8  9  10  11

按列索引倒序排序（水平倒叙排序）

a=df3.sort_index(axis=1, ascending=False) # 按列索引倒序排序
print(a)

#这个ascending我得记一下，算了，我遍布下去了，反正记住就行了，ascending=False可以显示出来结果，不加的话，还显示原来的dfs

#可以理解成ps一层一层的，df3的优先级是最高的，这里ascending=false 把df3的优先级给降下去了。先这么理解吧，不对的话以后再改

运行结果

         a  b   c   d
Qingdao  0  1   2   3
Jinan    4  5   6   7
Yantai   8  9  10  11
          d   c  b  a
Qingdao   3   2  1  0
Jinan     7   6  5  4
Yantai   11  10  9  8

 

这些先到这里

转载于:https://www.cnblogs.com/PYlog/p/9142759.html