快速入门Python机器学习笔记

学习笔记"/>

快速入门Python机器学习笔记

快速入门Python机器学习

matplotlib

实现一个简单的Matplotlib画图
第一步创建画布，第二步图像绘制，第三步图像展示

import matplotlib.pyplot as plt
#创建画布
plt.figure(figsize=(20,8),dpi=100)#绘制图像
x=[1,2,3]
y=[4,5,6]
plt.plot(x,y)#图像展示
plt.show()

折线图绘制（添加x、y轴刻度、网格、添加描述信息）

import matplotlib.pyplot as plt
#创建画布
plt.figure(figsize=(5,4),dpi=100)#figsize:指定图的长度，dpi：图像的清晰度#绘制图像
x=[1,2,3,4,5,6]
y=[3,6,3,5,3,10]
plt.plot(x,y)#图像保存
# plt.savefig("./data/test.png")#""内为保存路径#图像展示
plt.show()

案例：显示温度折线图

import matplotlib.pyplot as plt
import random
#准备x,y坐标的数据
x=range(60)#横轴生成60
y=[random.uniform(15,18)for i in x]#随机生成15-18的数据
#创建画布
plt.figure(figsize=(5,4),dpi=100)#figsize:指定图的长度，dpi：图像的清晰度#绘制图像
plt.plot(x,y)#图像保存
# plt.savefig("./data/test.png")#""内为保存路径#图像展示
plt.show()

生成自定义x，y轴

import matplotlib.pyplot as plt
import random
#准备x,y坐标的数据
x=range(60)
y=[random.uniform(15,18)for i in x]#随机生成15-18的数据
#创建画布
plt.figure(figsize=(5,4),dpi=100)#figsize:指定图的长度，dpi：图像的清晰度#绘制图像
plt.plot(x,y)#添加x,y轴刻度
y_ticks=range(40)
x_ticks=["11点{}分".format(i)for i in x]#生成一个自定义x轴刻度plt.yticks(y_ticks[::5])#y轴每隔5个点显示一次
plt.xticks(x[::5],x_ticks[::5])#x轴每隔5个点显示一次#图像保存
# plt.savefig("./data/test.png")#""内为保存路径#图像展示
plt.show()

添加网格信息显示
只需添加如下代码行

plt.grid(True,linestyle='--',alpha=0.5)#alpha为网格透明度

添加描述信息

import matplotlib.pyplot as plt
import random
#准备x,y坐标的数据
x=range(60)
y=[random.uniform(15,18)for i in x]#随机生成15-18的数据
#创建画布
plt.figure(figsize=(5,4),dpi=100)#figsize:指定图的长度，dpi：图像的清晰度#绘制图像
plt.plot(x,y)#添加x,y轴刻度
y_ticks=range(40)
x_ticks=["11点{}分".format(i) for i in x]#生成一个自定义x轴刻度plt.yticks(y_ticks[::5])#y轴每隔5个点显示一次
plt.xticks(x[::5],x_ticks[::5])#x轴每隔5个点显示一次#网格添加
plt.grid(True,linestyle='--',alpha=0.5)#alpha为网格透明度#添加描述
plt.xlabel("time")
plt.ylabel("temperature")
plt.title("一小时温度变化图",fontsize=20)#fontsize调整字体大小#图像保存
# plt.savefig("./data/test.png")#""内为保存路径#图像展示
plt.show()
print(x_ticks)

绘制多条折线及显示图例

import matplotlib.pyplot as plt
import random
#准备x,y坐标的数据
x=range(60)
y_shanghai=[random.uniform(15,18)for i in x]#随机生成15-18的数据
y_beijing=[random.uniform(1,5)for i in x]
#创建画布
plt.figure(figsize=(5,4),dpi=100)#figsize:指定图的长度，dpi：图像的清晰度#绘制图像
plt.plot(x,y_shanghai,label="shanghai")
plt.plot(x,y_beijing,color='r',linestyle='--',label="beijing")#显示图例
plt.legend(loc=1)#显示前需先定义label#添加x,y轴刻度
y_ticks=range(40)
x_ticks=["11点{}分".format(i) for i in x]#生成一个自定义x轴刻度plt.yticks(y_ticks[::5])#y轴每隔5个点显示一次
plt.xticks(x[::5],x_ticks[::5])#x轴每隔5个点显示一次#网格添加
plt.grid(True,linestyle='--',alpha=0.5)#alpha为网格透明度#添加描述
plt.xlabel("time")
plt.ylabel("temperature")
plt.title("一小时温度变化图",fontsize=20)#fontsize调整字体大小#图像保存
# plt.savefig("./data/test.png")#""内为保存路径#图像展示
plt.show()

多个坐标系显示图像

import matplotlib.pyplot as plt
import random
#准备x,y坐标的数据
x=range(60)
y_shanghai=[random.uniform(15,18)for i in x]#随机生成15-18的数据
y_beijing=[random.uniform(1,5)for i in x]#创建画布
#plt.figure(figsize=(5,4),dpi=100)#figsize:指定图的长度，dpi：图像的清晰度
fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(5,4),dpi=100)#nrows行数，ncols列数#绘制图像
# plt.plot(x,y_shanghai,label="shanghai")
# plt.plot(x,y_beijing,color='r',linestyle='--',label="beijing")
axes[0].plot(x,y_shanghai,label="shanghai")
axes[1].plot(x,y_beijing,color='r',linestyle='--',label="beijing")#显示图例
# plt.legend(loc=1)#显示前需先定义label
axes[0].legend(loc=1)
axes[1].legend(loc=1)# #添加x,y轴刻度
y_ticks=range(40)
x_ticks=["11点{}分".format(i) for i in x]#生成一个自定义x轴刻度
#
# plt.yticks(y_ticks[::5])#y轴每隔5个点显示一次
# plt.xticks(x[::5],x_ticks[::5])#x轴每隔5个点显示一次
axes[0].set_xticks(x[::5])#添加第一幅图x轴
axes[0].set_yticks(y_ticks[::5])#添加第一幅图y轴
axes[0].set_xticklabels(x_ticks[::5])#添加第一幅图自定义x轴刻度axes[1].set_xticks(x[::5])
axes[1].set_yticks(y_ticks[::5])
axes[1].set_xticklabels(x_ticks[::5])# #网格添加
# plt.grid(True,linestyle="--",alpha=0.5)#alpha为网格透明度
axes[0].grid(True,linestyle="--",alpha=0.5)
axes[1].grid(True,linestyle="--",alpha=0.5)# #添加描述
# plt.xlabel("time")
# plt.ylabel("temperature")
# plt.title("一小时温度变化图",fontsize=20)#fontsize调整字体大小
axes[0].set_xlabel("time")
axes[0].set_ylabel("temperature")
axes[0].set_title("Temperature change from 11 to 12 noon in Shanghai",fontsize=10)axes[1].set_xlabel("time")
axes[1].set_ylabel("temperature")
axes[1].set_title("Temperature change from 11 to 12 noon in Beijing",fontsize=10)#图像保存
# plt.savefig("./data/test.png")#""内为保存路径#图像展示
plt.show()

折线图应用场景

import numpy as np
import matplotlib.pyplot as plt
#准备数据
x=np.linspace(-10,10,1000)#从-10到10生成1000个数据
y=np.sin(x)#创建画布
plt.figure(figsize=(5,4),dpi=100)#figsize:指定图的长度，dpi：图像的清晰度#绘制函数图像
plt.plot(x,y)#绘制网格
plt.grid()#显示图像
plt.show()

绘制其他常见图形（散点图、柱状图、直方图、饼图）

散点图的绘制

import random
import matplotlib.pyplot as plt
#准备数据
x=range(60)
y=[random.uniform(0,100)for i in x]#随机生成0-100的数据#创建画布
plt.figure(figsize=(5,4),dpi=100)#figsize:指定图的长度，dpi：图像的清晰度#绘制函数图像
plt.scatter(x,y)#绘制网格
plt.grid()#显示图像
plt.show()

柱状图绘制

import random
import matplotlib.pyplot as plt
#准备数据
movie_name=['雷神3','诸神黄昏','正义联盟','东方快车谋杀案','寻梦环游记','全球风暴','追捕']
x=range(len(movie_name))
y=[73853,57767,22354,15969,8725,8716,8316]#创建画布
plt.figure(figsize=(5,4),dpi=100)#figsize:指定图的长度，dpi：图像的清晰度#绘制函数图像
plt.bar(x,y,color=['r','b','g','r','y','b','r'],width=0.5)#x轴显示名称
plt.xticks(x,movie_name)#绘制网格
plt.grid()#加标题
plt.title("电影票房统计")
#显示图像
plt.show()

Numpy

N维数组-ndarray介绍

生成数组

import numpy as npones=np.ones([4,8])#生成全为1的数组
print(ones)
zero=np.zeros_like(ones)#生成类似ones的全为0的数组
print(zero)

np.array–深拷贝，np.asarray–浅拷贝

import numpy as nplinspace=np.linspace(0,100,11)#从0-100等间距生成11个数
print(linspace)arange=np.arange(0,100,10)#从0-100每隔10生成一个数
print(arange)logspace=np.logspace(0,2,3)#从10的零次方到10的二次方，生成三个数字
print(logspace)

import numpy as np
import randomrand=np.random.rand(2,3)#从0-1随机生成两行三列的数据
print(rand)print("")uniform=np.random.uniform(low=1,high=10,size=(3,5))#从1-10随机生成三行五列的数据
print(uniform)print("")# randint=np.random.randint(low=1,high=10,size=(3,5))#从1-10随机生成三行五列的整数
randint=np.random.randint(1,10,(3,5))
print(randint)

生成均匀分布及显示

import numpy as np
import random
import matplotlib.pyplot as plt#生成均匀分布的随机数
x1=np.random.uniform(-1,1,100)#从-1到1随机生成一个百数#绘制画布
plt.figure(figsize=(10,10),dpi=100)#绘制直方图
plt.hist(x=x1,bins=10)#x代表使用的数据，bin表示要划分多少组#显示图像
plt.show()

纵轴表示该组有多少个数据，横轴表示数据的大小

★生成正态分布

import numpy as np
import random
import matplotlib.pyplot as plt#生成正态分布数据
x=np.random.normal(1.75,1,100000000)#生成均值为1.75，方差为1的一亿个数据#画布
plt.figure(figsize=(10,4),dpi=100)#绘制
plt.hist(x,bins=1000)#分为1000组数据#显示
plt.show()

数组索引和形状修改

import numpy as np
import random
import matplotlib.pyplot as plt#生成数据
stock_change=np.random.normal(0,1,(8,10))#随机生成均值为0标准差为1的八行十列数据
# print(stock_change)#索引切片
x=stock_change[0:2,0:3]#取出前两行的前三列
#print(x)

import numpy as np
import random
import matplotlib.pyplot as plt#生成数据
stock_change=np.random.normal(0,1,(4,5))#随机生成均值为0标准差为1的4行5列数据
# print(stock_change)#形状改变
x=stock_change.reshape([5,4])#1.数组形状改为5行4列（reshape产生新变量）
# print(x)
y=stock_change.reshape([-1,10])#素组形状修改为两行10列
# print(y)#stock_change.resize([5,4])#2.将原来数组改为5行4列（resize对原来变量进行修改）stock_change.T#3.进行行列互换（数组#转置）
print(stock_change.T)

数据类型修改和数组去重

import numpy as np
import random#生成数据
stock_change=np.random.normal(0,1,(4,5))#随机生成均值为0标准差为1的4行5列数据
print(stock_change)#类型修改
x=stock_change.astype(np.int32)#将数据改为Int32位数据
print(x)y=stock_change.tostring()#将数据改为相应的字符串
print(y)#数组去重
unique=np.unique(stock_change)
print(unique)

ndarray运算

逻辑运算

import numpy as np
import random#生成数据
stock_change=np.random.normal(0,1,(8,10))#随机生成均值为0标准差为1的4行5列数据
# print(stock_change)stock_c=stock_change[0:5,0:5]#取数据前五行的前五列#逻辑判断
x=stock_c>1#对数据进行逻辑判断，True/False
# print(x)#逻辑运算
stock_c[stock_c>0.5]=1#将数据中大于0.5的数变为1
print(stock_c)

import numpy as np
import random#生成数据
stock_change=np.random.normal(0,1,(8,10))#随机生成均值为0标准差为1的4行5列数据
# print(stock_change)stock_c=stock_change[0:5,0:5]#取数据前五行的前五列#逻辑判断
x=np.all(stock_c>0)#stock_c数组中所有的数均大于零则输出True，否则输出False
print(x)y=np.any(stock_c>0)#stock_c数组中有大于零的数则输出为True，否则输出为False
print(y)

三元运算符

import numpy as np
import random#生成数据
stock_change=np.random.normal(0,1,(8,10))#随机生成均值为0标准差为1的4行5列数据
# print(stock_change)stock_c=stock_change[0:5,0:5]#取数据前五行的前五列#三元运算符
x=np.where(stock_c>0,1,0)#将数组中大于零的数据返回1，反之为0
print(x)y=np.where(np.logical_and(stock_c>-0.5,stock_c<0.5),1,0)
#将数组中大于-0.5且小于0.5的数据赋为1否则为0（逻辑与）
print(y)z=np.where(np.logical_or(stock_c>-0.5,stock_c<0.5),1,0)
#将数组中大于-0.5且小于#0.5的数据赋为1否则为0（逻辑或）
print(z)

★统计运算 （最大值最小值均值方差）

import numpy as np
import random#生成数据
stock_change=np.random.normal(0,1,(4,5))#随机生成均值为0标准差为1的4行5列数据
# print(stock_change)stock_c=stock_change[0:2,0:2]#取数据前五行的前五列
print(stock_c)#统计运算
max=stock_change.max(axis=1)#生成每一行中最大值，axis=1为行，axis=0为列
print(max)argmax=stock_c.argmax(axis=1)#生成每一行中最大值的位置
print(argmax)

★矩阵

import numpy as nparr=np.array([1,2,3,4])arr=arr+1
print(arr)arr=arr/2
print(arr)

数组与数组的运算

★矩阵运算

import numpy as np
#准备数据
a=np.array([[80,86],[82,80],[85,78],[90,90],[86,82],[82,90],[78,80],[92,94]])
b=np.array([[0.7],[0.3]])#矩阵运算
matmul=np.matmul(a,b)#表示矩阵相乘
print(matmul)dot1=np.dot(a,b)#表示矩阵相乘，且支持点乘
dot2=np.dot(10,b)
print(dot1)
print(dot2)

Pandas

基本介绍

import numpy as np
import pandas as pd
import random
#导入数据
stock_change=np.random.normal(0,1,(10,5))#随机生成均值为0方差为1的十行五列数据#使用pandas进行列表结构生成
Data=pd.DataFrame(stock_change)
print(Data)print(Data.shape)#显示数据几行几列
print(Data.shape[0])#显示数据有几行
print(Data.shape[1])#显示数据有几列#构建行索引序列
stock_name=["stock{}".format(i+1) for i in range(Data.shape[0])]#增加行索引序列
# print(stock_name)#添加行索引
# pd.DataFrame(stock_change,index=stock_name)#index表示行索引,注意此时变量为数组
# print(index)#构建列索引序列C
stock_time=pd.date_range(start='2021.4.23',periods=Data.shape[1],freq='B')#freq为递进单位，'B'为略过周六日#添加行、列索引
index_columns=pd.DataFrame(stock_change,index=stock_name,columns=stock_time)#columns为列索引
print(index_columns)

N维数组

★DataFrame设置索引（二维数组）

import numpy as np
import pandas as pd
import random
#导入数据
stock_change=np.random.normal(0,1,(10,5))#随机生成均值为0方差为1的十行五列数据#使用pandas进行列表生成
Data=pd.DataFrame(stock_change)
# print(Data)
#
# print(Data.shape)#显示数据几行几列
# print(Data.shape[0])#显示数据有几行
# print(Data.shape[1])#显示数据有几列#构建行索引序列
stock_name=["stock_{}".format(i+1) for i in range(Data.shape[0])]#增加行索引序列
# print(stock_name)#添加行索引
# pd.DataFrame(stock_change,index=stock_name)#index表示行索引,注意此时变量为数组
# print(index)#构建列索引序列
stock_time=pd.date_range(start='2021.4.23',periods=Data.shape[1],freq='B')#freq为递进单位，'B'为略过周六日#添加行、列索引
DataFrame=pd.DataFrame(stock_change,index=stock_name,columns=stock_time)#columns为列索引
print(DataFrame)#重设索引
print(Data.reset_index(drop=True))#drop=False不删除原来索引，drop=True删除原来索引

import numpy as np
import pandas as pd#创建列表
df=pd.DataFrame({'month':[1,4,7,10],'year':[2017,2018,2019,2020],'sale':[35,95,33,84]})
print(df)#设置以月份索引
df1=df.set_index('month')
print(df1)#设置多个索引
df2=df.set_index(['month','year'])
print(df2)

MutiIndex(三维数组）

import numpy as np
import pandas as pd#创建列表
df=pd.DataFrame({'month':[1,4,7,10],'year':[2017,2018,2019,2020],'sale':[35,95,33,84]})
print(df)#设置以月份索引
df1=df.set_index('month')
print(df1)#设置多个索引
df2=df.set_index(['month','year'])
print(df2)#MultiIndex
df3=df2.index
print(df3)

Series（一维数组）

import pandas as pd
import numpy as np
#默认索引
a=pd.Series(np.arange(10))
print(a)#指定内容，指定索引
p=pd.Series([6,77,56,75,89,1],index=[1,2,3,4,5,6])
print(p)#通过字典索引数据
d=pd.Series({'red':10,'green':5,'blue':7})
print(d)

基本操作

import pandas as pd
#导入数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv")
print(stock_data)
#显示前五行数据
print(stock_data.head(5))
#删除数据中不需要的列
stock_data=stock_data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"],axis=1)#axis为1表示列
print(stock_data)

索引操作

import pandas as pd
#导入数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv")
print(stock_data)
#显示前五行数据
print(stock_data.head(5))
#删除数据中不需要的列
stock_data=stock_data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"],axis=1)#axis为1表示列
print(stock_data)#直接索引（先列后行）
print(stock_data['open']['2018-02-22'])
#使用loc进行索引
print(stock_data.loc["2018-02-27":"2018-02-14","open":"high"])
#使用iloc进行索引
print(stock_data.iloc[0:3,0:5])#取前三行前五列
#使用ix进行组合索引
# print(stock_data.ix[0:5,['open','high','close']])
#获取列索引
print(stock_data.columns.get_indexer(["open","low"])) 

赋值和排序操作

import pandas as pd
#导入数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv")#删除数据中不需要的列
stock_data=stock_data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"],axis=1)#axis为1表示列
print(stock_data)
#幅值操作
stock_data["close"]=100#将close这一列赋值为100
# stock_data.close=1000#将close这一列赋值为1000
print(stock_data)

import pandas as pd
#导入数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv")#删除数据中不需要的列
stock_data=stock_data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"],axis=1)#axis为1表示列
print(stock_data)#按照列值排序
print(stock_data.sort_values(by=['open','high'],ascending=False))#by表示按照什么排序，ascending=False表示降序排序#按照行索引值进行排序
print(stock_data.sort_index())#升序排列#使用seris进行排序
print(stock_data['open'].sort_values(ascending=True))#对open列进行升序排列
print(stock_data['open'].sort_index(ascending=False))#对open列日期大小进行排列

DataFrame运算

算数运算

import pandas as pd
#导入数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv")#删除数据中不需要的列
stock_data=stock_data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"],axis=1)#axis为1表示列
print(stock_data)#算数运算
print(stock_data["close"].add(10))#close这一列加10#任意两列运算，形成新的列
close=stock_data['close']
open1=stock_data['open']
New_price_change=stock_data["price_change"]=close.sub(open1)#close-open的差
print(New_price_change)

逻辑运算

import pandas as pd
#导入数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv")#删除数据中不需要的列
stock_data=stock_data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"],axis=1)#axis为1表示列
print(stock_data)#逻辑运算
print(stock_data['open']>23)
#完成多个逻辑运算
print((stock_data['open']>22 ) & (stock_data['open']<24))

import pandas as pd
#导入数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv")#删除数据中不需要的列
stock_data=stock_data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"],axis=1)#axis为1表示列
print(stock_data)#逻辑运算函数
New_open=stock_data.query("open<24 & open>23")
print(New_open)
#指定一个值进行判断
print(stock_data[stock_data["open"].isin([23.53,23.85])])#显示出指定open值

统计运算

import pandas as pd
#导入数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv")#删除数据中不需要的列
stock_data=stock_data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"],axis=1)#axis为1表示列
print(stock_data)#统计运算
print(stock_data.describe())#求和
print(stock_data.sum(axis=0))#默认按列求和axis=0#标准差
print('std\n',stock_data.std(axis=0))#中位数
print('median\n',stock_data.median())#求出最大值的位置
print('idxmax\n',stock_data.idxmax())

import pandas as pd
import matplotlib.pyplot as plt
#导入数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv")#删除数据中不需要的列
stock_data=stock_data.drop(["ma5","ma10","ma20","v_ma5","v_ma10","v_ma20"],axis=1)#axis为1表示列
print(stock_data.head(20))#按照列索引排序
stock_data=stock_data.sort_index()
# print(stock_data.head())#取价格浮动列
stock_float=stock_data["p_change"]
#对价格浮动累计求和
stock_float=stock_float.cumsum()#显示价格浮动图形
stock_float.plot()
plt.show()

Pandas画图

文件读取与存储

import pandas as pd
import matplotlib.pyplot as plt
#导入csv数据
stock_data=pd.read_csv("E:/百度网盘/stock_day.csv",usecols=["open","high"])
print(stock_data)
#写入csv数据
stock_data[:10].to_csv("E:/百度网盘/practice/test_py38.csv",columns=["open"],index=True)#导入数据的前十行，只取open一列，index表示是否显示索引

import pandas as pd
import matplotlib.pyplot as plt
#导入hdf5数据
data=pd.read_hdf("E:/BaiduWangPan/day_close.h5")
print(data)#写入ddf5数据
test_data=data.to_hdf("E:/BaiduWangPan/practice/test_py38.h5",key="close")
#读取写入文件
print(pd.read_hdf("E:/BaiduWangPan/practice/test_py38.h5",key="close").head())

import pandas as pd#导入json数据
data=pd.read_json("E:/BaiduWangPan/Sarcasm_Headlines_Dataset.json",orient="records",lines=True)
print(data)#存储json数据
data.to_json("E:/BaiduWangPan/practice/test_py38.json",orient="records",lines=True)

高级处理-缺失值处理

#判断缺失值是否存在
import pandas as pd
import numpy as np
#导入数据
data=pd.read_csv("E:/BaiduWangPan/IMDB-Movie-Data.csv")
print(data)#判断是否存在缺失值
print(pd.isnull(data))#缺失值返回True
print(np.any(pd.isnull(data)))#有一个缺失值就返回Trueprint(pd.notnull(data))#缺失值返回False
print(np.all(pd.notnull(data)))#有一个缺失值就返回False

#删除缺失值和替换缺失值
import pandas as pd
import numpy as np
#导入数据
data=pd.read_csv("E:/BaiduWangPan/IMDB-Movie-Data.csv")
print(data)
#判断是否存在缺失值
print(np.any(pd.isnull(data)))#有一个缺失值就返回True
#用dropna删除缺失值
movie=data.dropna()
#用fillna替换缺失值
print(data["Revenue (Millions)"].fillna(value=data["Revenue (Millions)"].mean()))
#使用循环遍历所有缺失值并且进行替换
for i in data.columns:# print(i)                              #显示有多少列if np.any(pd.isnull(data[i])) == True:  #判断是否有缺失值print(i)                            #显示有缺失值的列data[i].fillna(value=data[i].mean(),inplace=True)#将有缺失值的列进行替换
print(data)

高级处理-数据离散化

#股票的涨跌幅离散化
import pandas as pd
import numpy as np
#导入数据
data=pd.read_csv("E:/BaiduWangPan/stock_day.csv")
p_change=data['p_change']
print(p_change)#用qcut自行分组
qcut=pd.qcut(p_change,10)#将该列数据分为十组区间
print(qcut)
#计算分到每个组数据个数
print(qcut.value_counts())#用cut自定义区间分组
bins=[-100,-7,-5,-3,0,3,5,7,100]
p_count=pd.cut(p_change,bins)
print(p_count)
#计算分到每个组数据个数
print(p_count.value_counts())

#one-hot编码矩阵
import pandas as pd
import numpy as np
#导入数据
data=pd.read_csv("E:/BaiduWangPan/stock_day.csv")
p_change=data['p_change']
print(p_change)#用qcut自行分组
qcut=pd.qcut(p_change,10)#将该列数据分为十组区间
print(qcut)
#计算分到每个组数据个数
print(qcut.value_counts())#用cut自定义区间分组
bins=[-100,-7,-5,-3,0,3,5,7,100]
p_count=pd.cut(p_change,bins)
print(p_count)
#计算分到每个组数据个数
print(p_count.value_counts())#生成one—hot编码矩阵
dummies=pd.get_dummies(p_count,prefix="rise")#prefix是分组的名字
print(dummies)

高级处理-数据合并

#用concat数据合并
import pandas as pd
import numpy as np
#导入数据
data=pd.read_csv("E:/BaiduWangPan/stock_day.csv")
p_change=data['p_change']
# print(p_change)#用cut自定义区间分组
bins=[0,3,5,7,100]
p_count=pd.cut(p_change,bins)
# print(p_count)#生成one—hot编码矩阵
dummies=pd.get_dummies(p_count,prefix="rise")#prefix是分组的名字
# print(dummies)#用concat数据合并
print(pd.concat([p_change,dummies],axis=1))

#用merge数据合并
import pandas as pd
import numpy as np#创建数据
left=pd.DataFrame({'key1':['k0','k0','k1','k2'],'key2':['k0','k1','k0','k1'],'A':['A0','A1','A2','A3'],'B':['B0','B1','B2','B3']
})
right=pd.DataFrame({'key1':['k0','k1','k1','k2'],'key2':['k0','k0','k0','k0'],'C':['C0','C1','C2','C3'],'D':['D0','D1','D2','D3']
})
print(left)
print(right)#merge拼接
print(pd.merge(left,right,on=['key1','key2'],how="inner"))#on是指定共同键值对进行合并（内链接方式）
print(pd.merge(left,right,on=['key1','key2'],how="outer"))#（外连接方式）
print(pd.merge(left,right,on=['key1','key2'],how="left"))#只用left键值进行合并
print(pd.merge(left,right,on=['key1','key2'],how="right"))#只用right键值进行合并

高级处理-交叉表与透视表

探索两列数据之间的关系

#交叉表crosstab
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#导入数据
data=pd.read_csv("E:/BaiduWangPan/stock_day.csv")
# print(data)#转为datetime格式
time=pd.to_datetime(data.index)
# print(time)
# print(time.day)#显示哪一天
# print(time.week)#显示第几周
# print(time.weekday)#显示星期几#找到对应的日期是星期几,并以weekday列出
data["weekday"]=time.weekday#将p_change按照大小分类,并以p_n列出
data['p_n']=np.where(data['p_change']>0,1,0)#数据p_change>0则输出1，反之输出0#通过交叉表寻找两列数据的关系
print(pd.crosstab(data['weekday'],data['p_n']))#数据占比
count=pd.crosstab(data['weekday'],data['p_n'])
sum=count.sum(axis=1)#案列求和
per=count.div(sum,axis=0)#相除操作，得出比例
print(per)#使用pivot_table（透视表）实现数据占比
# per=data.pivot_table(['p_n'],index="weekday")#p_n为1时所占的比例
#可视化
per.plot(kind="bar",stacked=True)
plt.show()

高级处理-分组与聚合

#分组和聚合
import pandas as pd
import numpy as np#导入数据
data=pd.DataFrame({'color':['white','red','green','red','green'],'object':['pen','pencil','pencil','ashtray','pen'],'price1':[5.56,4.20,1.30,0.56,2.75],'price2':[4.75,4.12,1.60,0.75,3.15]})
print(data)#分组、求平均值
col=data
print(col.groupby(['color'])['price1'].mean())#按照color对price1求平均值
# print(col['price'].groupby(col['color']).mean())

#星巴克案例：通过groupby进行分组
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt#导入数据
data=pd.read_csv("E:/BaiduWangPan/directory.csv")
print(data['Country'])#按照country进行统计，求出每个国家星巴克的数量
count=data.groupby(['Country']).count()
print(count)#可视化
count['Brand'].plot(kind='bar')#取数据中Brand这一列进行柱状图可视化
plt.show()
#降序可视化
sort=count['Brand'].sort_values(ascending=False)[:20]#将数据进行降序排序
sort.plot(kind='bar')
plt.show()

电影数据分析案例

#电影数据分析
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt#导入数据
moive_data=pd.read_csv("E:/BaiduWangPan/IMDB-Movie-Data.csv")#电影数据平均分
print(moive_data['Rating'].mean())
#得出导演人数信息
unique=moive_data['Director'].unique()#将数据去重
print(unique.shape[0])#得出导演数量

#电影数据分析
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt#导入数据
moive_data=pd.read_csv("E:/BaiduWangPan/IMDB-Movie-Data.csv")#创建画布
plt.figure(dpi=100)#绘制Rating分布
# max_=moive_data['Rating'].max()
# min_=moive_data['Rating'].min()
# x1=np.linspace(min_,max_,21)#将数据平均分为20组（21个间隔）
# plt.xticks(x1)#生成x坐标
# plt.grid()#添加网格
# plt.hist(moive_data['Rating'].values,bins=20)#绘制直方图,分为20组#绘制Runtime分布
max_1=moive_data['Runtime (Minutes)'].max()
min_1=moive_data['Runtime (Minutes)'].min()
x2=np.linspace(min_1,max_1,21)#将数据平均分为20组（21个间隔）
plt.xticks(x2)#生成x坐标
plt.grid()#添加网格
plt.hist(moive_data['Runtime (Minutes)'].values,bins=20)#绘制直方图,分为20组
#显示
plt.show()

#电影数据分析
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt#导入数据
moive_data=pd.read_csv("E:/BaiduWangPan/IMDB-Movie-Data.csv")
# print(moive_data['Genre'])
#进行字符串分割
temp_list=[i.split(",") for i in moive_data['Genre']]
print(temp_list)
#获取电影的分类
genre_list=np.unique([i for j in temp_list for i in j])
#创建一个全为零的Dataframe
genre_zero=pd.DataFrame(np.zeros((moive_data.shape[0],genre_list.shape[0])),columns=genre_list)#创建一个行为数据总数，列为电影分类的全零Dataframe,列名改为分类名
# print(genre_zero)#遍历每一部电影，把分类出现的列置为1
for i in range(1000):genre_zero.loc[i,temp_list[i]]=1#混合索引
print(genre_zero)
#求和、绘图
genre_zero.sum().sort_values(ascending=False).plot(kind="bar")
plt.show()

1.概述

2 .特征工程

2.1数据集

2.1.2sklearn数据集

2.2特征工程介绍

2.3 特征提取

2.3.2字典特征提取

2.3.3文本特征提取

2.4特征预处理

2.4.2 归一化

2.4.3标准化

2.5 特征降维

此处的降维是降低特征的个数，要求特征与特征之间不相关。

2.5.1降维

2.5.2降维的两种方式（特征选择、主成分分析）

2.5.3特征选择

*方差选择法：低方差的特征进行过滤
*相关系数法：衡量特征与特征间的相关程度



运行结果：

2.5.4主成分分析

探究用户对物品类别的喜好细分：
1）需要将用户（user_id）和物品类别（aisle)放在同一个表中。
2）找到user_id和aisle-交叉表和透视表
3）特征冗余过多,PCA降维

3.分类算法

3.1sklearn转换器和估计器

3.1.1转换器

3.1.2估计器

方法：1.实例化一个estimator
2.estimator.fit(x_train,y_train)计算,调用完毕，生成模型
3.模型评估：1）直接对比真实值和预测值
y_predict=estimator.predict(x_test)
y_test==y_predict
2) 计算准确率
accuracy=estimator.score(x_test,y_test)

3.2KNN算法

3.2.1什么是K-近邻算法

核心思想：根据你的“邻居”推断你的类别。

1）k值取得过小，容易受到异常点的影响；k值取得过大，容易样本不均衡的影响
2）需要进行无量纲化的处理，如归一化，标准化

3.2.3案例：鸢尾花种类预测

3.3 模型选择与调优

3.3.1交叉验证（cross validation)

3.3.2超参数搜索-网格搜索（Grid Search)

3.3.3 案例：鸢尾花增加K值调优

使用GridSearchCV构建估计器

3.2.4案例：预测Facebook签到位置

布尔索引：

3.4朴素贝叶斯算法

3.4.1什么是朴素贝叶斯分类方法

3.4.2 概率基础

3.4.3联合概率、条件概率与相互独立

3.4.4朴素贝叶斯公式

例题：计算 P（喜欢|产品经理，超重）=？

朴素贝叶斯在文本分类下的应用

例子：
加入拉普拉斯平滑系数：

3.4.5API

3.4.6案例：20类新闻分类

步骤分析：1）获取数据，2）划分数据集3）特征工程【文本特征提取tfidf】4）贝叶斯预估器流程5）模型评估

from sklearn.datasets import fetch_20newsgroups from sklearn.model_selection import train_test_split from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.naive_bayes import MultinomialNB

3.5决策树

3.5.1什么是决策树

3.5.2决策树分类原理详解

信息论基础

1）信息：
香农：消除随机不定性的东西
小明：“我今年18岁”——信息
小华：“小明明年19岁”——不是信息
2）信息的衡量——信息量——信息熵

以上述银行贷款为例，计算信息熵

3.5.3决策树API

以鸢尾花数据集为例实现决策树

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, export_graphviz
def decision_iris():"""用决策树对鸢尾花进行分类:return:"""# 1）获取数据集iris = load_iris()# 2）划分数据集x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)# 3）决策树预估器estimator = DecisionTreeClassifier(criterion="entropy")estimator.fit(x_train, y_train)# 4）模型评估# 方法1：直接比对真实值和预测值y_predict = estimator.predict(x_test)print("y_predict:\n", y_predict)print("直接比对真实值和预测值:\n", y_test == y_predict)# 方法2：计算准确率score = estimator.score(x_test, y_test)print("准确率为：\n", score)# 可视化决策树export_graphviz(estimator, out_file="iris_tree.dot", feature_names=iris.feature_names)return None
if __name__ == '__main__':decision_iris()

这时，文件里的内容我们还是看不懂的，于是我们需要把内容放到一个生成树的网站里
(/)
点击网站最下面的

用决策树实现泰坦尼克号乘客生存预测

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.tree import DecisionTreeClassifier, export_graphviz
def titanic():# 1、获取数据path = ".txt"titanic = pd.read_csv(path)# 筛选特征值和目标值x = titanic[["pclass", "age", "sex"]]y = titanic["survived"]# 2、数据处理# 1）缺失值处理x["age"].fillna(x["age"].mean(), inplace=True) #填充平均值# 2) 转换成字典x = x.to_dict(orient="records")# 3、数据集划分x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)# 4、字典特征抽取transfer = DictVectorizer()x_train = transfer.fit_transform(x_train)x_test = transfer.transform(x_test)# 3）决策树预估器estimator = DecisionTreeClassifier(criterion="entropy", max_depth=8)estimator.fit(x_train, y_train)# 4）模型评估# 方法1：直接比对真实值和预测值y_predict = estimator.predict(x_test)print("y_predict:\n", y_predict)print("直接比对真实值和预测值:\n", y_test == y_predict)# 方法2：计算准确率score = estimator.score(x_test, y_test)print("准确率为：\n", score)# 可视化决策树export_graphviz(estimator, out_file="titanic_tree.dot", feature_names=transfer.get_feature_names())
if __name__ == '__main__':titanic()

3.6集成学习算法之随机森林

3.6.1什么是集成学习方法

3.6.2 什么是随机森林

3.6.3随机森林原理过程

用随机森林实现泰坦尼克号实例

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
import pandas as pd
from sklearn.feature_extraction import DictVectorizer
def suijisanli_demo():# 1、获取数据path = ".txt"titanic = pd.read_csv(path)# 筛选特征值和目标值x = titanic[["pclass", "age", "sex"]]y = titanic["survived"]# 2、数据处理# 1）缺失值处理x["age"].fillna(x["age"].mean(), inplace=True)# 2) 转换成字典x = x.to_dict(orient="records")# 3、数据集划分x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)# 4、字典特征抽取transfer = DictVectorizer()x_train = transfer.fit_transform(x_train)x_test = transfer.transform(x_test)#随机森林预估器estimator = RandomForestClassifier()# 加入网格搜索与交叉验证# 参数准备param_dict = {"n_estimators": [120, 200, 300, 500, 800, 1200], "max_depth": [5, 8, 15, 25, 30]}estimator = GridSearchCV(estimator, param_grid=param_dict, cv=3)estimator.fit(x_train, y_train)# 5）模型评估# 方法1：直接比对真实值和预测值y_predict = estimator.predict(x_test)print("y_predict:\n", y_predict)print("直接比对真实值和预测值:\n", y_test == y_predict)# 方法2：计算准确率score = estimator.score(x_test, y_test)print("准确率为：\n", score)# 最佳参数：best_params_print("最佳参数：\n", estimator.best_params_)# 最佳结果：best_score_print("最佳结果：\n", estimator.best_score_)# 最佳估计器：best_estimator_print("最佳估计器:\n", estimator.best_estimator_)# 交叉验证结果：cv_results_print("交叉验证结果:\n", estimator.cv_results_)if __name__ == '__main__':suijisanli_demo()

4.回归与聚类算法

4.1线性回归

4.1.2线性回归的损失和优化原理

即：目标就是找到一条直线，使所有点到直线的距离之和最小，即误差最小

损失函数

既然存在这个误差，那我们就将这个误差给衡量出来。

优化算法（正规方程与梯度下降）

代码如下：

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor
from sklearn.metrics import mean_squared_error
def linear1():"""正规方程的优化方法对波士顿房价进行预测:return:"""# 1）获取数据boston = load_boston()# 2）划分数据集x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)# 3）标准化transfer = StandardScaler()x_train = transfer.fit_transform(x_train)x_test = transfer.transform(x_test)# 4）预估器estimator = LinearRegression()estimator.fit(x_train, y_train)# 5）得出模型print("正规方程-权重系数为：\n", estimator.coef_)print("正规方程-偏置为：\n", estimator.intercept_)# 6）模型评估y_predict = estimator.predict(x_test)print("预测房价：\n", y_predict)error = mean_squared_error(y_test, y_predict)print("正规方程-均方误差为：\n", error)return Nonedef linear2():"""梯度下降的优化方法对波士顿房价进行预测:return:"""# 1）获取数据boston = load_boston()print("特征数量：\n", boston.data.shape)# 2）划分数据集x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)# 3）标准化transfer = StandardScaler()x_train = transfer.fit_transform(x_train)x_test = transfer.transform(x_test)# 4）预估器estimator = SGDRegressor(learning_rate="constant", eta0=0.01, max_iter=10000, penalty="l1")estimator.fit(x_train, y_train)# 5）得出模型print("梯度下降-权重系数为：\n", estimator.coef_)print("梯度下降-偏置为：\n", estimator.intercept_)# 6）模型评估y_predict = estimator.predict(x_test)print("预测房价：\n", y_predict)error = mean_squared_error(y_test, y_predict)print("梯度下降-均方误差为：\n", error)return Noneif __name__ == '__main__':linear1()linear2()

两种方法的对比

4.2欠拟合与过拟合

以计算机识别天鹅为例，第一种欠拟合，第二种过拟合
hw(xi)为预测值，yi为真实值，L1正则化就是把wj²改为|wj|

4.3线性回归的改进-岭回归

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor,Ridge
from sklearn.metrics import mean_squared_errordef linear3():"""岭回归对波士顿房价进行预测:return:"""# 1）获取数据boston = load_boston()print("特征数量：\n", boston.data.shape)# 2）划分数据集x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)# 3）标准化transfer = StandardScaler()x_train = transfer.fit_transform(x_train)x_test = transfer.transform(x_test)#4）预估器estimator = Ridge(alpha=0.5, max_iter=10000)estimator.fit(x_train, y_train)# 5）得出模型print("岭回归-权重系数为：\n", estimator.coef_)print("岭回归-偏置为：\n", estimator.intercept_)# 6）模型评估y_predict = estimator.predict(x_test)print("预测房价：\n", y_predict)error = mean_squared_error(y_test, y_predict)print("岭回归-均方误差为：\n", error)return None
if __name__ == '__main__':linear3()

4.4逻辑回归（分类算法）与二分类