python笔记（二）dataframe操作

df.target #查看目标属性

 

创建df

随机：

data = pd.DataFrame(np.random.randn(1000, 4))

 df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))

sampler = np.random.permutation(5)  # 对数组内数据随机重排

循环创建：

events_df = pd.DataFrame(columns={'event','ds'})

For……

 events_df = events_df.append({'event':'date38','ds':df['ds'][i]},ignore_index=True)

数据替换

df['city'].replace('sh', 'shanghai')

索引

1. 修改列索引

df.columns = boston.feature_names[4:7] #设定列名称

numpy数组转成列表之后，列名是数字，不是字符

data = data.rename(columns={col:'target'}) 

data_idmax = data_idmax.rename(columns={'old_name':'best_model'})

frame2 = frame.set_index(['c', 'd']) #将某一行列设为索引

train.index = pd.to_datetime(train["datetime"])

1. 行列索引命名

 frame.index.names = ['key1', 'key2']

 frame.columns.names = ['state', 'color']

1. 重设索引

df_inner.reset_index()  #删除缺失值之后索引会变得不连续

df = df[(df['pay_amt']>0) & (df['real_amt']>0)].reset_index(drop=True)

1. 设置索引列

df_inner.set_index('id')

1. 设置日期为索引

df_inner=df_inner.set_index('date')

1. 整列重新排序

frame.swaplevel('key1', 'key2')  # 交换两列位置

列排序：frame.sort_index(level=1)

DataFrame.sort_values（by，axis = 0，ascending = True，inplace = False，kind = ' quicksort '，na_position = 'last'，ignore_index = False，key = None）

list排序

list.sort( key=None, reverse=False)

1. 删除某列

train_df = new_df.drop(["name"], axis=1).values

切片

1. 取奇数/偶数列

xy_1=(np.array(b)[:,::2])[:,1:]

xy_2=np.array(b)[:,1::2]

1. 按索引提取

data.loc[time2:time1]——按行索引取 features1 = df.loc[0:16]

data.iloc[time2:time1]——按列索引取 features1 = df[df.columns[0:16]]

然后修改索引

data1 = data.reset_index()——行索引变成第一列

df.set_index('年份',inplace=True)——这一列变成行索引（index)

单行值	df_inner.loc[3]
多行值	df_inner.iloc[0:5]

1. 对复合多个条件的数据进行分组标记

df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign']=1

1. 分列

对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列，列名称为category和size

pd.DataFrame((x.split('-') for x in df_inner['category']),index=df_inner.index,columns=['category','size']))

1. 遍历取值

best_formula = []

for indexs in data_idmax.index:

    best_formula.append(formula.at[indexs,data_idmax.at[indexs,'best_model']])

data_idmax['best_formula'] = best_formula

1. 筛选（取交集）

df_inner.loc[(df_inner['age'] > 25) & (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']]

data[data['three'] > 5]

bokeh_data3['zkl'] = bokeh_data3['zkl'][bokeh_data3['zkl'] < 0.96]

条件筛选：如果prince列的值>3000，group列显示high，否则显示low：

df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')

contains函数：df[df[“column_name”].str.contains(“str”)]

筛选出所有含有(str)的数据记录, 用法类似于sql中的"contains"

1. 一些根据索引赋值

data2 = data.copy()

for i in x['利润中心（项目编号）']:

    data2.loc[(data2['利润中心（项目编号）']==i), 'ans']='基差贸易'

    x1 = data2[data2['利润中心（项目编号）']==i]['方向'].value_counts()

    if (len(x1)==2 and (x1.iloc[0]==x1.iloc[1])):

    #     a = pd.DataFrame(data2[(data2['利润中心（项目编号）']==i)]['ans'])

    #     a['ans']='相同'

    #     data2[(data2['利润中心（项目编号）']==i)]['ans']=a['ans']

        data2.loc[(data2['利润中心（项目编号）']==i), 'ans']='相同'

for i in df['利润中心（项目编号）']:

    for j in df['品类']:

        x2 = df.loc[(df['利润中心（项目编号）']==i)&(df['品类']==j), ['方向','时间']]

        if x2.loc[df['方向']=='买','时间'].min() > x2.loc[df['方向']=='卖','时间'].min():

            df.loc[(df['利润中心（项目编号）']==i)&(df['品类']==j), 'ans'] = '小'

        else:

            df.loc[(df['利润中心（项目编号）']==i)&(df['品类']==j), 'ans'] = '大'

print(df)

查找某列是否有某值，没有返回空值

isin()接受一个列表，判断该列中元素是否在列表中

data_top_all = df_all[df_all.product_cd.isin(list_top)]

格式转换

1. dataframe转list 

data1 = np.array(data1).tolist()——先变成array再转list

排序

1. 按照特定列的值排序：

df_inner.sort_values(by=['age'])

降序排列

train[train["remarks"]=="something"].sort_values(by="y",ascending=False)

1. 按照索引列排序：

df_inner.sort_index()

1. dataframe取每行最大——idmax

data_idmax = pd.DataFrame(data[['xgb_acc_median','prophet_acc_median']].idxmax(axis=1))

data_idmax = pd.merge(data,data_idmax,left_index=True,right_index=True)

data_idmax['best_acc'] = data[['xgb_acc_median','prophet_acc_median']].max(axis=1)

data_idmax = data_idmax.rename(columns={0:'best_t'})

data_idmax.groupby('best_t')[['product_cd']].count()

聚合

1. 统计每种元素出现个数（dataframe）

df['幸福感'].value_counts()

data.parent_ptype_id.value_counts()

1. Groupby

常用函数

自定义聚合函数：

将其传入aggregate或agg方法即可

def peak_to_peak(arr):

       return arr.max() - arr.min()

grouped.agg(peak_to_peak)

groupby().size

返回一个含有分组大小的Series

对所有的列进行汇总

df_inner.groupby('city').count()

按某一字段(city)对(另一字段(id))进行汇总

df.groupby('data_date').sum()

df.groupby('city')['id'].count()

对两个字段进行汇总计数

df_inner.groupby(['city','size'])['id'].count()

对city字段进行汇总，并分别计算price的合计和均值

df_inner.groupby('city')['price'].agg([len,np.sum, np.mean])

一次传入多个数组的列表会得到层次化索引结果

df['data1'].groupby([df['key1'], df['key2']]).mean()

1. apply（片段组合）——最通用的GroupBy方法

示例：

def get_stats(group):

return {'min': group.min(), 'max': group.max(),

              'count': group.count(), 'mean': group.mean()}

grouped.apply(get_stats)

apply计算加权平均数

df = pd.DataFrame({'category': ['a', 'a', 'a', 'a', 'b', 'b', 'b', 'b'],

                   'data': np.random.randn(8),

                  'weights': np.random.rand(8)})

grouped = df.groupby('category')

get_wavg = lambda g: np.average(g['data'], weights=g['weights'])

grouped.apply(get_wavg)

1. transform

得到每组平均值

g.transform(lambda x: x.mean())

计算每个分组的降序排名

g.transform(lambda x: x.rank(ascending=False))

区别

transform() 使用函数、字符串函数、函数列表和字典。 但是， apply() 只允许与函数一起使用。

transform() 不能使用聚合函数，apply() 能使用聚合。

transform() 一次只能处理单维（列），apply() 一次处理多维（列）

1. 最值

data_idmax['best_acc'] = data1[['acc_linear_mean','acc_log_mean']].max(axis=1)

获取最值索引

data_idmax = pd.DataFrame(data1[['acc_linear_mean','acc_log_mean']].idxmax(axis=1))

分箱

根据指定面元或样本分位数将数据拆分成多块的工具

1. Cut

装入长度大小相同的桶

quartiles = pd.cut(frame.data1, 4)

根据样本分位数得到大小相等的桶，labels=False即可只获取分位数的编号：

grouping = pd.qcut(frame.data1, 10, labels=False)

df加法（自动填充未对其部分）

df1.add(df2, fill_value=0)

df1和df2维度不同，没有对齐的部分自动填充0（默认NA）

eq：比较两个df

格式转换

tolist()方法,它可以将将外层内层全转化为list类型,实现数组或者矩阵转换为列表

apply()  遍历

apply()函数主要用于对DataFrame中的某一column或row中的元素执行相同的函数操作。

# 对df表中的每一个元素加1
df.apply(lambda x:x+1)

 

# 对第1行的每一个元素加1
df.loc[1].apply(lambda x:x+1)

 

applymap()函数用于对DataFrame中的每一个元素执行相同的函数操作

# 对df表中的每一个元素加1
df.applymap(lambda x:x+1)