# 找出只有赌场数据的账户
gp=data.groupby(['查询账号','场景标签'],as_index=True)
tj=gp.size().reset_index()按查询账号和场景标签分组并统计数据条数

https://blog.csdn.net/weixin_38168620/article/details/79596819
fillna 填充
bb=aa.isnull().any()
print(bb)
20210712

某列有多少行非空数值统计：
统计所有列df.count()
单独某列：df.age.count()

20210705

def apply_age(x,bias):return x+bias#以元组的方式传入额外的参数 #apply函数传参的方式
data["age"] = data["age"].apply(apply_age,args=(-3,))def gender_map(x):gender = 1 if x == "男" else 0return gender#以元组的方式传入额外的参数
data["age1"] = data["age"].map(gender_map)map不能传参，apply 可以
apply 通过调节 axis=0或者1来调节是对行还是列进行处理

https://zhuanlan.zhihu.com/p/100064394?utm_source=wechat_session
apply比map

20210628

ceshi=np.matrix([[1, 2], [1, 0]], dtype='int64') * np.matrix([[1], [0]])[[1, 2], [1, 0]]1  2
1  1
代表的是这样的矩阵[[1], [0]]1
0
代表的是这样的

20210625

         sent_len=len([j for i in sents for j in i])
for循环嵌套 第一层在前面

20210609

datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')

时间格式化

20210531

  peaks_df = pd.concat(peaks_list).reset_index(drop=True)#??

列表转dataframe

20210528

        columns = ['no2', 'so2', 'co', 'o3', 'pm2_5', 'pm10']station_group_by_df['aqi'] = np.max(station_group_by_df[columns], axis=1)

批量求某列的最大值

pd.concat([pd.read_csv(f) for f in file_list]).reset_index()
concat和for循环的联合使用

df.empty
判定一个df是否为空

https://vimsky.com/examples/usage/python-numpy.ufunc.reduce.html
python numpy ufunc.reduce用法及代码示例
沿某个轴进行某个函数处理

>>> X = np.arange(8).reshape((2,2,2))
>>> X
array([[[0, 1],[2, 3]],[[4, 5],[6, 7]]])
>>> np.add.reduce(X, 0)jz=[[1,2],[3,4]]
[1,2] 形状为2行1列
[3,4] 形状也为2行1列
np.minimum.reduce（jz）
等于 [1,2]
1  3
2  4
相当于每一行取最小值

x是一个多维矩阵,0可以为默认值不填

peaks = group.loc[group.index[peaks_index[0]], target]
按索引批量取出值

直接取出最大值所在的索引
https://blog.csdn.net/weixin_38605247/article/details/78736417
iterrows()对dataframe进行遍历按行遍历

      df_mobile['time_internal']=(pd.to_datetime(df_mobile['published_at']) - pd.to_datetime(df_mobile['last_published_at'])) / timedelta(seconds=1)

这样处理之后直接把结果变成了数值格式

type_dict = {‘lat’: ‘float’,
‘lon’: ‘float’,
‘co’: ‘float’,
‘so2’: ‘float’,
‘no2’: ‘float’,
‘o3’: ‘float’,
‘pm2_5’: ‘float’,
‘pm10’: ‘float’,
‘aqi’: ‘float’,
‘station_code’: ‘str’,
‘station_name’: ‘str’
}
exist_dict = {i: type_dict[i] for i in type_dict.keys() if i in data_df.columns}
data_df = data_df.astype(exist_dict)
批量修改列的类型

datetime
timedelta
timstamp

from datetime import datetime,timedelta

bb=pd.to_datetime(aa)
timestamp转datetime

20210421

pandas transform
https://blog.csdn.net/kyle1314608/article/details/115943253

data['sum_price']=data.groupby('order')['ext_price'].transform('sum')

transform 的核⼼：作⽤于 groupby 之后的每个组的所有数据
并把结果追加到原表后面

df=pd.DataFrame({'id':[1,1,1,1,1,2,2,2,2,2],'name':['aa','aa','aa','bb','bb','aa','aa','bb','bb','bb'],'cls':['cc','cc','dd','dd','cc','cc','cc','dd','dd','cc'],'stu':[1,2,3,4,5,6,7,8,9,10]})df['sum_stu']=df.groupby(['id','name','cls'])['stu'].transform('sum')df['sqrt_stu']=df.groupby(['id','name','cls'])['stu'].transform(np.sqrt)
多列处理

（ sum 可以换成任意的函数甚至是自定义的函数
不一定把）
20210420

https://blog.csdn.net/AaronPaul/article/details/106682486
长表转宽表

pltj=pltj.pivot_table(
index=["ipo_province"],    #行索引（可以使多个类别变量）
columns=["relation"],                   #列索引（可以使多个类别变量）
values=["js"])                   #值（一般是度量指标）

宽边转长表

https://blog.csdn.net/qq_34535319/article/details/100601656
多级行索引转成列

20210413

https://zhuanlan.zhihu.com/p/65147779
pandarallel

https://blog.csdn.net/jzlixiao/article/details/79583389
分箱要覆盖数据中的最小和最大值否则会产生nan

20210407

追加保存行之间错位一般都是 concat的时候两个表的索引没对齐

series.values 直接转numpy
dataframe.values 转出来之后还多了个中括号
dataframe 单元格可以是直接array 可以直接存储和读出来是array
concat当两个表的行数不一样的时候，保留最大的行数（索引）

20210402

pandas.DataFrame.copy
DataFrame.copy(deep=True)
深度复制

https://blog.csdn.net/u012995500/article/details/109463219

并行parallel

20210315

https://blog.csdn.net/qq_24499417/article/details/81428594
pandas处理json

20210309

https://blog.csdn.net/weixin_44073728/article/details/111054157
pandas无法打开.xlsx文件，xlrd.biffh.XLRDError: Excel xlsx file； not supported

https://blog.csdn.net/u012193416/article/details/83152895
直接设定指定列为横向索引
set_index

stack 左边变成右边
行索引变成二级列索引

sd=dd3.set_index(['spu','dateid'])[['active_sell']].unstack(level=-1).fillna(0)
列转行
纵向改横向https://www.cnblogs.com/rachelross/p/10439704.html综上, 可以总结, stack 的作用就是可以将横向的表头(列名)转成纵向的索引列展示, 对于多行表头而言, 具体要转换哪一行取决于 level 参数, 如果不指定, 则默认转换最下面一行表头. level 第几级索引 从上往下数和从左往右数


df=pd.DataFrame({'a':['null',1]})
df[df['a']=='null']='no'
全表筛选并赋值cp1=cp.where(cp.notnull(), None)
dataframe的nan替换成Nonehttps://zhuanlan.zhihu.com/p/107050664
Series.where(cond, other=nan, inplace=False, axis=None, level=None, errors=‘raise’, try_cast=False, raise_on_error=None)
如果 cond 为真，保持原来的值，否则替换为other， inplace为真则表示在原数据上操作，为False表明在原数据的copy上操作。mask方法与where方法作用相反，other默认为NaN

data_insert = [tuple(xi) for xi in last_merge.values]
每行转元组

metrics_save.groupby(['hy1','hy2'])['ndcg5'].mean().reset_index()
分组求平均

_temp = {‘job’:[‘farmer’, ‘teacher’, ‘worker’, ‘acter’, ‘present’], ‘money’:[3000, 7000, 5000, 100000, 66666]}
df = pd.DataFrame(_temp)
print(df)

   job   money
0 farmer 3000
1 teacher 7000
2 worker 5000
3 acter 100000
4 present 66666
a = df[(df[‘money’]>10000)].index.tolist()
print(a)
[3, 4]

求满足条件未知的索引

20210208

 i=0train=np.load('./20210202/company5_xiangl.npy',allow_pickle=True)# train=pd.DataFrame(train,columns=['other_company_ss', 'qymc_fss', 'qid','output_layer_fss', 'output_layer_ss' ])train=pd.DataFrame(train)from pandas_streaming.df import StreamingDataFramechunk= StreamingDataFrame.read_df(train, chunksize=5000)hz1=''k=0for ck in tqdm(chunk):data=ck.iloc[:,3:]hz=''j=0for i in tqdm(range(data.shape[0])):if j==0:per_row=np.hstack([np.frombuffer(data.iloc[i,0], dtype=np.float32), np.frombuffer(data.iloc[i,1], dtype=np.float32)])hz=per_rowhz=hz[np.newaxis,:]j+=1else:per_row = np.hstack([np.frombuffer(data.iloc[i,0], dtype=np.float32), np.frombuffer(data.iloc[i,1], dtype=np.float32)])per_row=per_row[np.newaxis, :]hz=np.concatenate([hz,per_row],axis=0)j+=1if k==0:hz1=hzk+=1else:hz1=np.concatenate([hz1,hz],axis=0)k+=1
分条处理的时候  在外面再套一层分块

当两个array之后列没有行(也就是只有一个维度)的时候用hstack 拼接
当两个array都有两个维度的时候用concatenate

https://blog.csdn.net/weixin_42866962/article/details/82811082

numpy增加新维度

20210127

找出含空值的行空行
https://www.jb51.net/article/169635.htm
直接用dropna

bb=aa.isnull().any()
print(bb)

得到每列的值是否存在null值

https://www.cnblogs.com/lucas-zhao/p/11697203.html
argsort
返回排序后的下标数组

def argsort(a, axis=-1, kind=None, order=None):axis : int or None, optionalAxis along which to sort.  The default is -1 (the last axis). If None,the flattened array is used.

20210122

            import randomaa=random.sample(['你','我'], 1)
中文随机取值

– 空值：一种是从未填写过数据，二是填写过数据后删除掉的
– 第一种是null,第二种是’’
字符串的nan 用isnull 或者notnull 是不能处理的
数据库

gl['prob']=gl['0_x']/gl['0_y']
gl['prob']=gl.apply(lambda x :round((x['0_x'])/(x['0_y']),2))
两列操作 上面一种可以 下面一种不行 报 key错误

gp_ic=yuanqy.groupby(['industry','chain'],as_index=True)
ct_xi=gp_ic.size().reset_index()reset_index() 直接把groupy的索引恢复为从零开始排序的自然数列

右边的形式通过 explode 处理后得到右边的形式相当于宽表变长表
yuanqy=yuanqy.explode(‘chain’)

20210115

https://blog.csdn.net/Jfuck/article/details/9464959
numpy view 继续看

aa=df.max(axis=0) 按每列统计
aa=df.max(axis=1) 按每行统计等同于 df.max()

20210113

           x_train, x_test = x_data.iloc[train_index,:], x_data.iloc[test_index,:]y_train, y_test = y_data.iloc[train_index,:],y_data.iloc[test_index,:]train_index 是一个索引列表 只有 iloc 支持了

        cols = data.columns.tolist()# aa=cols.index('index')# bb=cols.pop(cols.index('index'))# aa=[1,2,3]# aa.insert(0,5)# aa.pop(0)insert_col=cols.pop(cols.index('index'))cols.insert(0,insert_col)data=data[cols]调整指定列index的位置
cols.insert(0, cols.pop(cols.index('Mid')))
调整列的顺序
https://www.cnblogs.com/zhoudayang/p/5414020.html

df.iloc[:,2]
df[[''col_name"]]
df.loc[:,2]
上面三种选出来都是series 只有下面两种方式选出来是dataframe
aa=df.iloc[1:2,:]
前面以区间的方式切片就可以得到dataframe而不是seriestb_vec=tb.iloc[:,2:]current_data =group.iloc[0,:].to_frame()current_data=current_data.T

    chunk=chunk.loc[chunk['output_layer_jyfw'].notnull(),:]剔除某列的空值

20210111

bq_bl = bq[0].to_numpy(dtype=np.int32)ValueError: invalid literal for int() with base 10: 'abc'
里面还没有非数字字符的转换

20210109

流式处理

20210108

https://blog.csdn.net/weixin_46165569/article/details/107146617
np.load 参数
np.savetxt 保存为为csv格式

data=pd.read_csv(path,iterator=False,chunksize=2,encoding='gbk')
for i in range(2):for chunk in data:print(chunk)分块读取 迭代器的形式占用的内存很小设置了chunksize,iterator 可以不用管了for 一轮读完之后就不能再for 了 只能把data= ...也同时放到for i.. 里面迭代器的作用就能分块小批量地处理数据import pandas as pd
iter_csv = pd.read_csv('file.csv', iterator=True, chunksize=1000)
df = pd.concat([chunk[chunk['field'] > constant] for chunk in iter_csv])分块中途处理后再合并

20210104

https://www.cnblogs.com/traditional/p/12629050.html
numpy增加维度

删除只能删除数组长度为1所对应的维度，同理添加也是添加一个维度也只是让数组在这个维度上的长度变成1，因为数组本来不存在这个维度的，但是我们强行加上了一个维度，那么数组在这个维度上的长度只能是1
import numpy as np
arr = np.array([[1, 2, 3], [2, 3, 4]])print(arr.shape)  # (2, 3)# 很好理解
print(np.expand_dims(arr, 0).shape)  # (1, 2, 3)
删除维度
print(np.squeeze(arr, 0))

元组转dataframe
sql execute 转 dataframe

20210103

https://www.jianshu.com/p/743b3bb340f6
布尔索引和花式索引

第一个中括号只管行,第二个中括号只管列?
第一个中括号的1代表第二行 0代表第一行
第一个中括号的1和第二个中括号的冒号配对? 为什么3,4会交换位置

20201229

内存中字节数

a=np.array([1,2])
b=np.array([3,4])
print(a.dtype.itemsize)
查看单个元素在内存中的字节数

datafarme 的元素可以是列表和数值只是只能先用二进制的形式
存储之后才能转换成功?如何直接赋值单元格为列表或数组


train['output_layer_x']=train['output_layer_x'].apply(lambda x: np.frombuffer(x,dtype=np.float32))
train['output_layer_x']=train['output_layer_y'].apply(lambda x: np.frombuffer(x,dtype=np.float32))train['output_layer_x']=train['output_layer_x'].apply(lambda x: np.array(x))
train['output_layer_y']=train['output_layer_x'].apply(lambda x: np.array(x))train['output_layer']=train.apply(lambda x: np.concatenate([x['output_layer_x'],x['output_layer_y']],axis=0))
上面不能这样操作train1['output_layer']=train1.apply(lambda x: np.concatenate([x['output_layer_x'],x['output_layer_y']]))hb=[]
for i in range(train1.shape[0]):print(i)temp=np.concatenate([train1['output_layer_x'].iloc[0],train1['output_layer_y'].iloc[0]],axis=0)hb.append(temp)
hb=np.array(hb)   hb列表直接转成arraytrain['output_layer']=train['output_layer'].apply(lambda x:x.reshape(768,2))pandas和numpy的联合处理  pandas的每个格子可以放数组
而且每个数组还可以直接进行数组的操作

20201227

https://www.jianshu.com/p/fc2fe026f002
reshape

https://blog.csdn.net/weixin_41797117/article/details/80048688
np_c
np_r
np.r_是按列连接两个矩阵，就是把两矩阵上下相加，要求列数相等。
np.c_是按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等。
和vstack 以及hstack的区别是什么

20201225

tensor的索引也是取不到最大的一个比如 [0:10] 取的索引是0 到 9 是取的10个值

指定替换和修改

ser.replace({0: 10, 1: 100})   重点
df = pd.DataFrame({'a': [0, 1, 2, 3, 4], 'b': [5, 6, 7, 8, 9]})
df.replace({'a': 0, 'b': 5}, 100)  #重点

20201222

数组的显示方式和实际对应的矩阵方向是相反的
看起来是水平实际上是竖直的

20201219

https://blog.csdn.net/qq_36387683/article/details/87710821
np.tile(a,1) 1的位置可以是列表表示形状也可以是标量
numpy 复制

X = np.expand_dims(df.values[:, 0:246].astype(float), axis=2)
[120 20] 编号是 0 1 然后变成 [120 20 1]
扩展新的轴

dataframe.iloc[0:i] iloc 是不包含i 的如果是指定写i 则是包含i的

数组的数值类型更改

   xlb1 = xlb1.astype(np.float64)

list 的元素可以是array
numpy 拼接组合
https://blog.csdn.net/kyle1314608/article/details/111402520

20201218

dataframe 的元素不能是数组

import numpy as np
x = np.empty([3,2], dtype = int)
print (x)
https://www.runoob.com/numpy/numpy-array-creation.html
构建多维数组

20201215

aa=np.random.choice(2) 随机产生 0 到 1
numpy 随机数
https://blog.csdn.net/kyle1314608/article/details/111273642

dataframe 因为性能而不能做的话改成 numpy 可以处理

txwl=sxyxl_pqs.loc[((sxyxl_pqs['上游']==0) & (sxyxl_pqs['下游']==0)),: ]

每个条件都要用括号括起来

遇到有空值的时候
在控制台把其内容和类型打出来再针对性处理

20201214

这种空值对应 ‘’

https://blog.csdn.net/kyle1314608/article/details/111213976
删除带空值的行
拼接关联的时候容易产生空值 nan
假设拿到一个10万行的数据后，通过isnull我们发现某列有几个空值，要把该列空值所在行删除怎么操作？用dropna()会删除所有有空值的行，请看下面实例。

    cfbc.drop(index=[10,23], inplace=True)

删除指定行索引

列值筛选

    gys_filter1=df['supplier_name'].str.contains('供应商')gys_filter2 = df['supplier_name'].str.contains('单位')df=df.loc[~(gys_filter1|gys_filter2),:]

20201210

X_768_3=pd.concat([X_768[‘qymc’],X_768_fl],axis=1,ignore_index=False)

两个表索引没对齐的情况下需要加上 ignore_index=False?

  X_769['output_layer']=X_769['output_layer'].apply(lambda x:x[1:])不能这么用？最好像下面这样用
Try using .loc[row_indexer,col_indexer] = value instead

 j_data.loc[j_data['season'] == '春', 'season'] = 'spring'

部分值的更改也可以先把数据集分成几个部分再针对性处理之后再合并

代码跑半天都不出结果,而又看不到时间进度的时候
可以减少数据量测试所用的时间也可测试代码是否可以跑通
这样可以计算总体数据量跑完需要多少时间

np.where(_predict_binary(e, X) > thresh)
利用np.where实现筛选所需要的值

元组和列表一样都可以通过索引提取元素
比如
a=（1,2）
a[0]=1

找出列表中非零元素的索引

import numpy as np
a = [0, 1, 0, 1, 0, 0, 0, 0]
nonzeroind = np.nonzero(a)[0] # the return is a little funny so I use the [0]
print nonzeroind
[1 3][i for i, e in enumerate(a) if e != 0]

20201209

报错的信息里面含有-1维度很有可能需要再在外面加一个维度

csc_matrix
https://blog.csdn.net/kyle1314608/article/details/110929896

20201208

dataframe 以前笔记
https://blog.csdn.net/kyle1314608/article/details/110851107

loc iloc 区别
利用loc 来筛选的时候中括号里面计算的值为 True,False 这种
https://blog.csdn.net/kyle1314608/article/details/110850700

20201207

https://editor.csdn.net/md/?articleId=110806128
字符映射为数字

sx=contrast.apply( lambda x: 1 if (x.loc[:,"test") == x.loc[:,"pred"] else 0]

上面为什么不行注意后面是否加 axis=1
sx=contrast.loc[((contrast.loc[:,“test”]==1) | (contrast.loc[:,“pred”]==1)),:]
loc 筛选
sx不能改成contrast 等号两边的索引对不齐只能用新的变量

20201204

X=train.iloc[:,:-1].astype(float)
-1是指的最后一列,这样取是取不到最后一列的
dataframe 按索引取出记录
X[train_index]
loc和iloc 在这里不行,train_index是一个列表
只有series才可以?dataframe 不行？

    result=data_set.groupby(lable,group_keys=False).apply(typeicalSampling,typeicalFracDict)

对每个group都利用typicalfracdict参数加入typicalsampling方法中进行处理

具体查看这里
https://blog.csdn.net/kyle1314608/article/details/110085693

20201202

一行或者一列的时候中括号里面的元素是用逗号分开的,多行或多列的时候不是?

IndexError: single positional indexer is out-of-bounds
iloc[i] 传入的i 大于实际值个数的范围

ndarray 中的中括号[]不是列表列表中的元素是以逗号隔开

import numpy as np
arr=[1,2,3,4,5]
np.save(‘test’,arr)# 将数组以二进制格式保存到磁盘
#读取
print(np.load(‘test.npy’))#[1 2 3 4 5]

npy文件

20201130

‘0’ 在 IDE dataframe 预览中显示这样的情况则表示实际上外面还有一对
双引号比如“‘0’” 无法直接转成数值只有预览显示为0的时候才能
转换成数值

使用map的方法就可以实现把某一列的字符类型的值转换为数字。
class_mapping = {‘A’:0, ‘B’:1}
data[class] = data[class].map(class_mapping)

在ndarray 显示为元素为向量的时候实际上每个元素是分别在一列中
而不是一个向量的所有元素在一个单元格中

多个字符串转元组
先用逗号分开,然后用split分成列表,然后再把列表转成元组

https://blog.csdn.net/kyle1314608/article/details/110434419
重命名

X=X[‘embeding’].str.split(’,’, expand=True)
https://blog.csdn.net/kyle1314608/article/details/110428430
合并的成一个单元格的时候可以先把行转为列然后再转为 list
拆分分裂

pandas-两个Series拼接合并为一个DataFrame(pd.concat)
a_series = pd.Series([“a”, “b”, “c”], name=“Letters”)
another_series = pd.Series([1, 2, 3], name=“Numbers”)
df = pd.concat([a_series, another_series], axis=1)
#merge a_series and another_series
print(df)
OUTPUT
Letters Numbers
0 a 1
1 b 2
2 c 3

gl1cp[‘encodedata’]=gl1cp[‘encodedata’].apply(lambda x:re.sub(r"\n","",x))gl1cp[‘encodedata’]=gl1cp[‘encodedata’].apply(lambda x:re.sub(r"\n","",x))

字符中换行符的匹配和替换

aa=’[1.1,2.1]’
aa=aa.replace("[","")
aa=aa.replace("]","")
aa=aa.split(",")
aa= [float(i) for i in aa]

字符转列表

gl1cp[‘split’].iloc[i].remove(’’)
gl1cp[‘encodedata’]=gl1cp[‘encodedata’].apply(lambda x:x.remove("’’,"))
列表的remove 没有返回值不能用等号
也不能写到apply 里面

字符串直接外面加 list（“你们好”) 会得到上面的形式

gl1cp[‘split_tuple’].iloc[i]=tuple(gl1cp[‘split’].iloc[i])

dataframe 单元格不能保存元组?

from sklearn.preprocessing import MultiLabelBinarizer
mlb = MultiLabelBinarizer(classes = [‘光伏电站发电’, ‘光伏电站’, ‘光伏组件’, ‘光伏电站工程’, ‘光伏应用系统’, ‘光伏硅片’])
zh=mlb.fit_transform([(‘光伏电站发电’, ‘光伏电站’), (‘光伏组件’,),(‘光伏电站工程’,)])

单个元素的后面要加逗号,两个以上的后面不用加逗号
https://blog.csdn.net/kancy110/article/details/75094179
多标签转换为二者型

group[‘split’].loc[:].to_list()

一个方括号取出来是series 要统计个数先转化成list
然后用len 求列表元素个数

mydf.dropna(subset=[‘列名’],inplace=True)
删除含空值的行

numpy 序列化

np.frombuffer(x.dtype=np.float32) 二进制转换成原来的格式

np.tobytes(a) 转成二进制貌似是错的

20201124

dataframe 以tab键分列保存

不要直接打tab键上去
正则的表达方式

https://editor.csdn.net/md/?articleId=110085693
python抽样,采样

https://blog.csdn.net/kyle1314608/article/details/110086248
dataframe抽样

https://blog.csdn.net/kyle1314608/article/details/110085354
样本划分数据集划分

字符replace
https://www.runoob.com/python/att-string-replace.html

for 循环的时候刚开始会引入乱符,可以事先不用处理
等最后for循环完了之后再统一一次处理

20200724
data = data.apply(pd.to_numeric, errors=‘ignore’)
应用时候忽略错误
20200719
TypeError: ‘Series’ objects are mutable, thus they cannot be hashed

result_quan.iloc[result_quan[‘相似度’]==1,‘包含’]=1
loc没写
loc[行,列]
loc是两部分
20200707

https://editor.csdn.net/md?articleId=107187574
对列表元素去重并保持原来顺序

20200624

https://blog.csdn.net/weixin_43368684/article/details/88756103
列中不包含某个字符

df[df[“col”].str.contains(‘this’|‘that’)==False]
df = pd.DataFrame({“A”: [“Hello”, “this”, “World”, “apple”]})
df[df[‘A’].str.contains(“Hello|World”)==False]
A
1 this
3 apple

20200618

https://www.cnblogs.com/liulangmao/p/9301032.html
shift
pandas DataFrame.shift()函数可以把数据移动指定的位数
period参数指定移动的步幅,可以为正为负.axis指定移动的轴,1为行,0为列.

20200527

空表添加行数据

        if (biaonr.shape[0]<shujhs)&(biaonr.shape[0]==0):xianzhs=biaonr.shape[0]buchs=shujhs-xianzhscolmc=biaonr.columnschuszd = {}for i in colmc:      #如果是空表,先人工补充一行数据chuszd[i]='人工填充'renggz=pd.DataFrame(chuszd,columns=biaonr.columns,index=[0])biaonr=pd.concat([biaonr,renggz],axis=0,ignore_index=True)

https://blog.csdn.net/roamer314/article/details/80886075

20200518

zdlx=[ i if i in biaonr.columns else ‘’ for i in zdlx.tolist()]
zdlx=sorted(zdlx)
zdlx=set(zdlx)
zdlx=list(zdlx)
zdlx=zdlx[1:]

列表中剔除某些元素

列表追加转为dataframe

20200516

[ i if ‘pb’ in i else ‘’ for i in ycjg.columns ]
[ i for i in ycjg.columns if ‘pb’ in i ] 过滤
列表生成式

20200515

perr=zengq.iloc[i:i+1,:]
加个冒号直接取出来就是dataframe 不是series 不需要再转换

fg[‘col_name’]=fg[‘col_name’].apply(lambda x:x.lstrip())
fg[‘comments’]=fg[‘comments’].apply(lambda x:x.lstrip())

去除单元格左边空格

20200514

dataframe 累乘是向下累乘

当单元格的值是列表或者元组的时候,分组聚合运算会出问题

In [25]: gb = df.groupby(‘gender’)
In [26]: gb.
gb.agg gb.boxplot gb.cummin gb.describe gb.filter gb.get_group gb.height gb.last gb.median gb.ngroups gb.plot gb.rank gb.std gb.transform
gb.aggregate gb.count gb.cumprod gb.dtype gb.first gb.groups gb.hist gb.max gb.min gb.nth gb.prod gb.resample gb.sum gb.var
gb.apply gb.cummax gb.cumsum gb.fillna gb.gender gb.head gb.indices gb.mean gb.name gb.ohlc gb.quantile gb.size gb.tail gb.weight

分组聚合运算类型
分组累乘之后索引会自动改成数字序列?

https://blog.csdn.net/zxyhhjs2017/article/details/93498104?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-30.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-30.nonecase

累乘

dataframe 中某列是元组使得dataframe 不能显示出来?

gp=duiying.groupby([‘qian’,‘hou’],as_index=True)
pltj=gp[‘hou’].count()

pltj=pltj.to_frame(name=‘num’)
pltj.index=range(pltj.shape[0])
pltj[‘index’]=list(pltj.index)

分组统计之后多层索引转换为列

20200423

求各行的和各列的和
https://my.oschina.net/u/2306127/blog/1920367
DataFrame数据预览
计算各列数据总和并作为新列添加到末尾
df[‘Col_sum’] = df.apply(lambda x: x.sum(), axis=1)
计算各行数据总和并作为新行添加到末尾
df.loc[‘Row_sum’] = df.apply(lambda x: x.sum())
最终数据结果：

  data_=data_[data_.columns[0:-1]]

通过列名取出来一列还是dataframe 不用再从series转换

https://www.cnblogs.com/zhoudayang/p/5564219.html
https://blog.csdn.net/cow66/article/details/100119058
重点
同时对多列进行操作

ycjg[str(j)+‘pb’] = ycjg.apply(lambda x:x[str(j)] ==x[‘mubc’],axis=1)

apply括号里面的x 代表前面传入的是 ycjg dataframe
要每个元素单独比较 axis=1 每列的每个元素对应比较
axis=0 每行的元素对应比较
多列比较两列比较两列操作

df[‘duplication’]=df.apply(lambda x: 1 if ((x[0]==x[1])) else 0 ,axis=0 )
只能是X[0] 这种形式,不能用x[‘mubc’]的形式

df[df[‘target’]==‘脉搏’]

直接df通过true false 来筛选的时候,筛选的是整行
20200414
字符转换为数值

https://www.cnblogs.com/sench/p/10134094.html
from sklearn import preprocessing
le = preprocessing.LabelEncoder() #获取一个LabelEncoder
le = le.fit([“male”, “female”]) #训练LabelEncoder, 把male编码为0，female编码为1
sex = le.transform(sex) #使用训练好的LabelEncoder对原数据进行编码
print(sex)

20200413
行追加用append,concat
列插入用 insert

# X.iloc[:, i_outlier] = X.iloc[:, i_outlier].astype(float)

类型转换花的时间很多！

20200410

https://blog.csdn.net/uvyoaa/article/details/79157786
分组取前n行

https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html
groupby api

grouped = df.groupby([‘class’]).head(2)
分组取前面几条
goupby之后就是对每类分别操作?

https://blog.csdn.net/The_Time_Runner/article/details/84076716
set_index:删除原来索引,并用新的数字列覆盖索引
reset_index:drop false 将原来的索引加入当前df作为列同时用数字改写行索引
drop true 不作为列同时用数字改写行索引

reset_index()

test_data.groupby(‘release_year’)[‘genre’].value_counts()
分组对某列计数

注意筛选条件最终的表现形式是True或False

看起来是相同的但是实际上有个有空格,导致分组统计的时候
会出现两个值

gb=df.groupby([‘target’],as_index=True)
gb_count=gb.size() 是series
对分组列本身值统计计数如图在上

不是size 而count的结果会把所有列索引保留

https://blog.csdn.net/meiqi0538/article/details/82533456
series 追加,添加值

列名的更改
df.rename(columns={‘原列名’：‘新列名’}, inplace=True)

append,concat 出问题基本上就是两张表的行或者列索引
不一致导致的

20200408

ValueError: column index (256) not an int in range(256)
https://www.cnblogs.com/z-x-y/p/9639702.html

sigle_col=group.loc[i_gp, :]
sigle_col=(sigle_col.to_frame()).T
series 转dataframe

20200407
(df_test.loc[df_test.loc[:,‘列1’]==‘你好’,‘列1’])=‘大哥’
筛选赋值注意大圆括号不能少
series或者dataframe 才能赋值如果加iloc[0] 反而不能赋值

20200326
分组排序
df=df.groupby(‘LABEL1’).apply(lambda x:x.sort_values(‘行数’)).reset_index(drop=True)
test2=df_test.sort_values([‘列2’,‘列3’],ascending=[True,True])

两种效果是一样的

20200325

statis.to_excel(path + ‘统计结果_’ + str(i_sam) + ‘.xls’)
前面的to_excel 如果和后面的xls 不对应的话
输出就会像上面的错误

dataframe 模糊的是df 进行比较没取到具体的值

20200322

def dot_index(x):dot_index=re.search(r'\.',str(x)).span()[0]return dot_index
df['len'] = df.iloc[:, i].apply(lambda x: 1 if ((x!=0)&(int(str(x)[(dot_index(x)+1):]) ==0) & (len(str(int(x)))==1)) else 2)

某个字符所在的索引,判断是否是个位数

for i_outlier in tqdm(range(df_.shape[1])):
# print(i_outlier)
min_ = np.percentile(df_.iloc[:, i_outlier], 0.5, interpolation=‘lower’)
max_ = np.percentile(df_.iloc[:, i_outlier], 99.5, interpolation=‘higher’)
filter=df_.iloc[:, i_outlier][(df_.iloc[:, i_outlier] > max_) | (df_.iloc[:, i_outlier] < min_)]
df_.iloc[:, i_outlier][(df_.iloc[:, i_outlier] > max_) | (df_.iloc[:, i_outlier] < min_)] = 0
dataframe 大部分都是索引问题
如果for 的指和索引相同且索引存在重复时候,第四行将会改变所有相同的索引

20200321
min_ = np.percentile(df_.iloc[:, i_outlier], 0.5, interpolation=‘lower’)
max_ = np.percentile(df_.iloc[:, i_outlier], 99.5, interpolation=‘higher’)

filter=df_.iloc[:, i_outlier][(df_.iloc[:, i_outlier] > max_) | (df_.iloc[:, i_outlier] < min_)]
有可能取出来是空值,最小和最大的值的个数都很多
这样就筛选不出来

20200320
df_sample.loc[0seg:1(seg-1),str(i_1000)]=fuzhi #划分出的数据加到sample表,复制用dataframe不行,series 才可, 左右两边形式相同
series=series
dataframe=dataframe
20200319
df.loc[True]
df[True] 二者皆可以

20200319
df = df.loc[~df.iloc[:, 0].str.contains(‘心率’), :]
series 判断是否包含某些字符
20200318

df=df[~df[col_name[0]].isin([‘0’, ‘0.0’, ‘’])]
判断某列是否含有某值

20200317
X_train = df_train.iloc[:,0:-1]
索引-1 为最后一列

20200313
空值
isna() 不能识别’’

替换成‘’,筛选的时候用 aa==‘’

excel里面的空白,读到dataframe 里面是不存在的
无法显示出来的,比如本来一列有10行,有两个空白
读入之后就只剩下8个数据,两个空白无法显示出来

ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
(sigcol0.iloc[0] + sigcolna.iloc[0]) + sigcol00.iloc[0] > df.shape[0] * 0.5
sigcol0 是series 不能 sigcol0>15 不能直接判断
必须把值取出来再判断

apply 只适合于apply

20200311

https://blog.csdn.net/qq_22238533/article/details/70917102

            np.random.shuffle(data)dataframe不能用np的shuffle
from sklearn.utils import shuffle
df = shuffle(df)

随机打乱打散
concat 合并行或者
列索引不相同就会产生错误

df.notna() 非空值
dataframe 整体选择
df=df[df!=0] 零的部分变成nan,因为其要保存整体索引的不变
df=df[df.isna()] 这样好像是不起作用的
即使是按列来操作也是不行的,因为其要按最多值的列的索引
来concat 最终还是达不到只删除空值,非空值自动靠拢的目的

为什么非空值选不出来

20200310
指定位置插入列
df_minmax.insert(loc=0,column=‘784’,value=’’)

   df_sample=pd.DataFrame({'0':[0]*seg},index=[0]*seg)创建

正则要删除 “…” 主要"."是通配符,需要转义
re.sub(r’…’, ‘.’, x) 替换的部分就不用转义了 in_file=in_file.loc[in_file.iloc[:,0]!= ‘.’] #去掉纯粹的点号
后面的等号是指整个字符为一个点号

pandas series 方法
df2 = df[df[columnname].str.contains(area)] 就是选择包含area变量中的字符串的行。

20200309
quantity=former_data.loc[former_data[‘target’]==target_,‘quantity’]
dataframe 筛选
只有loc 才有上面那种用法相当于前面指定行,后面指定列
df整体只能是整行整行的筛选

csv 没有行数限制
xlsx 最高一百多万行

20200306

写条件判断的时候,多条件组合的所有情况
还有最边上的情况要考虑完全

xlsx输出变成了这样,csv 输出则为正常

df.sample.columns = [[df[‘target’].iloc[i]]]
columns 等于的值对象是列表的列表

numpy,ndarray,dataframe 行列的对应

20200305
删除 test_dict_df.drop([‘id’],axis=1)

dataframe 的坑
data_df=data_df.dropna(thresh=0.5*data_df.shape[0],axis=0)
这里的阈值一定要设置不然一旦有一个值为空整个都会被删掉
20200304

df.iloc[:, i_outlier][(df.iloc[:,i_outlier]>max_) or (df.iloc[:,i_outlier]<min_)]= 0
or 的前后必须加括号不然就会默认 max _和or运算

对每一行和每一列进行循环处理好像只能for循环
而对每一行或者每一列里面的每个值进行处理则可以增加一行
或者一列来处理不用for循环

20200303
iloc 不能用于扩展,会报溢出错误
而loc可以直接添加行或者列
dataframe 的index 本身是个array 对象

https://blog.csdn.net/qwertyuiop5rghar/article/details/84454670
https://blog.csdn.net/qwertyuiop5rghar/article/details/84454670
增加行只能用 loc？不能用iloc
扩充数据的时候用增加行比增加列容易

http://www.voidcn.com/article/p-fnoxvztw-bxs.html
用字典随机填充数据

填充的时候前后的形状要对齐

缺失值填充
https://blog.csdn.net/donghf1989/article/details/51167083/

20200302
def sort_handling(self, df):
df_=df.astype(float)
for i_col in df_.columns:
temp_sort=df_.loc[:, i_col].sort_values()
temp_sort.index=range(temp_sort.shape[0])
df_.loc[:, i_col] = temp_sort #排序后索引没对齐需要重新更改索引
每列单独排序

       df_.loc[:, i_col] = df_.loc[:, i_col].sort_values()  #排序后索引没对齐 需要重新更改索引索引对不齐 执行不成功 需要更改索引

20200302
找出nan以及inf
https://blog.csdn.net/alanguoo/article/details/77198503

20200228

numpy数据类型dtype转换
https://www.jianshu.com/p/a1da90edf87f

dataframe 所有值筛选
df=df[df!=0]

20200226

在类里面调用其中的某个函数时候用self.aa(）
不能是在类内部,应该是在某个函数内部才能调用self

字符到数值的映射
https://blog.csdn.net/liulunyang/article/details/88089962

dataframe 增加列 insert

https://blog.csdn.net/W_weiying/article/details/85247436

dataframe array 相互转换

20200225

df[‘舒张压.17’]=df[‘舒张压.17’].apply(lambda x: ‘’ if 1-bool(x.isdecimal()) else x)
1-bool(a) True 和 False的转换
if 的前面空值,直接写‘’,不用写x=‘’ 隐含已经有x=了
https://blog.csdn.net/laoyuanpython/article/details/94214189
判断是否为数值

df_sort[‘身高’][df_sort[‘身高’]<38.0]=int(df_sort[‘身高’].mean())
某一列中选出某些值然后统一更改左边中括号里面得到的是索引
df[col][df[col] >limit]=df[col][df[col] >limit]/1000
批量处理

列名称的改写
data_df.columns=[df['label'].iloc[i]]

20200224 空值或者Nan的选择
重点
对于不确定是什么样的空值
https://www.cnblogs.com/wqbin/p/12032073.html
data_df_not_nan=data_df[data_df!=‘NaN’]
data_df_non = data_df[data_df ==‘NaN’]
data_df_1=data_df[~data_df.isnull()]
上面是针对值为none的过滤
对NaN的处理用dropna？
https://blog.csdn.net/xu136090331/article/details/94784021 这个是重点
https://www.jianshu.com/p/ab64424ee99e

上面两种为什么不起作用
https://blog.csdn.net/lwgkzl/article/details/80948548
空值的处理

df.dropna()
df[‘舒张压.17’][df[‘舒张压.17’]==’’] = 0
如果是空白那用‘’处理

本文链接：https://blog.csdn.net/luolang_103/article/details/88898526

参考：

(3条消息)pandas中的DataFrame按指定顺序输出所有列 - quintind的专栏 - CSDN博客
https://blog.csdn.net/quintind/article/details/79691574

（1）创建数据框：

import pandas as pd
grades = [48,99,75,80,42,80,72,68,36,78]
df = pd.DataFrame( {'ID': ["x%d" % r for r in range(10)],
'Gender' : ['F', 'M', 'F', 'M', 'F', 'M', 'F', 'M', 'M', 'M'],
'ExamYear': ['2007','2007','2007','2008','2008','2008','2008','2009','2009','2009'],
'Class': ['algebra', 'stats', 'bio', 'algebra', 'algebra', 'stats', 'stats', 'algebra', 'bio', 'bio'],
'Participated': ['yes','yes','yes','yes','no','yes','yes','yes','yes','yes'],
'Passed': ['yes' if x > 50 else 'no' for x in grades],
'Employed': [True,True,True,False,False,False,False,True,True,False],
'Grade': grades})
print(df)

输出：

（2）整理按指定列输出

代码：

col = ['Grade','Passed','ID','Class','Gender','Participated','Employed','ExamYear']
df=df.ix[:,cols]

输出：

(3) 数据框转化成列表

方法一：

借助数组

import numpy as np
df = np.arrary(df)
df1 = df.tolist()

方法二：

df1 = (df.values).tolist()

输出结果：

（4）数据框中某一列的值转化为字符串

df2 = (df.values).tostring()
df3 = (df['ID'].values).tostring()

输出:

不懂为啥是这个样子

希望的样子：

代码：

df4 = tuple(df['ID'])
df5 = str(df4)

输出：

datafram 转 list

-- coding:utf-8--

import numpy as np
import pandas as pd

data_x = pd.read_csv(“E:/Tianchi/result/features.csv”,usecols=[2,3,4])#pd.dataframe
data_y = pd.read_csv(“E:/Tianchi/result/features.csv”,usecols=[5])

train_data = np.array(data_x)#np.ndarray()
train_x_list=train_data.tolist()#list
print(train_x_list)
print(type(train_x_list))

-- coding: utf-8 --

“”"
Created on Sat Jul 21 20:06:20 2018

@author: heimi
“”"
import warnings
warnings.filterwarnings(“ignore”)
import pandas as pd
import numpy as np
#导入自定义模块
import sys
from pandas import Series,DataFrame
from numpy import nan as NA
from os import path

sys.path.append( path.dirname(path.dirname(path.abspath(file))))

import mytools.midtools as midtools
from matplotlib.font_manager import FontProperties
#显示中文
font=FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=12)
path=r’D:/code12temp/自己笔记/’
pd.set_option(‘display.width’,None)

Series数据的连接

s1 = Series([0,1],index=[“a”,“b”])
s2 = Series([2,3,4],index=[“c”,“d”,“e”])
s3 = Series([5,6],index=[“f”,“g”])
result = pd.concat([s1,s2,s3])
result

result = pd.concat([s1,s2,s3],keys=[“one”,“two”,“three”])
result
#直接在外面再追加一层索引

#合并重叠数据
a = Series([NA,2.5,NA,3.5,4.5,NA],index=list(“fedcba”))
b = Series(np.arange(len(a)),dtype=np.float64,index=list(“fedcba”))
pd.concat([a,b])

#用其中一个Series中的数据给另一个Series中的数据作为补丁
resultB = b[:-2]
resultB
resultA = a[2:]
resultA
resultB.combine_first(resultA) #二者索引相同的时候用ResultB的索引优先

而且B的元素为NAN的,通过A中有点来填充,B 中没有的,A中有的,直接填上

反正就是A的元素只会增加,不会减少

#创建层次化索引两层索引
data = Series(np.random.randn(10),index= [list(“aaabbbccdd”),[1,2,3,1,2,3,1,2,2,3]])
data

将行索引（index）转换到列索引上（columns）没行列

result = data.unstack()
result
result.stack()

DataFrame 中的行索引和列索引的重塑和转换

data = DataFrame(np.arange(6).reshape(2,3),
index=pd.Index([“上海”,“北京”],name=“省份”),
columns=pd.Index([2011,2012,2013],name=“年份”))
data

将DataFrame的列索引转化到行索引烈士

result = data.stack()

#将DataFrame的行索引转化为列索引
#unstack（）默认转换的最内层的层次化索引
result.unstack()
#第一种方法，转换的时候，指定层次化索引的名称
result=result.unstack(“省份”) #相当于交换了行列
result.stack()

#第二种方法，转换的时候，指定层次化的索引 0是result的第一列，1是后面一层
data=result.unstack(1)
data.unstack(1)

#在对DataFrame进行unstack操作时，作为旋转轴的级别将会成为结果中的最低级别
data = DataFrame(np.arange(6).reshape(2,3),
index=pd.Index([“Ohio”,“Colorado”],name=“state”),
columns=pd.Index([“one”,“two”,“three”],name=“nu mbers”))
data
result = data.stack()

df = DataFrame({“left”:result, #直接以series 为对象并带来了行索引
“right”:result+5},
columns=pd.Index([“left”,“right”],name=“side”))
df

result = df.unstack(“state”) #放到原来索引的下一层

s1=Series([0,1,2,3],index=list(“abcd”))
s2 = Series([4,5,6],index=list(“cde”))
#将s1和s2拼接成一个具有层次化索引的Series
result = pd.concat([s1,s2],keys=[“one”,“two”])
result
#将结果中的行索引变成列索引 #多层索引序号以零开头
tempResult = result.unstack(1)
tempResult

#全部还原，空值用NaN填充
tempResult.stack(dropna=False)

3、pandas高级应用–数据转化、清除重复数据

data = DataFrame({“k1”:[“one”]*3+[“two”]*4,
“k2”:[1,1,2,3,3,4,4]})
#第一种方法，去重
#检测DataFrame中的每行数据是否为重复数据行
mask = data.duplicated() #当前行的记录和上一行记录进行比较
mask

#通过花式索引去除重复的数据
data[~mask] #保留为false的

#第二种方法:去重
#通过DataFrame内置的drop_duplicates()方法去除重复的数据行.
#去除

data.drop_duplicates()
data[“v1”] = range(7)

只以k1这一列为标准去重

data.drop_duplicates([“k1”])

#通过制定keep参数制定需要保留特定的重复数据
#keep=“first” 保留重复数据第一次出现的行索引
#keep=“last” 保留重复数据最后一次的行索引
#keep=False 只要有重复数据，就全部丢掉

data=DataFrame({‘food’:[‘bacon’,‘pulled pork’,‘bacon’,‘Pastrami’,
‘corned beef’,‘Bacon’,‘pastrami’,‘honey ham’,‘nova lox’],
‘ounces’:[4,3,12,6,7.5,8,3,5,6]})

meat_to_animal={
‘bacon’:‘pig’,
‘pulled pork’:‘pig’,
‘pastrami’:‘cow’,
‘corned beef’:‘cow’,
‘honey ham’:‘pig’,
‘nova lox’:‘salmon’}
data[“animal”]=data[“food”].map(str.lower).map(meat_to_animal)
data[“animal”] = data[‘food’].map(lambda x: meat_to_animal[x.lower()])
#这里的x.lower相当key了

4、pandas高级应用–数据替换

series = Series([1,-999,2,-999,-1000,3])
#单个数据替换
series.replace(-999,NA)
#多个数据替换
series.replace([-999,-1000],NA)

#replace方法传入字典，针对不同的值，进行不同的替换
#第一种方法
series.replace({-999:NA,-1000:0})

#第二种方法
series.replace([-999,-1000],[NA,0])

5、pandas高级应用–数据拆分

from matplotlib import pyplot as plt

age = [20,22,25,27,21,23,37,31,61,45,41,32]
#将所有年龄进行分组
bins = [18,25,35,60,100] #前开后闭
#使用pandas中的cut对年龄数据进行分组
cats = pd.cut(age,bins)

#调用pd.value_counts方法统计每个区间段的人数
pd.value_counts(cats) #直接统计

#区间属于那一行索引按大小排序的
cats.codes

#为分类出每一组年龄加上标签
group_names = [“Youth”,“YouthAdult”,“MiddleAged”,“senior”]

#用group_name中的值，把区间替换
personType = pd.cut(age,bins,labels=group_names) #为什么这里不对

plt.hist(personType)
plt.show()

06、pandas高级应用–数据分割

data = np.random.randn(1000) # 服从正太分布
result = pd.qcut(data,4) # cut将data数据均分为4组
result

统计落在每个区间的元素个数

pd.value_counts(result)

cut函数分割一组数据 cut计算：找出data中的最大值最小值，之差除以4，得出区间值，然后以这个区间值分四份

data = np.random.randn(20)

用cut函数将一组数据分割成n份 precision:保留小数点的有效位数

result = pd.cut(data,4,precision=2)
pd.value_counts(result)

data = np.random.randn(1000)

根据分位数差的百分比分割

result=pd.qcut(data,[0,0.1,0.5,0.9,1.0])
pd.value_counts(result)

如果分为数的差值的和小于1的情况分割的结果，安装分位数差之和计算

result = pd.qcut(data,[0,0.1,0.3,0.75])
pd.value_counts(result)

series.str.contains

http://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.str.contains.html

07、pandas高级应用–数据的过滤和筛选

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

np.random.seed(num) #num是生成随机数的种子

np.random.randn() ##默认生成随机数的种子数是当前时间的时间戳

#定义一个种子数
np.random.seed(33)
np.random.rand()

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

简单的数据统计信息

data.describe()

获取数据的第四列

col = data[3]

筛选出绝对值大于3的数 #对series 直接饮用 np的数学函数,用中括号来放置条件

col[np.abs(col)>3]

查找出数据集中有任意某一列的值出现大于3的行数据

data[(np.abs(data)>3).any(1)] #对所有列进行处理

将所有绝对值大于3的正数设置为3，绝对值大于3的负数设置为-3

获取数据的符号

data[np.abs(data)>3] = np.sign(data)*3 #取符号
data.describe()

08、pandas高级应用–读写文件数据

import sys

pandas读取csv文件

data = pd.read_csv(‘data/ex1.csv’)
data

读取的csv文件没有标题，默认分配表头索引

pd.read_csv(‘data/ex2.csv’,header=None)

自定义添加标题

pd.read_csv(‘data/ex2.csv’,names=[‘a’,‘b’,‘c’,‘e’,‘name’])

指定行索引

pd.read_csv(‘data/ex2.csv’,names=[‘a’,‘b’,‘c’,‘e’,‘name’],index_col=‘name’) #不是很懂

将读取的数据进行层次化索引

pd.read_csv(‘data/csv_mindex.csv’,index_col=[‘key1’,‘key2’])

通过skiprows参数指定需要跳过的行索引

pd.read_csv(‘data/ex4.csv’,skiprows=[0,2,3])

加载存在NaN值缺值数据，把na_values对应的值替换为NaN

pd.read_csv(‘data/ex5.csv’,na_values=3)

把数据集中的NAN值替换

data.to_csv(sys.stdout,na_rep=[‘NULL’])

只写入数据，不写入行和列的索引

data.to_csv(sys.stdout,index=False,header=False)
data.to_csv(‘data/aa.csv’,index=False,header=False)

通过columns来指定写入文件中的列

data.to_csv(sys.stdout,index=False,columns=[‘a’,‘c’,‘message’])

09、pandas高级应用–数据的聚合及分组计算

df = DataFrame({“key”:[‘a’,‘a’,‘b’,‘b’,‘a’],
“key2”:[‘one’,‘two’,‘one’,‘two’,‘one’],
“data1”:np.random.randn(5),
“data2”:np.random.randn(5)})
df

选取data1数据列按照key1进行分组

groupd = df[“data1”].groupby(df[‘key’]) #除了可以按列分组,也可以按行分组

调用已经分组好的数据中一些方法，即可得出相应的统计结果

获取分组中每一组数据的平均值

groupd.mean()

根据key和key2两个列数据进行分组

grouped = df[‘data1’].groupby([df[‘key’],df[‘key2’]])

求平均

grouped.mean()

获取分组后每一组中相应元素出现的次数

df.index
df.groupby([df[‘key’],df[‘key2’]]).size() #或 df.groupby([‘key’,‘key2’]).size() #按行索引分组

for in 循环输出分组的结果

for name,group in df.groupby(“key”):
print(name)
print(group)

将groupby 分类结果转化成字典

pices = dict(list(df.groupby(‘key’))) #list的时候以逗号分隔key和values,dict 以分号代替逗号
pices[‘b’]

按照列的数据类型分组

group = df.groupby(df.dtypes,axis=1)
dict(list(group))
group.size()

选择分类数据中的一个或一组

方法一：生成的数据类型是DataFrame

df.groupby([‘key’,‘key2’])[[‘data2’]].mean()

方法二：生成的类型是series

df[‘data2’].groupby([df[‘key’],df[‘key2’]]).mean() #series 的groupby 和 dataframe 的groupby 是不一样的

方法三：

df.groupby([‘key’,‘key2’])[‘data2’].mean()

通过字典或series进行分组

people = DataFrame(np.random.randn(5,5),columns=list(‘abcde’),index=[‘Joe’,‘Stenve’,‘Wes’,‘Jim’,‘Travis’])
people

创建一个将列名进行映射的字典

mapping = {‘a’:‘red’,‘b’:‘red’,‘c’:‘blue’,‘d’:‘blue’,‘e’:‘red’,‘f’:‘orange’}
by_columns = people.groupby(mapping,axis=1) #相当于对列进行分组
gp=dict(list(by_columns)) #分组之后结果展示
gp[‘blue’]
by_columns.sum() #横向相加

将mapping转化成Series

seriesMap = Series(mapping)

people.groupby(seriesMap,axis=1).count() #即是不是这个dataframe的列也是可以作为分组的 #对列的数目进行统计对每个行索引来说

分组后常用的计算方法

dict_obj = {‘key1’ : [‘a’, ‘b’, ‘a’, ‘b’, ‘a’, ‘b’, ‘a’, ‘a’],
‘key2’ : [‘one’, ‘one’, ‘two’, ‘three’, ‘two’, ‘two’, ‘one’, ‘three’],
‘data1’: np.random.randint(1,10, 8),
‘data2’: np.random.randint(1,10, 8)}
df = DataFrame(dict_obj)

按照key1进行分组求和

df.groupby(‘key1’).sum()
df[[‘data1’]].groupby(df[‘key1’]).sum()

求最大值

df.groupby(‘key1’).max()

df.groupby(‘key1’).describe()

第一种方法

定义一个函数，求获得DataFrame中某一列数据的最大值和最小值之差

def peak_range(df):
print(type(df))
return df.max()-df.min()

df.groupby(‘key1’).agg(peak_range) #分组之后对每列进行函数处理

用匿名函数的方式

第二种方法

df.groupby(‘key1’).agg(lambda df: df.max()-df.min())

使用agg对分组后的数据调用多个聚合函数

df.groupby(‘key1’).agg([‘mean’,‘sum’,‘count’,‘min’,‘std’,peak_range]) # 带引号的参数是内置聚合函数

df.groupby(‘key1’).agg([‘mean’,‘sum’,‘count’,‘min’,‘std’,(‘ptp’,peak_range)]) #peak_range 给peak_range起一个别名，叫ptp #起别名

使用字典实现数据集的每列作用不同的聚合函数

dict_mapping = {‘data1’:‘mean’,‘data2’:‘sum’}
df.groupby(‘key1’).agg(dict_mapping) #agg 传入函数对每列进行不同的操作

以"没有索引形式"返回聚合函数的计算结果

df = pd.DataFrame(data={‘books’:[‘bk1’,‘bk1’,‘bk1’,‘bk2’,‘bk2’,‘bk3’], ‘price’: [12,12,12,15,15,17]})

将分组之后的books列作为索引

df.groupby(“books”,as_index=True).sum() #默认对剩下的price 进行处理

不让分组之后的books列作为索引

df.groupby(“books”,as_index=False).sum()

tips=pd.read_csv(path+’/input/pandasData/tips.csv’,encoding=‘gbk’)

10、pandas高级应用–分组计算apply

为tips数据集添加新的一列，作为客户给的小费占消费总额的百分比

tips[‘tip_pct’] = tips[‘tip’]/tips[‘total_bill’]

定义函数，筛选出小费占比最大的前五条数据

def top(df,n=5,columns=‘tip_pct’):
return df.sort_values(by=columns)[-n:]
top(tips,n=6)

#对数据集按抽烟进行分组
group = tips.groupby(‘smoker’)

group

使用apply方法分别求出抽烟和不抽烟的客户中的消费占比排在前五客户

group.apply(top) #直接对分组结果进行应用函数相当于对两类都进行了处理

显示抽烟和不抽烟客户的数量

group.size()
group.count()

为apply中使用的函数传参

tips.groupby([‘smoker’,‘day’],group_keys=False).apply(top,columns=‘total_bill’,n=2) #前面是函数,后面是参数
#不显示key
frame = pd.DataFrame({‘data1’: np.random.randn(1000),
‘data2’: np.random.randn(1000)})

result = pd.cut(frame.data1,4) #每个值对应一个区间
pd.value_counts(result)

定义一个函数，求data1数据列各项参数计算

def get_stats(group):
return { ‘min’: group.min(), ‘max’: group.max(),
‘count’:group.count(), ‘mean’: group.mean() }
grouped = frame.data2.groupby(result)

dict(list(grouped))

grouped.apply(get_stats).unstack()

加权平均和相关系数

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’)
grouped.size()

Python数据处理进阶——pandas

https://www.cnblogs.com/llhy1178/p/6762459.html

df = DataFrame(np.random.randn(4,3), columns= list(“bde”),
index= [“Utah”, “Ohio”, “Texas”, “Oregon”])

print np.abs(df)

将函数应用到各列或行所形成的一维数组上。

f = lambda x : x.max() - x.min()

每一列的最大值减最小值

print (df.apply(f, axis=0))

每一行的最大值减最小值

print (df.apply(f, axis=1))

返回值由多个值组成的Series

def f(x):
return Series([x.min(), x.max()], index=[“min”,“max”]) #对每列进行处理
print (df.apply(f)) #默认是对列进行操作

保留两位小数点

format = lambda x : “%.2f” % x
print (df.applymap(format)) #apply对series和对整个dataframe,applymap 对整个dataframe,map对series
print (df[“e”].map(format))

通过建立函数可以实现对数据库所有元素的修改操作
对dataframe的整体操作所有元素操作

总的来说就是apply()是一种让函数作用于列或者行操作，applymap()是一种让函数作用于DataFrame每一个元素的操作，而map是一种让函数作用于Series每一个元素的操作

排序和排名

obj = Series(np.arange(4.), index=[“b”,“a”,“d”,“c”])

print obj.sort_index()

frame = DataFrame(np.arange(8).reshape((2,4)),index=[“three”,“one”],
columns=[“d”,‘a’,‘b’,‘c’])

按照索引的行进行排序

print (frame.sort_index(axis=1))

按照索引的列进行排序

print frame.sort_index(axis=0)

按照值的列进行排序（必须传入一个列的索引且只能排列一组）

frame.sort_values(‘b’, axis=0, ascending=False)

按照值的行进行排序(必须传入一个行的索引且只能排列一组)

frame.sort_values(“one”, axis=1, ascending=False)

根据多个列进行排序

frame.sort_index(by=[“a”,“b”])

排名

obj1 = Series([7,-5,7,4,2,0,4])
obj1.rank()

加减乘除 add代表加，sub代表减， div代表除法， mul代表乘法

df1 = DataFrame(np.arange(12).reshape((3,4)), columns=list(“abcd”))
df2 = DataFrame(np.arange(20).reshape((4,5)), columns=list(“abcde”))

df1 + df2 #找不到匹配的位置直接为空

将缺失值用0代替

df1.add(df2, fill_value=0) #找不到匹配的位置用单独一方的值替代

再进行重新索引时，也可以指定一个填充值

df1.reindex(columns=df2.columns, fill_value=0)

data = {“state”: [“Ohio”,“Ohio”,“Ohio”,“Nevada”,“Nevada”],
“year” : [2000, 2001, 2002, 2001, 2002],
“pop” : [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = DataFrame(data)

frame

矩阵的横坐标

frame.columns

矩阵的纵坐标

print frame.index

获取列通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series：

print frame[“state”]

print frame.year

获取行也通过类似字典标记的方式或属性的方式，比如用索引字段ix

print frame.ix[3]

精准匹配

val = Series([-1.2, -1.5, -1.7], index=[“two”, “four”, “five”])
frame.index = Series([‘one’, ‘two’, ‘three’, ‘four’, ‘five’])
frame.debt = val #debt 是啥东东

print frame

为不存在的列赋值存在列中的某个值会创建出一个布尔列。关键字del用于删除列。

frame[“eastern”] = frame.state == “Ohio”

del frame[“eastern”] # 只能这样表示删除列

嵌套字典

pop = { “Nevada” : {2001 : 2.4, 2002 : 2.9},
“Ohio” : {2000 : 1.5, 2001 : 1.7, 2002 : 3.6}
}

传给DataFrame，它会被解释为：外层字典的键作为列，内层键则作为行索引

frame2 = DataFrame(pop)

对该结果进行转置

frame2.T

内层字典的键会被合并、排序以形成最终的索引。

frame3 = DataFrame(pop, index=[2001, 2002, 2003])
frame3.index.name = “year”; frame3.columns.name = “state” #索引和列只有一个名字

重新索引

obj = Series([4.5, 7.2, -5.3, 3.6], index=[“d”, “b”, “a”, “c”])

reindex将会根据新索引进行重排。

obj2 = obj.reindex([“a”, “b”, “c”, “d”, “e”])

print obj2

将缺失值用0代替

obj2 = obj.reindex([“a”, “b”, “c”, “d”, “e”], fill_value= 0)

print obj2

插值处理–Series

obj3 = Series([“blue”, “purple”, “yellow”], index=[0,2,4])

前向填充ffill或pad

obj3.reindex(range(6), method=“ffill”)

print a

后向填充bfill或backfill

b = obj3.reindex(range(6), method=“bfill”)

print b

插值处理–DataFrame

import numpy as np
f = DataFrame(np.arange(9).reshape((3,3)), index=[“a”,“c”,“d”],
columns=[“Ohio”, “Texas”, “California”])

改变行的索引

f2 = f.reindex([“a”,“b”,“c”,“d”], fill_value=9)

print f2

改变列的索引

col = [“Texas”, “Utah”, “California”]
f3 = f.reindex(columns=col)

print f3

同时改变列和行的索引不成功

f4 = f.reindex([“a”,“b”,“c”,“d”], method=“ffill”,
columns=[“Texas”, “Utah”, “California”])

print f4

丢弃指定轴上的项–Series

mys = Series(np.arange(5.), index=[“a”,“b”,“c”,“d”,“e”])

print mys

drop（）删除某个索引以及对应的值

mys_new = mys.drop(“c”)

print mys_new

mys_new1 = mys.drop([“c”,“e”])

print mys_new1

丢弃指定轴上的项–DataFrame

data = DataFrame(np.arange(16).reshape((4,4)),
index=[“Ohio”, “Colorado”, “Utah”, “New York”],
columns=[“one”, “two”, “three”, “four”])

删除某行轴上的值

data1 = data.drop([“Ohio”,“Utah”], axis=0) # axis=0代表行

print data1

删除某列轴上的值

data2 = data.drop([“one”,“three”], axis=1) # axis=1代表列

print data2

obj = Series(range(5), index=[‘a’, ‘a’, ‘b’, ‘b’, ‘c’])

使用is_unique属性可以知道他的值是否是唯一的

obj.index.is_unique

obj[‘a’]

df = DataFrame(np.random.randn(4, 3), index=[‘a’, ‘b’, ‘a’, ‘b’])
df.ix[“b”, 1]
df[1]

pandas中的索引高级处理：

索引、选取和过滤–Series

obj = Series(np.arange(4), index=[“a”,“b”,“c”,“d”])

print obj[“b”]

print obj[1]

print obj[2:4]

print obj[[“b”,“a”,“d”]]

print obj[[1,3]]

print obj[obj < 2]

利用标签的切片运算与普通的python切片运算不同，其末端是包含的

print obj[“b”:“c”]

obj[“b”:“c”] = 5

print obj

结束

dataframe,python,numpy 问题索引1相关推荐

dataframe,python,numpy 问题索引2
20220330 print(frame3.isnull().any()) 找出存在空值的列 print("========================") print(fra ...
python numpy矩阵索引_Numpy中的矩阵索引
索引后查看形状:In [295]: A=np.matrix([1,2,3]) In [296]: A.shape Out[296]: (1, 3) In [297]: A[0] Out[297]: m ...
python numpy矩阵索引_python – Numpy中的矩阵索引
索引后查看形状: In [295]: A=np.matrix([1,2,3]) In [296]: A.shape Out[296]: (1, 3) In [297]: A[0] Out[297]: ...
【Python语言基础】——Python NumPy 数组索引
Python语言基础--Python NumPy 数组形状文章目录 Python语言基础--Python NumPy 数组形状一.Python NumPy 数组形状一.Python NumPy ...
python numpy矩阵索引_python-为什么scipy csr矩阵的行索引比numpy数组...
我在下面演示的简短答案是,构造新的稀疏矩阵非常昂贵.开销很大,不依赖于行数或特定行中非零元素的数量. 稀疏矩阵的数据表示形式与密集阵列的数据表示形式完全不同.数组将数据存储在一个连续的缓冲区中,并有效 ...
python numpy花哨索引
1 import numpy as np 2 rand = np.random.RandomState(42) 3 4 x = rand.randint(100, size=10) 5 print(x ...
python numpy array索引_Python NumPy 数组索引
1.访问数组元素数组索引与访问数组元素相同. 您可以通过引用其索引号来访问数组元素. NumPy数组中的索引以0开头,这意味着第一个元素的索引为0,第二个元素的索引为1等. 例如: 从以下数组中获取 ...
python将ElasticSearch索引数据读入pandas dataframe实战
python将ElasticSearch索引数据读入pandas dataframe实战 # 导入基础包和库 import pandas as pdpd.set_option('display.max ...
Python之pandas：对pandas中dataframe数据中的索引输出、修改、重命名等详细攻略
Python之pandas:对pandas中dataframe数据中的索引输出.修改.重命名等详细攻略目录对pandas中dataframe数据中的索引输出.修改.重命名等详细攻略知识点学习输 ...

dataframe,python,numpy 问题索引1

参考：

(3条消息)pandas中的DataFrame按指定顺序输出所有列 - quintind的专栏 - CSDN博客 https://blog.csdn.net/quintind/article/details/79691574