Python之pandas

dataframe和series操作

1、取dataframe数据

1) iterrows()

for index_, row in df1.iterrows():
    print(index_)
    print(row, row.values[0])

iterrows()按行遍历dataframe或series，返回两个元素：行索引和行值，其中行值为Series格式，可以根据list索引取具体的数值。
结果：

2) itertuples()

itertuples为每一行产生一个namedtuple，并且行的索引值作为元组的第一个元素，pandas类型。

for nametuple in df1.itertuples():
        print(nametuple)
        print(nametuple[0], type(nametuple))

3) dataframe按某列的值取数据

temp_df[temp_df.c1 == 'aa']['c2']

dataframe对象temp_df的c1列值为aa时temp_df的c2列的值；

4) dataframe根据列值取行索引

temp_df[temp_df.c1 == 'aa'].index.to_list()

temp_df的c1列值为aa时,temp_df的行的索引；

5) dataframe 根据行索引和列名修改dataframe的值

final_result.loc[10, 'c1'] = abc

将final_result的10行c1列的值改为abc；

6) dataframe根据列名取值

sorted(list(set(pre_result['c3'].to_list())))

返回list格式，set()去重，list()改回list格式，sorted()排序；

7) 取dataframe的部分列

df_after[['c1', 'c3', 'c6']]

8) dataframe.loc[0]——根据数字型行索引的值取值，

print(retemp.loc[0])

retemp:
    asset_return  asset_vol
0             1          2
1            11         12

output:

asset_return    1
asset_vol       2

9) dataframe.iloc[1]——根据行顺序取值，取第i行，从0开始

retemp:
           asset_return
asset_vol             
b                    a
ee                  dd

output：

asset_return  dd
asset_vol     ee

2、索引

1) 修改列名或索引名

df_after = df_after.rename(columns={base_type: 'values'})

修改列名base_type为’values’。

2) dataframe.set_index('return')——将return列的值作为新的行索引

print(retemp, '\n', retemp.set_index('return'))

output：

        return asset_vol
0            a         b
1           dd        ee 

           return
asset_vol    
b            a
ee           dd 

3) dataframe.reset_index()

重置行索引为数字型索引,参数drop=True时丢失原索引列，参数inplace=True时，修改原df，为false时，返回新的df

output： (drop=False)

   index    return      vol
0      0            a         b
1      1           dd        ee

output： drop=True

        return      vol
0            a         b
1           dd        ee

retemp:

                return
vol             
b                    a
ee                  dd 

print(retemp.reset_index(inplace=False))
print(retemp)

output：inplace=False时返回的结果

   index return vol
0      0            a         b
1      1           dd        ee

原retemp没有改变

            return   vol
0            a         b
1           dd        ee

3、 drop_duplicates(self, keep='first', inplace=False)

删除series的重复项

4、 dataframe的apply方法

5、 np.asarray(a, dtype=None, order=None)

将输入转化为数组

6、 dataframe指定的列做运算，列名要一样

res_df['q'] = res_df['q'] / df['q']

res_df和df的q列相除

7、 判断dataframe的数据是否为NaN

temp_df[temp_df.c1 == cc_]['c2'] is np.NaN

8、 pd.concat()

拼接dataframe，列索引可以不一样，拼接后的结果会保留原df的行索引，当两个df的列数量不一样时，会填充NaN

df = pd.concat([df1, df2])

input：

      Q1    Q2    
0  asset  path    
1  asset  path    
2  asset  path    
3  asset  path    
       Q1         Q2           Q3
0  quater  0.6641355  0.664235635
1  quater  0.6641355  0.664235635
2  quater  0.6641355  0.664235635
3  quater  0.6641355  0.664235635
4  quater  0.6641355  0.664235635    

output:

       Q1         Q2           Q3
0   asset       path          NaN
1   asset       path          NaN
2   asset       path          NaN
3   asset       path          NaN
0  quater  0.6641355  0.664235635
1  quater  0.6641355  0.664235635
2  quater  0.6641355  0.664235635
3  quater  0.6641355  0.664235635
4  quater  0.6641355  0.664235635

9、设置打印的数据小数点位数

pd.set_option('precision', 10)

10、字典转dataframe，设置数据格式

data1 = {'Q1': ['0.1', '0.2', 0.3],
            'Q2': [1, 2, '3']}
df1 = pd.DataFrame(data1, dtype=np.float)

11、df.shift(n)

dataframe向下平移n行

12、操作文件

(一)to_excel()可以选择要保存的sheet

writer = pd.ExcelWriter('df2.xlsx',)
df1.to_excel(writer, index=False, sheet_name='aaa')

(二)to_csv(),mode='a'——设置写入的模式：添加

一次写入

df1.to_csv(path_or_buf=file_name, index=False, mode='a')

分行写入，newline=''——去空行

with open("test0.csv", "a+", newline='') as csvfile:
    writer = csv.writer(csvfile, dialect='excel')
    # 先写入columns_name
    writer.writerow(['Q1', "Q2", "Q3", "Q3"])
    for i in range(len(column1)):
    # 写入多行用writerows
    writer.writerow([column1[i], column2[i], column3[i], column4[i]])

(三)读csv文件为dataframe，header=None:表示csv文件中不包含列名，names=[]：设置df的列名

df_after = pd.read_csv(filepath_or_buffer=file_name, header=None, names=['c1', 'c2', 'c3', 'c4'])

13、pivot函数

对dataframe行列互换，可以接收三个参数，分别是index、columns和values，其中index用来指定转换后DataFrame对象的纵向索引，columns用来指定转换后DataFrame对象的横向索引或者列名，values用来指定转换后DataFrame对象的值。

14、pd.merge()函数

merge(left, right, how='inner', on=None, left_on=None, right_on=None,
          left_index=False, right_index=False, sort=False,
          suffixes=('_x', '_y'), copy=True, indicator=False,
          validate=None)

作用：拼接两个dataframe对象，可以通过参数left,right,on,how,sort等参数设置多种拼接方式。
left/right:设置待拼接dataframe的左右顺序；
on:设置拼接dataframe的连接键，必须是待拼接的两个dataframe中同时存在的，可以是一个列表，表示同时按多列拼接；
left_on=/ right_on=:分别设置待拼接的两个dataframe的连接键，可以不同；
how:设置拼接方式，'left', 'right', 'outer', 'inner'。
sort: 按字典顺序通过连接键对结果DataFrame进行排序。

15、Pandas聚合和分组

15.1 GroupBy

1) 使用groupby对dataframe按照列名、索引分组

然后对分组的数据求均值、方差等计算。

Grouped = df.groupby[‘column_name’]

变量grouped是一个GroupBy对象，它实际上还没有进行任何计算
同时传入多个对象：对df按照column_2和column_3两级分组，然后求列column_1的均值。

Grouped = df[‘column_1’].groupby([df[‘column_2’],df[‘column_3’]]).mean()

使用size()方法查看每个分组的数据大小。

2) GroupBy对象支持迭代

产生一组二元元组（由分组名和数据块组成），其中数据块的索引与原dataframe一致。

for name_, group_df in df_res.groupby('path'):
        print(name _)
        print(group_df)

对于多重键的情况，元组的第一个元素将会是由键值组成的元组：

for (k1, k2), group_df in df.groupby(['key1', 'key2']):
     print(k1, k2)
     print(group_df)

3) groupby默认是在axis=0上进行分组的，通过设置也可以在其他任何轴上进行分组

grouped = df.groupby(df.dtypes, axis=1)

4) 分组信息可以是字典

          a         b         c         d         e
1     0.306336 -0.139431  0.210028 -1.489001 -0.172998
2   0.998335  0.494229  0.337624 -1.222726 -0.402655
3     1.415329  0.450839 -1.052199  0.731721  0.317225

mapping
{'a': 'group1', 'c': 'group2', 'b': 'group1', 'e': 'group1', 'd': 'group2', 'f': 'group3'}
将dataframe的列通过字典的键值对映射，可以将多列映射到同一个键值，然后传入字典根据键值分组。

by_column = df1.groupby(mapping, axis=1)
by_column.sum()

     group2       group1
1    -1.278973 -0.006092
2  -0.885102  1.089908
3     0.731721  1.732554