python笔记（一）notebook

 `shift +enter`运行代码块, 选择下面的代码块(在编辑模式下也可用)

`x`剪切，`c`复制，`v`粘贴

`a`: 在上面插入代码块 `b`: 在下面插入代码块

如何为Jupyter Notebook添加目录功能 - 知乎

给jupyter安装目录插件时报错:Jupyter command `jupyter-contrib-nbextension` not found._CDA答疑社区

pip install xx -i http://pypi.douban.com/simple --trusted-host pypi.douban.com

查看宏包版本——conda list

显示图像

import matplotlib.pyplot as plt

%matplotlib inline

seaborn格式

import seaborn as sns

sns.set()

#取消科学计数法，直接显示小数

pd.set_option('display.float_format', lambda x: '%.3f' % x)

np.set_printoptions(suppress=True)

# df显示中文

plt.rcParams['font.sans-serif']=['SimHei']  

plt.rcParams['axes.unicode_minus']=False

取消版本warnning

import warnings

warnings.filterwarnings("ignore")

读取数据

df1 = pd.read_csv(r'C:\Users\Mac Book Air\Desktop\作业5\\car_increase.csv',encoding='gbk',sep = ',')

输出：

data_idmax.to_csv('./month+year.csv')

plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签

plt.rcParams['axes.unicode_minus']=False #用来正常显示负号

随机生成

frame = pd.DataFrame({'data1': np.random.randn(1000),

:                       'data2': np.random.randn(1000)})

常用操作

基本操作：

缺失值处理

数据替换

索引重命名

离散化

过滤异常值

排列和随机采样

 

# 去重

df.drop_duplicates(subset=['A','B','C'],keep='first',inplace=True)

参数说明如下：

删除后出现的重复值：

df['city'].drop_duplicates()

删除先出现的重复值：

df['city'].drop_duplicates(keep='last')

删除空值和inf值

data4[~data4.isin([np.nan, np.inf, -np.inf]).any(1)]

删除某几列空值

df_all.drop(index = df_all[df_all['pro_pay_amt'].isna()) |  df_all['is_refund'].isna()].index,inplace=True)

删除某列某值

df_all.drop( index = df_all[df_all['data_date']== 202105].index , inplace =True)

#缺失值填充

时间序列——历史数据平移 <多重时序高阶算法-DeepAR（供水管网压力预测Baseline） - 知乎>

基本函数

dropna默认丢弃任何含有缺失值的行，axis=1 丢弃列

1、用数字0填充空值：

df.fillna(value=0)

用ptype_id替换空值

data['parent_ptype_id'].fillna(data['ptype_id'], inplace=True)

2、使用列均值对NA进行填充：

data.fillna(data.mean())

df['price'].fillna(df['price'].mean())

传入一个整数值，当行或列低于该值时删除，大于等于时不删除

当每行至少有一个不是空值时保留，全部为空时删除

rs=df.dropna(axis=0,thresh=1)

subset = [ 'a','d'] 即丢弃子列 a d 中含有缺失值的行

删除toy中含有空值的行，

rs=df.dropna(axis=0,subset=["toy"])

创建函数，用apply填充

fill_mean = lambda g: g.fillna(g.mean())

In [103]: data.groupby(group_key).apply(fill_mean)

直接填充

df_sub['mean'] = df_sub['mean'].fillna(df_sub['加油价格'])

Map（更智能）

应用错误收集

import pandas as pd

hair=pd.read_excel('practice.xlsx')

hair.isnull()

help(hair.dropna)

hair.dropna(how='all')  #全为空的记录删除

hair.dropna()  #默认，有一项为空的记录删除

hair.fillna(hair.mean(),inplace=True) #用均值填充数据,直接更改原始数据

hair2=hair.fillna(method='ffill') #用上一个非缺失值填充，bfill用下一个

# KNN

from sklearn.impute import KNNImputer

imputer = KNNImputer(n_neighbors=10)

imputed = imputer.fit_transform(df2)

df_imputed = pd.DataFrame(imputed, columns=df2.columns)

通用缺失值处理方法

from sklearn.preprocessing import Imputer

imputer = Imputer(strategy="median")   # 选择中位数方法填充

imputer.fit(housing_num)    # inputer方法拟合

X = imputer.transform(housing_num)

strategy =‘median’，代表取所在列的中位数进行填充

most_frequent’, 代表取所在列的众数进行填充

axis=0，代表按列进行填充

1，代表按行进行填充

输出缺失值所占比例

def missing_data(data):

    total = data.isnull().sum()

    percent = (data.isnull().sum()/data.isnull().count()*100)

    tt = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])

    types = []

    for col in data.columns:

        dtype = str(data[col].dtype)

        types.append(dtype)

    tt['Types'] = types

    return(np.transpose(tt))

# 异常值

绝对值

col[np.abs(col) > 3]

data[(np.abs(data) > 3).any(1)]   #  选出全部含有“超过3或－3的值”的行

data[np.abs(data) > 3] = np.sign(data) * 3  #  将值限制在区间－3到3以内

any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

元素除了是 0、空、FALSE 外都算 TRUE。

df3 = df_imputed[np.abs(df_imputed-df_imputed.mean()) <= 3 *df_imputed.std()]

imputer = KNNImputer(n_neighbors=3)

imputed = imputer.fit_transform(df3)

df_final = pd.DataFrame(imputed, columns=df3.columns)

明显超出传感器量程或者不合常理的数值，比如压力小于0或者大于0.5

瞬时突变类的数值，这里采用z_score进行筛选

连续常值，这类数据一般为传感器故障或者是传感器处于标定状态。通过判断连续时间段的方差即可。

def remove_abnormal(df):
    df[df[G_POST_LIST]<=0.1] =None
    df[df[G_POST_LIST]>=0.5] =None
    return df

def remove_abnormal_z_score(df,by_col='hour',th =3 ):
    for pos in tqdm(G_POST_LIST):
        df_zscore=df[[pos,by_col]].copy()
        f_zscores_all = pd.Series()
        for i in range(24):
            f_zscores=(df_zscore[df_zscore[by_col]==i][pos]-df_zscore[df_zscore[by_col]==i][pos].mean())/df_zscore[df_zscore[by_col]==i][pos].std()
            f_zscores_all= pd.concat([f_zscores_all,f_zscores])
        f_zscores_all.sort_index(inplace=True)
        df_zscore.loc[f_zscores_all.abs()> th,pos] = None # must use loc
        df[pos] = df_zscore[pos]
    return df

def remove_abnormal_zero_var(df,window =3,th=1e-07):
    for pos in tqdm(G_POST_LIST):
        df_pos=df[[pos]].copy()
        df_pos['var']=df_pos[pos].rolling(window=window,center=False).std()
        df_pos.loc[df_pos['var'] <= th,pos] = None # must use loc
        df[pos] = df_pos[pos]
    return df

离散化

pd.cut(ages, [18, 26, 36, 61, 100], right=False)

  数据集ages按list的数值分割

pd.value_counts(cats)是pandas.cut结果的面元计数。

跟“区间”的数学符号一样，圆括号表示开端，而方括号则表示闭端（包括）。哪边是闭端可以通过right=False进行修改：

分箱

pd.cut(df.AGE,5,labels = range(5)) #将AGE这一列等宽分为5个箱子，标签0-4

pd.qcut(df.AGE[:20],5,labels = range(5))  #每个箱子个数均衡,划分前二十个数据

np.sign(data).head()  #直接根据正负返回1/-1

# 标准化

#标准化

scaler = sklearn.preprocessing.StandardScaler().fit(train)

scaler.transform(train)

scaler.transform(test)

实际应用中，需要做特征标准化的常见情景：SVM

 

# 直接处理

df.apply(lambda x : (x-np.min(x))/(np.max(x)-np.min(x)))

# 分组标准化

df.groupby('A').apply(lambda x: (x - np.min(x)) / (np.max(x) - np.min(x)))

分组编号

MyData['sort_id'] = MyData['salary'].groupby(MyData['dep_id']).rank()

#归一化

(df-df.min())/(df.max()-df.min())

#或者用库

from sklearn import preprocessing

preprocessing.minmax_scale(df)

#小数定标：移动小数点位置

import numpy as np

df/(10**(np.ceil(np.log10(df.abs().max()))))

特征二值化，多分类问题转化为二分类问题，通过设定阈值分为0，1

from sklearn.preprocessing import Binarizer

sklearn.preprocessing.LabelEncoder

#Binarizer()函数  LabelEncoder()函数

x=boston.target.reshape(-1,1) #转换成列向量

Binarizer(threshold=20.0).fit_transform(x) #阈值20

 

哑变量/计算指标

将一列中的K个值转化为k列二进制变量

pd.get_dummies(df['key'])
Out[110]:  a  b  c

dummies = pd.get_dummies(df['key'], prefix='key')

In [112]: df_with_dummy = df[['data1']].join(dummies)

Out[113]:    data1  key_a  key_b  key_c  #添加列名前缀

直接分列

 for x in movies.genres:    

all_genres.extend(x.split('|'))

• df['等距分箱'] = pd.cut(df['年龄'] ,4) # 实现等距分箱，分为4个箱
• df['等频分箱'] = pd.qcut(df['年龄'],4) # 实现等频分箱，分为4个箱
• 异常处理，异常值有以下几类：
• 有参照，用另一列映射
• 分组填充
• subset：表示要进去重的列名，默认为 None。
• keep：有三个可选参数，分别是 first、last、False，默认为 first，表示只保留第一次出现的重复项，删除其余重复项，last 表示只保留最后一次出现的重复项，False 则表示删除所有重复项。
• inplace：布尔值参数，默认为 False 表示删除重复项后返回一个副本，若为 Ture 则表示直接在原数据上删除重复项。
• 去重函数：drop_duplicates()