python pandas 数据处理

 内容汇总目录：

df插入一行

相同列名df合并

df去极值

df行、列分别求和

https://blog.csdn.net/zhili8866/article/details/68134481

1、修改一个或多个列名

2、增加列、插入列、删除列或行

3、删除特定行或特定列，可以按照索引（行名）、列名、元素值来筛选

4、df两行之间运算

5、判断元素是否在Series中

将字符串类型日期修改为datetime日期类型

将df或者Series等分

1、df数据选取

2、set_index、reset_index、sort_index、reindex、sort_values

3、暴力修改索引

计算累积收益率

df中eval用法

df中数据格式转换

pandas.DataFrame.iterrows

pandas.Series.searchsorted

df插入一行

分两种情况，一、插入行没有索引；二、插入的行有索引，用reindex重新设置索引

df = pd.DataFrame(np.arange(12).reshape(3, 4), columns=list('abcd'))
df
Out[9]: 
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
df.loc[-1]=[1,1,1,1]
df
Out[12]: 
    a  b   c   d
 0  0  1   2   3
 1  4  5   6   7
 2  8  9  10  11
-1  1  1   1   1
df.loc[df.shape[0]+1]=[1,1,1,1]
df
Out[14]: 
    a  b   c   d
 0  0  1   2   3
 1  4  5   6   7
 2  8  9  10  11
-1  1  1   1   1
 5  1  1   1   1
df.index=['aa','bb','cb','dd','ee']
df
Out[24]: 
    a  b   c   d
aa  0  1   2   3
bb  4  5   6   7
cb  8  9  10  11
dd  1  1   1   1
ee  1  1   1   1

相同列名df合并

df.append(df)
Out[22]: 
   a  b   c   d         e
0  0  1   2   3 -1.564839
1  4  5   6   7 -0.268072
2  8  9  10  11  0.229017
0  0  1   2   3 -1.564839
1  4  5   6   7 -0.268072
2  8  9  10  11  0.229017

功能：df去极值

df = pd.DataFrame(np.arange(12).reshape(3, 4), columns=list('abcd'))
df.where(df<df.median(),df.median(),axis=1)
Out[73]: 
   a  b  c  d
0  0  1  2  3
1  4  5  6  7
2  4  5  6  7

功能：df行、列分别求和

#DataFrame行、列分别求和

from pandas import Series, DataFrame 
import pandas as pd 
import numpy as np
df = pd.DataFrame(np.arange(12).reshape(3, 4), columns=list('abcd'))
df
Out[31]: 
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
df['col_sum']=df.sum(axis=1)
df
Out[34]: 
   a  b   c   d  col_sum
0  0  1   2   3        6
1  4  5   6   7       22
2  8  9  10  11       38
df.ix['row_sum']=df.sum()
df
Out[36]: 
          a   b   c   d  col_sum
0         0   1   2   3        6
1         4   5   6   7       22
2         8   9  10  11       38
row_sum  12  15  18  21       66

 

功能：

1、修改一个或多个列名

2、增加列、插入列、删除列或行

3、删除特定行或特定列，可以按照索引（行名）、列名、元素值来筛选

4、df两行之间运算

5、判断元素是否在Series中

df = pd.DataFrame(np.arange(1, 17).reshape(4, 4), index=pd.date_range('2017/1/1', periods=4), columns=list('mnxy'))
df
Out[39]: 
                     m   n   x   y
2017-01-01   1   2   3   4
2017-01-02   5   6   7   8
2017-01-03   9  10  11  12
2017-01-04  13  14  15  16
# 修改特定（某一列或某几列）列名
df.rename(columns={'m': 'n', 'n': 'm'}, inplace=True)
df
Out[41]: 
                     n   m   x   y
2017-01-01   1   2   3   4
2017-01-02   5   6   7   8
2017-01-03   9  10  11  12
2017-01-04  13  14  15  16
# 增加列
df['mn']=1
df
Out[44]: 
                     n   m   x   y  mn
2017-01-01   1   2   3   4   1
2017-01-02   5   6   7   8   1
2017-01-03   9  10  11  12   1
2017-01-04  13  14  15  16   1
# 插入列
df.insert(1, 'e', 1000)  # 1为插入位置，1000为插入内容
df
Out[46]: 
                      n     e   m   x   y  mn
2017-01-01   1  1000   2   3   4   1
2017-01-02   5  1000   6   7   8   1
2017-01-03   9  1000  10  11  12   1
2017-01-04  13  1000  14  15  16   1
# 删除列
del df['mn']
df
Out[48]: 
                      n     e   m   x   y
2017-01-01   1  1000   2   3   4
2017-01-02   5  1000   6   7   8
2017-01-03   9  1000  10  11  12
2017-01-04  13  1000  14  15  16

# drop删除列，inplcae=False,不改变原数据，返回dataframe存放删除后的数据
# inplace=True,改变原数据，返回None
# drop比del好，del只能删除列，drop行和列都可以
df1 = df.drop(['m', 'n'], axis=1)
df
Out[50]: 
                      n     e   m   x   y
2017-01-01   1  1000   2   3   4
2017-01-02   5  1000   6   7   8
2017-01-03   9  1000  10  11  12
2017-01-04  13  1000  14  15  16
df1
Out[51]: 
                           e   x   y
2017-01-01  1000   3   4
2017-01-02  1000   7   8
2017-01-03  1000  11  12
2017-01-04  1000  15  16
df2 = df.drop(['m', 'n'], axis=1, inplace=True)
df
Out[53]: 
                         e   x   y
2017-01-01  1000   3   4
2017-01-02  1000   7   8
2017-01-03  1000  11  12
2017-01-04  1000  15  16
df2  #空

# drop删除行，与上面用法类似
df.index=['a','b','c','d']
df
Out[58]: 
      e   x   y
a  1000   3   4
b  1000   7   8
c  1000  11  12
d  1000  15  16
df.drop(['a'],inplace=True)
df
Out[60]: 
      e   x   y
b  1000   7   8
c  1000  11  12
d  1000  15  16

# 获取特定的几行
df = df.ix[['b','c']]

# 删除特定行，删除与选取类似
# 1、例如删除x列中为7的行
df = df[df['x'] != 7]
df
Out[65]: 
          e   x   y
c  1000  11  12
d  1000  15  16
# 2、删除多个非特定元素的行，如删除m列中为6和9的行
# 方法一：多删除几次即可
# 方法二：

#‘B’列中值为'one','two'的df
#df[df['B'].isin(['one','two'])]
#‘B’列中值不为‘one','two'的df
#df[~df['B'].isin(['one','two'])]
#索引中为’a‘，’b‘的df
#df[df.index.isin(['a','b')]
#索引中不为'b','b'的df
#df[~df.index.isin(['a','b'])]

# 删除特定列，例如索引为c的行中为某值（比如11）的列，即删去‘x’列
# 可以先转置，按照上面方法删除，再转置回来即可

# DataFrame两行相减
df.ix['f'] = df.ix['c'] - df.ix['d'] #这个以后要被Deprecated,用loc
df
Out[69]: 
      e   x   y
c  1000  11  12
d  1000  15  16
f     0  -4  -4
df.loc['g'] = df.loc['c'] - df.loc['d']  # 多用loc和iloc,用这两个就够了！！！！
df
Out[71]: 
      e   x   y
c  1000  11  12
d  1000  15  16
f     0  -4  -4
g     0  -4  -4

# 删除掉Series中小于3的数据
new_data = df['e'][df['e'] >= 3]
new_data
Out[73]: 
c    1000
d    1000
Name: e, dtype: int64
# 删除掉dataframe中小于0的数据
new_data = df[df >= 0]  # 将小于0的数据替换为NaN，可用dorpna()彻底删除
new_data
Out[75]: 
         e     x     y
c  1000  11.0  12.0
d  1000  15.0  16.0
f     0   NaN   NaN
g     0   NaN   NaN
new_data.dropna(inplace=True)
new_data
Out[77]: 
      e     x     y
c  1000  11.0  12.0
d  1000  15.0  16.0

 可参考博客    pandas 数据索引与选取

#接上面代码
# 判断某一元素是否在Series中
11 in df['x'].tolist()
Out[83]: True
# 判断某一些元素是否在Series中
df['x'].isin(['a', 'b', 11])  # 判断元素'a','b',11是否在Series中
Out[85]: 
c     True
d    False
f    False
g    False
Name: x, dtype: bool

功能：将字符串类型日期修改为datetime日期类型

# 将字符串类型日期修改为datetime日期类型
#方法1： .to_datetime 和 .set_index
df=pd.DataFrame({'date':'2018-01-01','price':20},index=list('ab'))
df
Out[7]: 
         date  price
a  2018-01-01     20
b  2018-01-01     20
df['date']=pd.to_datetime(df['date'])
df.set_index('date',inplace=True)
df
Out[11]: 
            price
date             
2018-01-01     20
2018-01-01     20
df.index
Out[12]: DatetimeIndex(['2018-01-01', '2018-01-01'], dtype='datetime64[ns]', name='date', freq=None)

#方法2：.set_index和 .DatetimeIndex
df=pd.DataFrame({'date':'2018-01-01','price':20},index=list('ab'))
df
Out[14]: 
         date  price
a  2018-01-01     20
b  2018-01-01     20
df.set_index('date',inplace=True)
df.index=pd.DatetimeIndex(df.index)
df
Out[17]: 
            price
date             
2018-01-01     20
2018-01-01     20
df.index
Out[18]: DatetimeIndex(['2018-01-01', '2018-01-01'], dtype='datetime64[ns]', name='date', freq=None)

功能：将df或者Series等分

# 将dataframe或者series三等分
# cut区间范围等分，每个范围数据个数不等，qcut分位数等分，每个范围数据个数相等
# cut和qcut返回的factor对象可直接用于groupby
frame = pd.DataFrame({'data1': np.random.randn(10), 'data2': np.random.randn(10)})
frame
Out[20]: 
      data1     data2
0 -0.420824  0.517133
1 -1.085327  0.969493
2  1.111569 -1.444616
3 -1.837042  0.934159
4 -1.290986  0.565812
5  2.792878  0.756323
6 -0.925471 -0.193387
7 -0.035497 -0.795628
8 -0.737259  0.121162
9  0.375720 -0.380498
factor = pd.cut(frame['data1'], 4)  # 也可以改为qcut，桶等分
for i in frame.groupby(factor):
    print(i)
    
(Interval(-1.8420000000000001, -0.68000000000000005, closed='right'),       data1     data2
1 -1.085327  0.969493
3 -1.837042  0.934159
4 -1.290986  0.565812
6 -0.925471 -0.193387
8 -0.737259  0.121162)
(Interval(-0.68000000000000005, 0.47799999999999998, closed='right'),       data1     data2
0 -0.420824  0.517133
7 -0.035497 -0.795628
9  0.375720 -0.380498)
(Interval(0.47799999999999998, 1.635, closed='right'),       data1     data2
2  1.111569 -1.444616)
(Interval(1.635, 2.7930000000000001, closed='right'),       data1     data2
5  2.792878  0.756323)

 功能：df数据选取

import pandas as pd
from pandas import Series, DataFrame
import numpy as np

# SettingWithCopyWarning:
# A value is trying to be set on a copy of a slice from a DataFrame.
# Try using .loc[row_indexer,col_indexer] = value instead
# See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy

# 是选数据的时候方法问题，用的
df = pd.DataFrame(np.arange(12).reshape(3, 4), columns=list('abcd'))
a = df[['x', 'y']]        # 错误用法
a = df.loc[:, ['x', 'y']] #正确用法

def do_something(df):
    foo = df[['bar', 'baz']]  # Is foo a view? A copy? Nobody knows!
    # ... many lines here ...
    foo['quux'] = 'value'  # We don't know whether this will modify df or not!
    return foo

df = pd.DataFrame(np.arange(12).reshape(3, 4), index=list('xyz'), columns=['A', 'B', 'C', 'D'])
df
Out[134]: 
   A  B   C   D
x  0  1   2   3
y  4  5   6   7
z  8  9  10  11
# 列-->>索引 set_index() #原来的索引被删掉，即x、y、z被删掉
df = df.set_index(['A'])
df
Out[136]: 
   B   C   D
A           
0  1   2   3
4  5   6   7
8  9  10  11
df = df.set_index('B')
print(df)
    C   D
B        
1   2   3
5   6   7
9  10  11
# 索引-->>列 reset_index   #注意，如果要丢掉原来索引，重新排列，可以pd.reset_index(drop=True)即可，Series也可以
df = df.reset_index()
df
Out[139]: 
   B   C   D
0  1   2   3
1  5   6   7
2  9  10  11
df['index'] = df.index
df
Out[141]: 
   B   C   D  index
0  1   2   3      0
1  5   6   7      1
2  9  10  11      2
# 索引重排列，方法一
df.sort_index()
Out[154]: 
   B   C   D  index
0  1   2   3      0
1  5   6   7      1
2  9  10  11      2
# 索引重排列，方法二
df = df.reindex([1, 2, 0])
df
Out[143]: 
   B   C   D  index
1  5   6   7      1
2  9  10  11      2
0  1   2   3      0
# 暴力修改索引,用的较少，但是没有索引名字了
df.index = ['x', 'y', 'z']
df
Out[145]: 
   B   C   D  index
x  5   6   7      1
y  9  10  11      2
z  1   2   3      0
# 按照列的值排序
df.sort_values(by='B')
Out[147]: 
   B   C   D  index
z  1   2   3      0
x  5   6   7      1
y  9  10  11      2

功能：计算累积收益率

# 计算累计收益率，假设m列中均为股票S价格，结果均为series
df = pd.DataFrame(np.arange(1, 17).reshape(4, 4), index=pd.date_range('2017/1/1', periods=4), columns=list('mnxy'))
df
Out[163]: 
             m   n   x   y
2017-01-01   1   2   3   4
2017-01-02   5   6   7   8
2017-01-03   9  10  11  12
2017-01-04  13  14  15  16
series_data = df['m']
returns = series_data.pct_change()
ret_index = (1 + returns).cumprod()
ret_index[0] = 1
ret_index
Out[165]: 
2017-01-01     1.0
2017-01-02     5.0
2017-01-03     9.0
2017-01-04    13.0
Freq: D, Name: m, dtype: float64

功能：df中eval用法

#DataFrame 中 eval用法
df = pd.DataFrame(np.arange(15).reshape(5, 3), index=pd.date_range('2017/1/1', periods=5), columns=list('mnx'))
df
Out[119]: 
             m   n   x
2017-01-01   0   1   2
2017-01-02   3   4   5
2017-01-03   6   7   8
2017-01-04   9  10  11
2017-01-05  12  13  14
df.eval('n=m/2')
Out[120]: 
             m    n   x
2017-01-01   0  0.0   2
2017-01-02   3  1.5   5
2017-01-03   6  3.0   8
2017-01-04   9  4.5  11
2017-01-05  12  6.0  14
df.eval('y=m+n+x')
Out[121]: 
             m   n   x   y
2017-01-01   0   1   2   3
2017-01-02   3   4   5  12
2017-01-03   6   7   8  21
2017-01-04   9  10  11  30
2017-01-05  12  13  14  39

 功能：df中数据格式转换

#DataFrame中数据格式转换

df= pd.DataFrame({'data1': np.random.randn(10), 'data2': np.random.randn(10)})
df
Out[158]: 
      data1     data2
0  0.502123 -0.509918
1 -0.951938  1.087244
2  0.813539  1.472696
3 -2.371410  1.653909
4 -2.003656 -0.377436
5 -0.568296  0.860488
6 -0.298069  0.524529
7  1.495561 -0.168975
8  0.071808 -0.657124
9  1.033833 -0.792216
#保留两位小数
df.round(2)  #注意：df本没有变化，如果要直接修改，应是：df=df.round(2)
Out[159]: 
   data1  data2
0   0.50  -0.51
1  -0.95   1.09
2   0.81   1.47
3  -2.37   1.65
4  -2.00  -0.38
5  -0.57   0.86
6  -0.30   0.52
7   1.50  -0.17
8   0.07  -0.66
9   1.03  -0.79
#浮点型转换为字符串，也可以一列一列修改，下同
df.astype('str')
Out[160]: 
                 data1                 data2
0   0.5021230983459903   -0.5099175252419896
1  -0.9519381099105976     1.087243798112059
2   0.8135390670890555    1.4726958935479506
3   -2.371409829647876    1.6539092429632931
4  -2.0036555631578294  -0.37743579303176955
5  -0.5682959379210526    0.8604878115460606
6  -0.2980691412731598    0.5245286812900314
7   1.4955614539023945  -0.16897501597784825
8  0.07180772648583414   -0.6571243077010698
9    1.033833479234571   -0.7922160997192839
#字符串转换为整数
df.astype('int')
Out[161]: 
   data1  data2
0      0      0
1      0      1
2      0      1
3     -2      1
4     -2      0
5      0      0
6      0      0
7      1      0
8      0      0
9      1      0

1、pandas.DataFrame.iterrows

2、pandas.Series.searchsorted

import numpy as np
x=pd.DataFrame(np.arange(16).reshape(4,4),index=list('numb'),columns=list('xyzi'))
x
Out[12]: 
    x   y   z   i
n   0   1   2   3
u   4   5   6   7
m   8   9  10  11
b  12  13  14  15
y=x.iterrows()
y
Out[14]: <generator object DataFrame.iterrows at 0x000001F88B224D58>
for i in y:
    print(i)
    
('n', x    0
y    1
z    2
i    3
Name: n, dtype: int32)
('u', x    4
y    5
z    6
i    7
Name: u, dtype: int32)
('m', x     8
y     9
z    10
i    11
Name: m, dtype: int32)
('b', x    12
y    13
z    14
i    15
Name: b, dtype: int32)
x.index
Out[16]: Index(['n', 'u', 'm', 'b'], dtype='object')
x.index.searchsorted('u')
Out[17]: 4
x.index.searchsorted('a')
Out[18]: 0
x.index.searchsorted('z')
Out[19]: 4
x.index.searchsorted('b')
Out[20]: 0