python 从原有data取出一部分数据变成新的data

numpy:支持大量的维度数组与矩阵运算

array

import numpy as np#导入库并别名
x = np.array([[1,2],[2,3]],int)#创建int型的数组
#array([[1, 2],
#     [2, 3]])
x.ndim#维度 2
x.shape = (1,3)#几行几列 可改变 x.shape可查看
x.dtype#元素类型
x.itemsize#每个元素多少字节
np.arange(1,10,1)#array([1, 2, 3, 4, 5, 6, 7, 8, 9]) 从1到10，间隔为1创建数组
np.linspace(2,4,5)#array([2. , 2.5, 3. , 3.5, 4. ]) 2到4均匀间隔创建数组 等差数组
np.logspace(2,4,2)#array([  100., 10000.]) 等比数组
np.zeros(2,3)#2行3列全为0的数组
np.eye(3)#标准数组
np.ones((1,3))#一行三列全为1的数组
np.bool/int/float64(12)#类型转换
np.random.random((2,3))#随机生成2行3列
np.random.rand(2,3)#随机生成2行3列正态分布的数组 包含0，不包含1
np.random.randn(2,3)#也是正态分布 具有负数
np.random.randint(2,10,size = [2,3])#给定随机数的上下限

#数组操作
array = np.array([[1,2],[2,3]],int)
array.sum()#和 mean 均值 std 标准差 var 方差 argmin 最小值的索引 cumsum 元素累计和 cumprod 元素累计积
array.flatten()#数组横向展平 不改变原来的
array.flatten('F')#数组纵向展平 不改变原来的
np.hstack((arr1,arr2))#横向组合 np.vstack((arr1,arr2)) 纵向
np.concatenate((arr1,arr2),axis = 1)#axis=1 横向组合 0纵向组合
np.hsplit(arr1,2)#横向切割成2个数组 np.vsplit(arr1,2) 纵向
np.split(arr,2,axis = 1)#axis=1 横向 0纵向

矩阵

import numpy as np
np.matrix([[123],[456],[789]])#创建 
np.mat('123,456,789') #创建
np.bmat('arr1 arr2;arr2')#创建
mat.T/H/I/A#T转置 H共轭矩阵 I逆矩阵 A2维数组的视图

文件读写

import numpy as np
np.save("./...",arr)#np.saves("./...",arr1,arr2) 将数组存入文件
np.load("./..")
np.savetxt("./...",arr,fmt = "%d",delimiter = ",")#fmt 整数类型存入 delimiter 用什么隔开
np.loadtxt("./",delimiter=",")#文件加载到一个二维数组中 delimiter 用什么隔开

matplotlib：绘图

import matplotlib as plt#导入库
plt.figure(figsize=(3,5),facecolor= 'red')#figsize尺寸：3×5 红色的画布
plt.show()#展示出来
#散点图
plt.scatter([1,2,3,4],[2,4,6,8],[10,20,30,40],['r'])#x,y,点的大小，颜色
#折线图
plt.plot([1,2,3,4],[2,4,6,8],'r')#x,y,颜色
#直方图
plt.bar([1,2,3,4],[3,5,6,7])#x,y
#箱线图
plt.boxplot()

pandas

Series:一维数组

import pandas as pd#导入
a = pd.Series([1,2])#a.index 行标签即0 1 没有列标签（columns）a.dtype类型
#0    1
#1    2
#dtype: int64

DataFrame:二维数组

import pandas as pd
b = pd.DataFrame([[1,2],[3,4]])#b.index行标签 b.columns列标签 b.shape b.dtypes类型
#   0  1
#0  1  2
#1  3  4
b.index = ['a','b']#更改行标签 列标签数据 a.columns = ['','']
b.rename(index={'a':'aa'},inplace=True(是否对原来产生变更))#更改某一个行标签
b.reindex(list('3'))#丢弃1 2行并且新增3行 赋值NAN
b.set_index(0)#设置0列为标签 a.reset_index()#reset标签
#访问数据 其中loc按标签值访问、iloc按数字索引访问
b[0:1]#访问0行所有列


a.query('aa*2 == ab')#aa列乘以2等于ab列的数据
a.get('aa')#取aa列或者aa行
a.loc['a']#取索引为‘a’的行 a.iloc[0]取第一行
a.loc[:,['aa']]#取aa列所有行 a.iloc[:,[0]]取第一列所有行
a.loc[['a'],['aa']]#取index为a，列名为aa的数据  a.iloc[[0],[0]]#取第一行第一列的数据
a.loc[a['a']==0]#提取data数据(筛选条件: a列中数字为0所在的行数据)

数据读写

import pandas as pd
pd.read_csv('./...'，sep=',',name=['',''],hander=0,index_col='name')#读取文本
#一些常用参数
#sep delimiter delim_whitesoace(True: 空格为分隔符) 分隔符 names 可以设置表头的名称 hander:设置第几行做表头 index_col=''设置什么作为索引
#converters：在读取数据的时候对列数据进行变换，例如将id增加10，但是注意 需要int(x)，在使用converters参数时，解析器默认所有列的类型为 str，所以需要进行类型转换。
#true_values=['1']和false_value：指定哪些值应该被清洗为True（例如1），哪些值被清洗为False.
#skiprows=[1]过滤掉第一行 skipfooter末尾开始算起过滤
pd.to_csv('./....',sep=' ',na_rep='wu')#写入文本
#na_rep 将NAN替换成什么 columns指定哪些列写进去 header 表头 index True:写入索引
read_excel() to_excel()#excel文件
read_sql() to_sql()#sql文件

对数据进行处理

合并数据

import pandas as pd
import numpy as np
pd.concat([ser1,ser2],axis=1,join='inner(交集)默认/outer(并集)')#横向表堆叠 行连接 左右合并
pd.concat([ser1,ser2],axis=0(默认),join='inner(交集)默认/outer(并集)')#纵向表堆叠 列连接上下连接
pd.merge(ser1,ser2,hwo='inner(交集)默认/outer(并集)',left_on=key1,right_on=key2(指定主键))#主键合并 2张表有共同的一列 data1.join(data2):两个键名称必须一样
pd.data1.combine_first(data2)#重叠合并 表基本一样有一点不同

清洗数据

1.记录重复

data1.drop_duplicates(subset=['id'](同id的就去除),keep='First/Last(保留第一个还是最后一个 默认全部去除)')#去除重复记录的数据

2.特征重复

data[['id','age']].corr()#id和年龄相似度 只能算数字
data[i].equals(date[j])#字符串相似度 可以用于id

3.缺失值

data.describe()#简单查看
data.isnull()#是缺失值返回True 可用data.isnull().sum()#求和查看对比data.sum()
data.motnull()#不是缺失值返回False

处理1-删除

data.dropna(subset=['id'](删除id有缺失的那行),axis=0(删除行))#删除缺失数据的一整行

处理2-替换

data['name'].fillna('wu')#name中缺失的填wu data['id'].value_counts()查看数据的数量   查看后可以填补数据多的保持较好的均值和方差
data['name'].fillna(data['name'].value_counts().index[0])#data['name'].value_counts()自动排序将对多的name排在第一行
#对于数字：
data['sum'].fillna(data['sum'].mean())#替换均值

处理3-插值法

线性插值

from scipy.interpolate import interp1d 导入求线性方程的函数
model = intero1d(x,y,kind = 'linear')#求出xy的线性方程
model（[4,5]）#假如x=[1,2,3,6]

例子

import numpy as np
x = np.array([1, 2, 3, 6, 7])
y = np.array([3, 5, 6, 9, 13])
from scipy.interpolate import interp1d
model = interp1d(x, y, kind='linear')
model([4, 5])#array([7., 8.])
import matplotlib.pyplot as plt#画图表示
plt.scatter(x, y)#散点图
plt.plot(x, model(x), 'r-')
plt.show()

运行结果：

拉格朗日插值法

from scipy.interpolate import lagrange
lag = lagranger(x,y)
lag([4,5])#假如x=[1,2,3,6]

例子

import numpy as np
x = np.array([1, 2, 3, 6, 7])
y = np.array([3, 5, 6, 9, 13])
from scipy.interpolate import lagrange
lag = lagranger(x,y)
lag([4,5])#假如x=[1,2,3,6]
import matplotlib.pyplot as plt
plt.scatter(x, y)
plt.scatter([4, 5], model([4, 5]))#对比一下线性插值
plt.scatter([4, 5], f_lag([4, 5]))
plt.show()

样条插值法

from scipy.interpolate import spline,Bspline
bs = Bspline(x,y,k=1)
bs([4,5])#假如x=[1,2,3,6] array([5.33333333, 5.66666667])

例子

import numpy as np
x = np.array([1, 2, 3, 6, 7])
y = np.array([3, 5, 6, 9, 13])
from scipy.interpolate import  BSpline
y_bs = BSpline(x, y, k=1)
y_bs([4, 5])
plt.scatter(x, y)
import matplotlib.pyplot as plt
plt.scatter([4, 5], model([4, 5]),label= '线性')#对比一下线性插值
plt.scatter([4, 5], f_lag([4, 5]),label='拉格朗日')
plt.scatter([4, 5], y_bs([4, 5]),label='样条')
plt.legend(prop={'family':'SimHei','size':14})#fontproperties='SimHei'字体设置显示中文
plt.show()

4.异常值（离群点）

正态分布

u = data['counts'].mean()#均值
o = date['counts'].std()#方差
ind = data['counts'].apply(lambda x: x>u+3*o or x<u-3*o)#对每一个数据进行判断是否属于异常值
data.loc[ind,['counts']]#异常数据

箱线图

import matpolitlib.pyplot as plt
p = plt.boxplot(data['counts'])
p['filers'][0].get_ydata()#filers存储异常值对应的y

标准数据（sklearn有定义好的函数）

1.标准化数据（将数据映射到[0,1]之间）

def MinMaxScal(data):#计算函数
    return (data -data.min()/(data.max()-data.min()))

2.标准差标准化数据

def StandScale(data):#计算函数
    return (data - data.mean()/data.std())

3.小数定标标准化

def DecimalScale(datra):#计算函数
    return data/10**(np.log10(data.abs().max()))

转换数据

1.哑变量处理（例如输入特征为数值型，其他类型就需要哑变量处理）

pd.get_dummies(data['name'])# 稀散数据 还能加快运算

2.离散化数据

等宽法

pd.cut(data['amounts'],bins = 5(5个))

等频法（按照出现频率分割）

def samefreq(data,k):
    w = data.quantilc(np.arange(0,1+1/k,k/1))#分频
    return pd.cut(data,w)
samefreq(data['amounts'],k=5(5个))

sklearn

具有很多数据库，可以作为训练集，测试集，构建model

from sklearn.model_selection import train_test_split
train_data, test_data, train_target, test_target =train_test_split(data['data'],data['target'],test_size=0.2)#将数据分为训练集和测试集，测试集占百分之20 返回4个数组

sklearn转换器

from sklearn.preprocessing import MinMaxScaler
model = MinMaxScal().fit(train_data) #将train_data进行最小最大标准化
train_data_mms = model.transform(train_data)
test_data_mms = model.transform(test_data)#将对train_data进行的操作搬到test上来

sklearn PCA降维

from sklearn.decomposition import PCA
model = PCA(n_components=8).fit(train_data_mms)#降8维

sklearn估计器构建模型

聚类模型

from sklearn.cluster import KMeans#KMans聚类
model = KMeans(n_clusters=3).fit(data['data]')#把data中的‘data’列聚成三类

评估聚类模型

from sklearn.metrics import silhouette_score#轮廓系数评价法
silhouette_score(data['data'],model.labels_)#输出数值 越接近1越好 model.labels_聚类后的标签（数值）

分类模型

from sklearn.svm import  SVC#支持向量机
model = SVC().fit(x_train,y_train)
y_pre = model.predict(x_test)#对测试集进行预测 可以与y_test作比较
model.score(x_test,y_test)#x_test预测值和y_test对比得出正确率

例子（分类模型一般要先处理）

# 数据导入
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
x = data['data']
y = data['target']
# 模型预处理
from sklearn.preprocessing import StandardScaler
model = StandardScaler().fit(x_train)
x_train_ss = model.transform(x_train)
x_test_ss = model.transform(x_test)
# 模型预处理
from sklearn.preprocessing import StandardScaler
model = StandardScaler().fit(x_train)
x_train_ss = model.transform(x_train)
x_test_ss = model.transform(x_test)
# 分类模型构建
from sklearn.svm import SVC
model = SVC().fit(x_train_ss, y_train)
y_pre = model.predict(x_test_ss)

评估

正确率：

model.score(x_test_ss, y_test)#越接近1越好

召回率(1)，精确率(1)，F1值(1)，roc曲线(靠近y轴)

from sklearn.metrics import recall_score,precision_score,f1_score,roc_curve#召回率(1)，精确率(1)，F1值(1)，roc曲线(靠近y轴)
recall_score(y_test,y_pre)
precision_score(y_test,y_pre)
#roc曲线
f1_score(y_test,y_pre)
fpr,tpr,thresholds = roc_curve(y_test,y_pre)#假正率 真正率 绘图
import matplotlib.pyplot as plt
plt.plot(fpr, tpr)
plt.show()

回归模型

#导入数据
from sklearn.datasets import load_boston
data = load_boston()
x = data['data']
y = data['target']
#处理数据
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#构建回归模型
from sklearn.linear_model import LinearRegression
model = LinearRegression().fit(x_train,y_train)
y_pre = model.predict(x_test)
#画图
import matplotlib.pyplot as plt
plt.plot(range(len(y_test)), y_test)
plt.plot(range(len(y_pre)), y_pre)
plt.legend(['real', 'predict'])
plt.show()

评估

from sklearn.metrics import mean_squared_error,r2_score#均方误差(越接近0越好) R方（越接近1越好）
mean_squared_error(y_true=y_test,y_pre=y_pre)
r2_score(y_true=y_test,y_pre=y_pre)