这是在 数据统计分析(Numpy) 的基础上进行的。
Win7连接公网安装第三方库（Scikit-Learn）：
C:\Users\jacky\Desktop>pip3 install scikit-learn==0.24.2 -i http://mirrors.aliyun.com/pypi/simple --trusted-host=mirrors.aliyun.com
列出当前环境所有已经安装的第三方库的名称和其版本号:（会自动安装一些相关的第三方库）
C:\Users\jacky\Desktop>pip3 freeze
cycler==0.11.0
et-xmlfile==1.1.0
joblib==1.1.1
kiwisolver==1.3.1
matplotlib==3.3.0
numpy==1.19.5
openpyxl==3.1.2
pandas==1.1.5
Pillow==8.4.0
pyparsing==3.1.1
python-dateutil==2.8.2
pytz==2023.3
scikit-learn==0.24.2
scipy==1.5.4
seaborn==0.11.2
six==1.16.0
threadpoolctl==3.1.0
xlrd==1.2.0
xlwt==1.3.0
C:\Users\jacky\Desktop>
机器学习，顾名思义就是让机器（计算机）模拟人类进行学习，从而提高工作效率。
Python的第三方库Scikit-Learn对常用的机器学习算法进行了封装，其算法包括回归、聚类等。
回归：
线性回归是数据挖掘的基础算法之一，其核心思想其实就是解一组方程，得到回归系数，从而获得预测值。
Scikit-Learn的线性模型包括最小二乘法回归、岭回归等，在程序中直接调用就可以实现线性回归分析。
岭回归是在最小二乘法回归的基础上，对回归系数的大小施加了限制，获得的预测值会准确很多。
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_1 = np.array([[1,56],[1,104],[1,156],[1,200],[1,250],[1,300]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = np.array([560,1040,1560,2000,2500,3000]) #创建一个一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
Key_X = np.array([[1,170]])
Key_Y = clf.predict(Key_X)
print('回归系数：',k)
print('截距：',b)
print('“1”、“170”对应的预测值：',Key_Y)
print(type(Key_Y))
print(Key_Y[0])
print(type(Key_Y[0]))
print("-" * 5)
Result_1 = int(Key_Y[0])
print('预测值（取整数）：',Result_1)
print(type(Result_1))
脚本运行的结果：（数组n_2相当于数组n_1的结果，会自动生成计算公式）
C:\Users\jacky\Desktop>python xx.py
[[ 1 56]
[ 1 104]
[ 1 156]
[ 1 200]
[ 1 250]
[ 1 300]]
----------
[ 560 1040 1560 2000 2500 3000]
----------
----------
回归系数： [0. 9.99975843]
截距： 0.04291845493594337
“1”、“170”对应的预测值： [1700.00185202]
<class 'numpy.ndarray'>
1700.0018520158792
<class 'numpy.float64'>
-----
预测值（取整数）： 1700
<class 'int'>
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_1 = np.array([[1,56],[1,104],[1,156],[1,200],[1,250],[1,300]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = np.array([560,1040,1560,2000,2500,3000]) #创建一个一维数组
print(n_2)
print("-" * 10)
print('数组n_1 & 数组n_2的效果：')
n_3 = np.array([[1,56,n_2[0]],[1,104,n_2[1]],[1,156,n_2[2]],[1,200,n_2[3]],
[1,250,n_2[4]],[1,n_1[5][1],n_2[5]]]) #把n_1、n_2整合起来
print(n_3)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
Key_X = np.array([[1,170]])
Key_Y = clf.predict(Key_X)
print('回归系数：',k)
print('截距：',b)
print('“1”、“170”对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = round(Key_Y[0],1)
print('预测值（保留一位小数）：',Result_1)
print(type(Result_1))
Result_1 = float(Result_1) #转换为浮点型
print(Result_1)
print(type(Result_1))
脚本运行的结果：（数组n_2相当于数组n_1的结果，会自动生成计算公式）
C:\Users\jacky\Desktop>python xx.py
[[ 1 56]
[ 1 104]
[ 1 156]
[ 1 200]
[ 1 250]
[ 1 300]]
----------
[ 560 1040 1560 2000 2500 3000]
----------
数组n_1 & 数组n_2的效果：
[[ 1 56 560]
[ 1 104 1040]
[ 1 156 1560]
[ 1 200 2000]
[ 1 250 2500]
[ 1 300 3000]]
----------
----------
回归系数： [0. 9.99975843]
截距： 0.04291845493594337
“1”、“170”对应的预测值： [1700.00185202]
-----
预测值（保留一位小数）： 1700.0
<class 'numpy.float64'>
1700.0
<class 'float'>
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_1 = np.array([[1,56],[1,104],[1,156],[1,200],[1,250],[1,300]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = np.array([560,1040,1560,2000,2500,3000]) #创建一个一维数组
print(n_2)
print("-" * 10)
print('数组n_1 & 数组n_2的效果：')
n_3 = np.array([[1,56,n_2[0]],[1,104,n_2[1]],[1,156,n_2[2]],[1,200,n_2[3]],
[1,250,n_2[4]],[n_1[5][0],n_1[5][1],n_2[5]]]) #把n_1、n_2整合起来
print(n_3)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
Key_X = np.array([[1,170]])
Key_Y = clf.predict(Key_X)
print('回归系数：',k)
print('截距：',b)
print('“1”、“170”对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = "%.1f" % Key_Y[0]
print('预测值（保留一位小数）：',Result_1)
print(type(Result_1))
Result_1 = float(Result_1) #转换为浮点型
print(Result_1)
print(type(Result_1))
脚本运行的结果：（数组n_2相当于数组n_1的结果，会自动生成计算公式）
C:\Users\jacky\Desktop>python xx.py
[[ 1 56]
[ 1 104]
[ 1 156]
[ 1 200]
[ 1 250]
[ 1 300]]
----------
[ 560 1040 1560 2000 2500 3000]
----------
数组n_1 & 数组n_2的效果：
[[ 1 56 560]
[ 1 104 1040]
[ 1 156 1560]
[ 1 200 2000]
[ 1 250 2500]
[ 1 300 3000]]
----------
----------
回归系数： [0. 9.99975843]
截距： 0.04291845493594337
“1”、“170”对应的预测值： [1700.00185202]
-----
预测值（保留一位小数）： 1700.0
<class 'str'>
1700.0
<class 'float'>
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_1 = np.array([[1,56],[1,104],[1,156],[1,200],[1,250],[1,300]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = np.array([560,1040,1560,2000,2500,3000]) #创建一个一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
Key_X = np.array([[1,170]])
Key_Y = clf.predict(Key_X)
print('回归系数：',k)
print('截距：',b)
print('“1”、“170”对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = int(Key_Y[0])
print('“1”、“170”对应的预测值（取整数）：',Result_1)
print(type(Result_1))
print("-" * 10)
print('数组n_1 & 数组n_2 & “1”、“170”对应的预测值的效果：')
n_3 = np.array([[1,n_1[0][1],n_2[0]],[1,n_1[1][1],n_2[1]],[1,n_1[2][1],n_2[2]],
[1,n_1[3][1],n_2[3]],[1,n_1[4][1],n_2[4]],[1,n_1[5][1],n_2[5]],
[1,170,Result_1]])
print(n_3)
脚本运行的结果：（数组n_2相当于数组n_1的结果，会自动生成计算公式）
C:\Users\jacky\Desktop>python xx.py
[[ 1 56]
[ 1 104]
[ 1 156]
[ 1 200]
[ 1 250]
[ 1 300]]
----------
[ 560 1040 1560 2000 2500 3000]
----------
----------
回归系数： [0. 9.99975843]
截距： 0.04291845493594337
“1”、“170”对应的预测值： [1700.00185202]
-----
“1”、“170”对应的预测值（取整数）： 1700
<class 'int'>
----------
数组n_1 & 数组n_2 & “1”、“170”对应的预测值的效果：
[[ 1 56 560]
[ 1 104 1040]
[ 1 156 1560]
[ 1 200 2000]
[ 1 250 2500]
[ 1 300 3000]
[ 1 170 1700]]
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_1 = np.array([[1,56],[1,104],[1,156],[1,200],[1,250],[1,300]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = np.array([560,1040,1560,2000,2500,3000]) #创建一个一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
Key_X = np.array([[1,170]])
Key_Y = clf.predict(Key_X)
print('回归系数：',k)
print('截距：',b)
print('“1”、“170”对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = "%.2f" % Key_Y[0]
print('“1”、“170”对应的预测值（保留两位小数）：',Result_1)
print(type(Result_1))
print("-" * 10)
print('数组n_1 & 数组n_2 & “1”、“170”对应的预测值的效果：')
n_3 = np.array([[1,n_1[0][1],n_2[0]],[1,n_1[1][1],n_2[1]],[1,n_1[2][1],n_2[2]],
[1,n_1[3][1],n_2[3]],[1,n_1[4][1],n_2[4]],[1,n_1[5][1],n_2[5]],
[1,170,Result_1]])
print(n_3)
脚本运行的结果：（数组n_2相当于数组n_1的结果，会自动生成计算公式）
C:\Users\jacky\Desktop>python xx.py
[[ 1 56]
[ 1 104]
[ 1 156]
[ 1 200]
[ 1 250]
[ 1 300]]
----------
[ 560 1040 1560 2000 2500 3000]
----------
----------
回归系数： [0. 9.99975843]
截距： 0.04291845493594337
“1”、“170”对应的预测值： [1700.00185202]
-----
“1”、“170”对应的预测值（保留两位小数）： 1700.00
<class 'str'>
----------
数组n_1 & 数组n_2 & “1”、“170”对应的预测值的效果：
[['1' '56' '560']
['1' '104' '1040']
['1' '156' '1560']
['1' '200' '2000']
['1' '250' '2500']
['1' '300' '3000']
['1' '170' '1700.00']]
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_1 = np.array([[1,56],[1,104],[1,156],[1,200],[1,250],[1,300]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = np.array([600,1040,1560,2000,2500,3000]) #创建一个一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
Key_X = np.array([[1,170]])
Key_Y = clf.predict(Key_X)
print('回归系数：',k)
print('截距：',b)
print('“1”、“170”对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = "%.2f" % Key_Y[0]
print('“1”、“170”对应的预测值（保留两位小数）：',Result_1)
print(type(Result_1))
print("-" * 10)
print('数组n_1 & 数组n_2 & “1”、“170”对应的预测值的效果：')
n_3 = np.array([[1,n_1[0][1],n_2[0]],[1,n_1[1][1],n_2[1]],[1,n_1[2][1],n_2[2]],
[1,n_1[3][1],n_2[3]],[1,n_1[4][1],n_2[4]],[n_1[5][0],n_1[5][1],n_2[5]],
[1,170,Result_1]])
print(n_3)
脚本运行的结果：（预测值会随着数组的元素的变化而变化）
C:\Users\jacky\Desktop>python xx.py
[[ 1 56]
[ 1 104]
[ 1 156]
[ 1 200]
[ 1 250]
[ 1 300]]
----------
[ 600 1040 1560 2000 2500 3000]
----------
----------
回归系数： [0. 9.88219569]
截距： 27.59656652360536
“1”、“170”对应的预测值： [1707.56983308]
-----
“1”、“170”对应的预测值（保留两位小数）： 1707.57
<class 'str'>
----------
数组n_1 & 数组n_2 & “1”、“170”对应的预测值的效果：
[['1' '56' '600']
['1' '104' '1040']
['1' '156' '1560']
['1' '200' '2000']
['1' '250' '2500']
['1' '300' '3000']
['1' '170' '1707.57']]
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_1 = np.array([[1,56],[2,104],[3,156],[4,200],[5,250],[6,300]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = np.array([560,1040,1560,2000,2500,3000]) #创建一个一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
Key_X = np.array([[1,170]])
Key_Y = clf.predict(Key_X)
print('回归系数：',k)
print('截距：',b)
print('“1”、“170”对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = "%.2f" % Key_Y[0]
print('“1”、“170”对应的预测值（保留两位小数）：',Result_1)
print(type(Result_1))
print("-" * 10)
print('数组n_1 & 数组n_2 & “1”、“170”对应的预测值的效果：')
n_3 = np.array([[1,n_1[0][1],n_2[0]],[2,n_1[1][1],n_2[1]],[3,n_1[2][1],n_2[2]],
[4,n_1[3][1],n_2[3]],[5,n_1[4][1],n_2[4]],[6,n_1[5][1],n_2[5]],
[1,170,Result_1]])
print(n_3)
脚本运行的结果：（预测值会随着数组的元素的变化而变化）
C:\Users\jacky\Desktop>python xx.py
[[ 1 56]
[ 2 104]
[ 3 156]
[ 4 200]
[ 5 250]
[ 6 300]]
----------
[ 560 1040 1560 2000 2500 3000]
----------
----------
回归系数： [0.20441416 9.99555621]
截距： 0.07406310176293118
“1”、“170”对应的预测值： [1699.52303362]
-----
“1”、“170”对应的预测值（保留两位小数）： 1699.52
<class 'str'>
----------
数组n_1 & 数组n_2 & “1”、“170”对应的预测值的效果：
[['1' '56' '560']
['2' '104' '1040']
['3' '156' '1560']
['4' '200' '2000']
['5' '250' '2500']
['6' '300' '3000']
['1' '170' '1699.52']]
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_1 = np.array([[1,56],[2,104],[3,156],[4,200],[5,250],[6,300]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = np.array([560,1040,1560,2000,2500,3000]) #创建一个一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
Key_X = np.array([[7,170]])
Key_Y = clf.predict(Key_X)
print('回归系数：',k)
print('截距：',b)
print('“7”、“170”对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = "%.2f" % Key_Y[0]
print('“7”、“170”对应的预测值（保留两位小数）：',Result_1)
print(type(Result_1))
print("-" * 10)
print('数组n_1 & 数组n_2 & “7”、“170”对应的预测值的效果：')
n_3 = np.array([[1,n_1[0][1],n_2[0]],[2,n_1[1][1],n_2[1]],[3,n_1[2][1],n_2[2]],
[4,n_1[3][1],n_2[3]],[5,n_1[4][1],n_2[4]],[n_1[5][0],n_1[5][1],n_2[5]],
[7,170,Result_1]])
print(n_3)
脚本运行的结果：（预测值会随着数组的元素的变化而变化）
C:\Users\jacky\Desktop>python xx.py
[[ 1 56]
[ 2 104]
[ 3 156]
[ 4 200]
[ 5 250]
[ 6 300]]
----------
[ 560 1040 1560 2000 2500 3000]
----------
----------
回归系数： [0.20441416 9.99555621]
截距： 0.07406310176293118
“7”、“170”对应的预测值： [1700.74951859]
-----
“7”、“170”对应的预测值（保留两位小数）： 1700.75
<class 'str'>
----------
数组n_1 & 数组n_2 & “7”、“170”对应的预测值的效果：
[['1' '56' '560']
['2' '104' '1040']
['3' '156' '1560']
['4' '200' '2000']
['5' '250' '2500']
['6' '300' '3000']
['7' '170' '1700.75']]
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_0 = np.array([[1,56,560],[2,104,1040],[3,156,1560],[4,200,2000],[5,250,2500],[6,300,3000]]) #创建一个多维数组
print(n_0)
print("-" * 10)
print("-" * 10)
n_1 = np.delete(n_0,2,axis=1) #删除数组n_0的第3列
print(n_1)
print("-" * 10)
n_2 = np.delete(n_0,(0,1),axis=1) #删除数组n_0的第1列、第2列
print(n_2)
print("-" * 5)
n_2 = n_2.reshape(-1) #把数组n_2转换为一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
print('回归系数：',k)
print('截距：',b)
print("-" * 5)
Key_1 = 7
Key_2 = 170
Key_X = np.array([[Key_1,Key_2]])
Key_Y = clf.predict(Key_X)
print('自定义变量1：',Key_1)
print('自定义变量2：',Key_2)
print('自定义变量1、自定义变量2对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = "%.3f" % Key_Y[0]
print('自定义变量1、自定义变量2对应的预测值（保留三位小数）：',Result_1)
print(type(Result_1))
print("-" * 10)
print("-" * 10)
print('数组n_1 & 数组n_2 & 自定义变量1、自定义变量2对应的预测值的效果：')
n_3 = np.array([[1,n_1[0][1],n_2[0]],[2,n_1[1][1],n_2[1]],[3,n_1[2][1],n_2[2]],
[4,n_1[3][1],n_2[3]],[5,n_1[4][1],n_2[4]],[6,n_1[5][1],n_2[5]],
[Key_1,Key_2,Result_1]])
print(n_3)
脚本运行的结果：（数组n_2相当于数组n_1的结果，会自动生成计算公式）
C:\Users\jacky\Desktop>python xx.py
[[ 1 56 560]
[ 2 104 1040]
[ 3 156 1560]
[ 4 200 2000]
[ 5 250 2500]
[ 6 300 3000]]
----------
----------
[[ 1 56]
[ 2 104]
[ 3 156]
[ 4 200]
[ 5 250]
[ 6 300]]
----------
[[ 560]
[1040]
[1560]
[2000]
[2500]
[3000]]
-----
[ 560 1040 1560 2000 2500 3000]
----------
----------
回归系数： [0.20441416 9.99555621]
截距： 0.07406310176293118
-----
自定义变量1： 7
自定义变量2： 170
自定义变量1、自定义变量2对应的预测值： [1700.74951859]
-----
自定义变量1、自定义变量2对应的预测值（保留三位小数）： 1700.750
<class 'str'>
----------
----------
数组n_1 & 数组n_2 & 自定义变量1、自定义变量2对应的预测值的效果：
[['1' '56' '560']
['2' '104' '1040']
['3' '156' '1560']
['4' '200' '2000']
['5' '250' '2500']
['6' '300' '3000']
['7' '170' '1700.750']]
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_0 = np.array([[1,1,56,560],[2,1,104,1040],[3,1,156,1560],[4,1,200,2000],[5,1,250,2500],[6,1,300,3000]]) #创建一个多维数组
print(n_0)
print("-" * 10)
print("-" * 10)
n_1 = np.delete(n_0,3,axis=1) #删除数组n_0的第4列
print(n_1)
print("-" * 10)
n_2 = np.delete(n_0,(0,1,2),axis=1) #删除数组n_0的第1列、第2列、第3列
print(n_2)
print("-" * 5)
n_2 = n_2.reshape(-1) #把数组n_2转换为一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
print('回归系数：',k)
print('截距：',b)
print("-" * 5)
Key_1 = 7
Key_2 = 1
Key_3 = 170
Key_X = np.array([[Key_1,Key_2,Key_3]])
Key_Y = clf.predict(Key_X)
print('自定义变量1：',Key_1)
print('自定义变量2：',Key_2)
print('自定义变量3：',Key_3)
print('自定义变量1、自定义变量2、自定义变量3对应的预测值：',Key_Y)
脚本运行的结果：（数组n_2相当于数组n_1的结果，会自动生成计算公式）
C:\Users\jacky\Desktop>python xx.py
[[ 1 1 56 560]
[ 2 1 104 1040]
[ 3 1 156 1560]
[ 4 1 200 2000]
[ 5 1 250 2500]
[ 6 1 300 3000]]
----------
----------
[[ 1 1 56]
[ 2 1 104]
[ 3 1 156]
[ 4 1 200]
[ 5 1 250]
[ 6 1 300]]
----------
[[ 560]
[1040]
[1560]
[2000]
[2500]
[3000]]
-----
[ 560 1040 1560 2000 2500 3000]
----------
----------
回归系数： [0.20441416 0. 9.99555621]
截距： 0.07406310176293118
-----
自定义变量1： 7
自定义变量2： 1
自定义变量3： 170
自定义变量1、自定义变量2、自定义变量3对应的预测值： [1700.74951859]
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_0 = np.array([[1,1,56,560],[2,1,104,1040]]) #创建一个多维数组
print(n_0)
print("-" * 10)
print("-" * 10)
n_1 = np.delete(n_0,3,axis=1) #删除数组n_0的第4列
print(n_1)
print("-" * 10)
n_2 = np.delete(n_0,(0,1,2),axis=1) #删除数组n_0的第1列、第2列、第3列
print(n_2)
print("-" * 5)
n_2 = n_2.reshape(-1) #把数组n_2转换为一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
print('回归系数：',k)
print('截距：',b)
print("-" * 5)
Key_1 = 7
Key_2 = 1
Key_3 = 170
print('自定义变量1：',Key_1)
print('自定义变量2：',Key_2)
print('自定义变量3：',Key_3)
Key_X = np.array([[Key_1,Key_2,Key_3]])
print(Key_X)
Key_Y = clf.predict(Key_X)
print('自定义变量1、自定义变量2、自定义变量3对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = "%.3f" % Key_Y[0]
print('预测值（保留三位小数）：',Result_1)
print(type(Result_1))
print("-" * 5)
n_3 = np.array([Key_1,Key_2,Key_3,Result_1]) #创建一个一维数组
print(n_3)
脚本运行的结果：（预测值会随着数组的元素的变化而变化）
C:\Users\jacky\Desktop>python xx.py
[[ 1 1 56 560]
[ 2 1 104 1040]]
----------
----------
[[ 1 1 56]
[ 2 1 104]]
----------
[[ 560]
[1040]]
-----
[ 560 1040]
----------
----------
回归系数： [0.20806242 0. 9.9869961 ]
截距： 0.7282184655397259
-----
自定义变量1： 7
自定义变量2： 1
自定义变量3： 170
[[ 7 1 170]]
自定义变量1、自定义变量2、自定义变量3对应的预测值： [1699.9739922]
-----
预测值（保留三位小数）： 1699.974
<class 'str'>
-----
['7' '1' '170' '1699.974']
C:\Users\jacky\Desktop>
###### （岭回归）
#coding=utf-8
from sklearn import linear_model
from sklearn.linear_model import Ridge
import numpy as np
n_0 = np.array([[1,1,56,560],[2,1,104,1040],[3,1,156,1560]]) #创建一个多维数组
print(n_0)
print("-" * 10)
print("-" * 10)
n_1 = np.delete(n_0,3,axis=1) #删除数组n_0的第4列
print(n_1)
print("-" * 10)
n_2 = np.delete(n_0,(0,1,2),axis=1) #删除数组n_0的第1列、第2列、第3列
print(n_2)
print("-" * 5)
n_2 = n_2.reshape(-1) #把数组n_2转换为一维数组
print(n_2)
print("-" * 10)
print("-" * 10)
clf = linear_model.LinearRegression()
clf = Ridge(alpha=1.0) #使用Ridge函数
clf.fit(n_1,n_2) #拟合线性模型
k = clf.coef_
b = clf.intercept_
print('回归系数：',k)
print('截距：',b)
print("-" * 5)
Key_1 = 7
Key_2 = 1
Key_3 = 170
print('自定义变量1：',Key_1)
print('自定义变量2：',Key_2)
print('自定义变量3：',Key_3)
Key_X = np.array([[Key_1,Key_2,Key_3]])
print(Key_X)
Key_Y = clf.predict(Key_X)
print('自定义变量1、自定义变量2、自定义变量3对应的预测值：',Key_Y)
print("-" * 5)
Result_1 = "%.4f" % Key_Y[0]
print('预测值（保留四位小数）：',Result_1)
print(type(Result_1))
print("-" * 5)
n_3 = np.array([Key_1,Key_2,Key_3,Result_1]) #创建一个一维数组
print(n_3)
print("-" * 10)
print("-" * 10)
print('数组n_1 & 数组n_2 & 自定义变量1、自定义变量2、自定义变量3对应的预测值的效果：')
n_4 = np.array([[1,n_1[0][1],n_1[0][2],n_2[0]],[2,n_1[1][1],n_1[1][2],n_2[1]],
[n_1[2][0],n_1[2][1],n_1[2][2],n_2[2]],
[Key_1,Key_2,Key_3,n_3[3]]])
print(n_4)
脚本运行的结果：（预测值会随着数组的元素的变化而变化）
C:\Users\jacky\Desktop>python xx.py
[[ 1 1 56 560]
[ 2 1 104 1040]
[ 3 1 156 1560]]
----------
----------
[[ 1 1 56]
[ 2 1 104]
[ 3 1 156]]
----------
[[ 560]
[1040]
[1560]]
-----
[ 560 1040 1560]
----------
----------
回归系数： [0.19956097 0. 9.99401317]
截距： 0.23149072041519503
-----
自定义变量1： 7
自定义变量2： 1
自定义变量3： 170
[[ 7 1 170]]
自定义变量1、自定义变量2、自定义变量3对应的预测值： [1700.61065656]
-----
预测值（保留四位小数）： 1700.6107
<class 'str'>
-----
['7' '1' '170' '1700.6107']
----------
----------
数组n_1 & 数组n_2 & 自定义变量1、自定义变量2、自定义变量3对应的预测值的效果：
[['1' '1' '56' '560']
['2' '1' '104' '1040']
['3' '1' '156' '1560']
['7' '1' '170' '1700.6107']]
C:\Users\jacky\Desktop>
###### （自定义预测公式）
#coding=utf-8
import numpy as np
n_0 = np.array([[1,56,560],[1,104,1040],[1,156,1560]]) #创建一个多维数组
print(n_0)
print("-" * 10)
print("-" * 10)
Key_1 = 1
Key_2 = 170
print('自定义变量1：',Key_1)
print('自定义变量2：',Key_2)
Key_X = Key_1 * Key_2 * 10
print('自定义变量1、自定义变量2对应的预测值：',Key_X)
Result_1 = Key_X
print(type(Result_1))
print("-" * 10)
print('数组n_0 & 自定义变量1、自定义变量2 & 预测值的效果：')
n_1 = np.array([[n_0[0][0],n_0[0][1],n_0[0][2]],[n_0[1][0],n_0[1][1],n_0[1][2]],
[n_0[2][0],n_0[2][1],n_0[2][2]],
[Key_1,Key_2,Result_1]])
print(n_1)
脚本运行的结果：
C:\Users\jacky\Desktop>python xx.py
[[ 1 56 560]
[ 1 104 1040]
[ 1 156 1560]]
----------
----------
自定义变量1： 1
自定义变量2： 170
自定义变量1、自定义变量2对应的预测值： 1700
<class 'int'>
----------
数组n_0 & 自定义变量1、自定义变量2 & 预测值的效果：
[[ 1 56 560]
[ 1 104 1040]
[ 1 156 1560]
[ 1 170 1700]]
C:\Users\jacky\Desktop>
###### （自定义预测公式）
#coding=utf-8
import numpy as np
n_0 = np.array([[1,56,560],[1,104,1040],[1,156,1560]]) #创建一个多维数组
print(n_0)
print("-" * 10)
print("-" * 10)
Key_1 = 1
Key_2 = 170
print('自定义变量1：',Key_1)
print('自定义变量2：',Key_2)
Key_X = Key_1 * Key_2 * 10
print('自定义变量1、自定义变量2对应的预测值：',Key_X)
Result_1 = Key_X
print(type(Result_1))
print("-" * 5)
Result_1 = "%.2f" % Key_X
print('预测值（保留两位小数）：',Result_1)
print(type(Result_1))
print("-" * 10)
print('数组n_0 & 自定义变量1、自定义变量2 & 预测值的效果：')
n_1 = np.array([[n_0[0][0],n_0[0][1],n_0[0][2]],[n_0[1][0],n_0[1][1],n_0[1][2]],
[n_0[2][0],n_0[2][1],n_0[2][2]],
[Key_1,Key_2,Result_1]])
print(n_1)
脚本运行的结果：
C:\Users\jacky\Desktop>python xx.py
[[ 1 56 560]
[ 1 104 1040]
[ 1 156 1560]]
----------
----------
自定义变量1： 1
自定义变量2： 170
自定义变量1、自定义变量2对应的预测值： 1700
<class 'int'>
-----
预测值（保留两位小数）： 1700.00
<class 'str'>
----------
数组n_0 & 自定义变量1、自定义变量2 & 预测值的效果：
[['1' '56' '560']
['1' '104' '1040']
['1' '156' '1560']
['1' '170' '1700.00']]
C:\Users\jacky\Desktop>
###### （自定义预测公式）
#coding=utf-8
import numpy as np
n_0 = np.array([[1,56,560],[1,104,1040],[1,156,1560]]) #创建一个多维数组
print(n_0)
print("-" * 10)
print("-" * 10)
Key_1 = 1
Key_2 = 170
print('自定义变量1：',Key_1)
print('自定义变量2：',Key_2)
Key_X = Key_1 * Key_2 * 10
print('自定义变量1、自定义变量2对应的预测值：',Key_X)
Result_1 = Key_X
print(type(Result_1))
print("-" * 5)
Result_1 = "%.3f" % Key_X
print(f'预测值（保留三位小数）： {Result_1}')
print(type(Result_1))
print("-" * 10)
n_1 = np.array(['第一次测试','第二次测试','第三次测试','第四次测试']) #创建一个一维数组
print(n_1)
print("-" * 10)
print('数组n_1 & 数组n_0 & 自定义变量1、自定义变量2 & 预测值的效果：')
n_2 = np.array([[n_1[0],n_0[0][0],n_0[0][1],n_0[0][2]],[n_1[1],n_0[1][0],
n_0[1][1],n_0[1][2]],
[n_1[2],n_0[2][0],n_0[2][1],n_0[2][2]],
[n_1[3],Key_1,Key_2,Result_1]])
print(n_2)
脚本运行的结果：
C:\Users\jacky\Desktop>python xx.py
[[ 1 56 560]
[ 1 104 1040]
[ 1 156 1560]]
----------
----------
自定义变量1： 1
自定义变量2： 170
自定义变量1、自定义变量2对应的预测值： 1700
<class 'int'>
-----
预测值（保留三位小数）： 1700.000
<class 'str'>
----------
['第一次测试' '第二次测试' '第三次测试' '第四次测试']
----------
数组n_1 & 数组n_0 & 自定义变量1、自定义变量2 & 预测值的效果：
[['第一次测试' '1' '56' '560']
['第二次测试' '1' '104' '1040']
['第三次测试' '1' '156' '1560']
['第四次测试' '1' '170' '1700.000']]
C:\Users\jacky\Desktop>
聚类：
聚类类似于分类，不同的是，聚类所划分的类是未知的，要通过一定的算法进行自动分类。
简单地说，聚类就是将相似的数据聚在一起。
###### （聚类数据生成器+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
## 随机生成用于聚类的数据（100个样本，每个样本含有3个特征，类别数为3）：
x,y = make_blobs(n_samples=100,n_features=3,centers=3)
y_pred = KMeans(n_clusters=3,random_state=9).fit_predict(x) #调用KMeans方法实现聚类（分三类）
print('预测类别：','\n',y_pred)
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("随机数据自动分三类") #图形标题
plt.scatter(x[:,0],x[:,1],c=y_pred) #绘制散点图
plt.show() #显示图形
脚本运行的结果：
脚本运行后的图形效果：
从分析结果得知：相似的数据聚在一起，分成了3堆，也就是3类，并以不同的颜色显示，看上去更加清晰直观。
###### （聚类数据生成器+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('white') #设置Seaborn的背景风格为white
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
## 随机生成用于聚类的数据（200个样本，每个样本含有2个特征，类别数为3）：
x,y = make_blobs(n_samples=200,n_features=2,centers=3)
y_pred = KMeans(n_clusters=4,random_state=9).fit_predict(x) #调用KMeans方法实现聚类（分四类）
print(f'预测类别： \n {y_pred}')
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("随机数据自动分四类") #图形标题
plt.scatter(x[:,0],x[:,1],c=y_pred) #绘制散点图
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
从分析结果得知：相似的数据聚在一起，分成了4堆，也就是4类，并以不同的颜色显示，看上去更加清晰直观。
###### （聚类数据生成器+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('white') #设置Seaborn的背景风格为white
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import numpy as np
## 随机生成用于聚类的数据（200个样本，每个样本含有2个特征，类别数为3）：
x,y = make_blobs(n_samples=200,n_features=2,centers=3)
y_pred = KMeans(n_clusters=4,random_state=9).fit_predict(x) #调用KMeans方法实现聚类（分四类）
print(f'预测类别：\n{y_pred}')
print("-" * 5)
print("-" * 5)
## 自定义类别的颜色：
color_map = {0: 'red', 1: 'blue', 2: 'green', 3: 'black'}
colors = np.array([color_map[cat] for cat in y_pred])
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("随机数据自动分四类",fontsize=18) #图形标题
plt.scatter(x[:,0],x[:,1],c=colors) #绘制散点图，自定义了不同类别的点的颜色
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
从分析结果得知：相似的数据聚在一起，分成了4堆，也就是4类，并以不同的自定义颜色显示，看上去更加清晰直观。
###### （K-means聚类）
#coding=utf-8
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[1,11],[2,20],[2,23],[3,21]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = n_1[:,0] #多维数组n_1的第1列的数组
print(n_2)
print("-" * 5)
n_3 = n_1[:,1] #多维数组n_1的第2列的数组
print(n_3)
print("-" * 10)
print("-" * 10)
kmodel = KMeans(n_clusters=2) #调用KMeans方法实现聚类（分两类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
print('聚类中心坐标值：','\n',kmodel.cluster_centers_)
脚本运行的结果：（可以看到是以数组n_1的第2列的数组来分类的）
C:\Users\jacky\Desktop>python xx.py
[[ 1 10]
[ 1 11]
[ 2 20]
[ 2 23]
[ 3 21]]
----------
[1 1 2 2 3]
-----
[10 11 20 23 21]
----------
----------
预测类别： [1 1 0 0 0]
聚类中心坐标值：
[[ 2.33333333 21.33333333]
[ 1. 10.5 ]]
C:\Users\jacky\Desktop>
###### （K-means聚类）
#coding=utf-8
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[1,11],[2,20],[2,23],[3,21]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = n_1[:,0] #多维数组n_1的第1列的数组
print(n_2)
print("-" * 5)
n_3 = n_1[:,1] #多维数组n_1的第2列的数组
print(n_3)
print("-" * 10)
print("-" * 10)
kmodel = KMeans(n_clusters=3) #调用KMeans方法实现聚类（分三类）
y_pred = kmodel.fit_predict(n_1)
print(f'预测类别：{y_pred}')
print(f'聚类中心坐标值：\n{kmodel.cluster_centers_}')
脚本运行的结果：（可以看到是以数组n_1的第2列的数组来分类的）
C:\Users\jacky\Desktop>python xx.py
[[ 1 10]
[ 1 11]
[ 2 20]
[ 2 23]
[ 3 21]]
----------
[1 1 2 2 3]
-----
[10 11 20 23 21]
----------
----------
预测类别：[1 1 0 2 0]
聚类中心坐标值：
[[ 2.5 20.5]
[ 1. 10.5]
[ 2. 23. ]]
C:\Users\jacky\Desktop>
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[1,11],[2,20],[2,23],[3,21]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = n_1[:,0] #数组n_1的第1列的数组
print(n_2)
print("-" * 5)
n_3 = n_1[:,1] #数组n_1的第2列的数组
print(n_3)
print("-" * 10)
print("-" * 10)
kmodel = KMeans(n_clusters=2) #调用KMeans方法实现聚类（分两类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
print('类别标记：',kmodel.labels_)
print("-" * 5)
print("-" * 5)
plt.scatter(n_1[:,0],n_1[:,1],c=y_pred) #绘制散点图
plt.show()
脚本运行的结果：（可以看到是以数组n_1的第2列的数组来分类的）
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[1,11],[2,20],[2,23],[3,21]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = n_1[:,0] #数组n_1的第1列的数组
print(n_2)
print("-" * 5)
n_3 = n_1[:,1] #数组n_1的第2列的数组
print(n_3)
print("-" * 10)
print("-" * 10)
kmodel = KMeans(n_clusters=2) #调用KMeans方法实现聚类（分两类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
## 自定义类别的颜色：
color_map = {0: 'red', 1: 'blue'}
colors = np.array([color_map[cat] for cat in y_pred])
print("-" * 5)
print("-" * 5)
plt.scatter(n_1[:,0],n_1[:,1],c=colors) #绘制散点图，自定义了不同类别的点的颜色
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[1,11],[2,20],[2,23],[3,21]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = n_1[:,0] #数组n_1的第1列的数组
print(n_2)
print("-" * 5)
n_3 = n_1[:,1] #数组n_1的第2列的数组
print(n_3)
print("-" * 10)
print("-" * 10)
kmodel = KMeans(n_clusters=3) #调用KMeans方法实现聚类（分三类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
print('类别标记：',kmodel.labels_)
print("-" * 5)
print("-" * 5)
plt.grid(axis='y',linestyle=':',color='purple',alpha=0.6) #显示网格线，但不显示网格线的y轴
plt.scatter(n_1[:,0],n_1[:,1],c=y_pred) #绘制散点图
plt.show()
脚本运行的结果：（可以看到是以数组n_1的第2列的数组来分类的）
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[1,11],[2,20],[2,23],[3,21]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = n_1[:,0] #数组n_1的第1列的数组
print(n_2)
print("-" * 5)
n_3 = n_1[:,1] #数组n_1的第2列的数组
print(n_3)
print("-" * 10)
print("-" * 10)
kmodel = KMeans(n_clusters=3) #调用KMeans方法实现聚类（分三类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
## 自定义类别的颜色：
color_map = {0: 'red', 1: 'blue', 2: 'green'}
colors = np.array([color_map[cat] for cat in y_pred])
print("-" * 5)
print("-" * 5)
plt.grid(axis='x',linestyle=':',color='purple',alpha=0.6) #显示网格线，但不显示网格线的x轴
plt.scatter(n_1[:,0],n_1[:,1],c=colors) #绘制散点图，自定义了不同类别的点的颜色
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
import numpy as np
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
n_1 = np.array([[1,10],[2,25],[3,12],[4,20],[5,23],[6,21],[7,11]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = n_1[:,0] #数组n_1的第1列的数组
print(n_2)
print("-" * 5)
n_3 = n_1[:,1] #数组n_1的第2列的数组
print(n_3)
print("-" * 10)
kmodel = KMeans(n_clusters=2) #调用KMeans方法实现聚类（分两类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
print("-" * 10)
print("-" * 10)
n_4 = np.array(['李大杰','小红','Jacky','Lily','zhuohua wu','小明','小白']) #创建一个一维数组
print(n_4)
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("语文成绩的分析比较（自动分两类）") #图形标题
plt.grid(True,linestyle=':',color='purple',alpha=0.6) #显示网格线
plt.scatter(n_4,n_1[:,1],c=y_pred) #绘制散点图
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
import numpy as np
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
n_1 = np.array([[1,10],[2,25],[3,12],[4,20],[5,23],[6,21],[7,11]]) #创建一个多维数组
print(n_1)
print("-" * 5)
kmodel = KMeans(n_clusters=2) #调用KMeans方法实现聚类（分两类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
## 自定义类别的颜色：
color_map = {0: 'red', 1: 'blue'}
colors = np.array([color_map[cat] for cat in y_pred])
print("-" * 10)
print("-" * 10)
n_4 = np.array(['李大杰','小红','Jacky','Lily','zhuohua wu','小明','小白']) #创建一个一维数组
print(n_4)
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("语文成绩的分析比较（自动分两类）",fontsize=18,loc='left') #图形标题
plt.grid(True,linestyle=':',color='purple',alpha=0.6) #显示网格线
plt.scatter(n_4,n_1[:,1],c=colors) #绘制散点图，自定义了不同类别的点的颜色
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('whitegrid') #设置Seaborn的背景风格为whitegrid
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[2,25],[3,12],[4,20],[5,23],[6,21],[7,11]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = n_1[:,0] #数组n_1的第1列的数组
print(n_2)
print("-" * 5)
n_3 = n_1[:,1] #数组n_1的第2列的数组
print(n_3)
print("-" * 10)
kmodel = KMeans(n_clusters=3) #调用KMeans方法实现聚类（分三类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
print("-" * 10)
print("-" * 10)
n_4 = np.array(['李大杰','小红','Jacky','Lily','zhuohua wu','小明','小白']) #创建一个一维数组
print(n_4)
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("语文成绩的分析比较（自动分三类）") #图形标题
plt.scatter(n_4,n_1[:,1],c=y_pred) #绘制散点图
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('whitegrid') #设置Seaborn的背景风格为whitegrid
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[2,25],[3,12],[4,20],[5,23],[6,21],[7,11]]) #创建一个多维数组
print(n_1)
print("-" * 5)
kmodel = KMeans(n_clusters=3) #调用KMeans方法实现聚类（分三类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
## 自定义类别的颜色：
color_map = {0: 'red', 1: 'blue', 2: 'green'}
colors = np.array([color_map[cat] for cat in y_pred])
print("-" * 10)
print("-" * 10)
n_4 = np.array(['李大杰','小红','Jacky','Lily','zhuohua wu','小明','小白']) #创建一个一维数组
print(n_4)
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("语文成绩的分析比较（自动分三类）",fontsize=18,loc='right') #图形标题
plt.scatter(n_4,n_1[:,1],c=colors) #绘制散点图，自定义了不同类别的点的颜色
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('white') #设置Seaborn的背景风格为white
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[2,25],[3,12],[4,20],[5,23],[6,21],[7,11]]) #创建一个多维数组
print(n_1)
print("-" * 10)
n_2 = n_1[:,0] #数组n_1的第1列的数组
print(n_2)
print("-" * 5)
n_3 = n_1[:,1] #数组n_1的第2列的数组
print(n_3)
print("-" * 10)
kmodel = KMeans(n_clusters=2) #调用KMeans方法实现聚类（分两类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
print("-" * 10)
print("-" * 10)
n_4 = np.array(['第一季度','第一季度','第二季度','第二季度','第三季度','第三季度','第四季度']) #创建一个一维数组
print(n_4)
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("苹果销量的分析比较（自动分两类）",fontsize=18) #图形标题
plt.grid(axis='y',linestyle=':',color='purple',alpha=0.6) #显示网格线，但不显示网格线的y轴
plt.scatter(n_4,n_1[:,1],c=y_pred) #绘制散点图
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('white') #设置Seaborn的背景风格为white
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[2,25],[3,12],[4,20],[5,23],[6,21],[7,11]]) #创建一个多维数组
print(n_1)
print("-" * 5)
kmodel = KMeans(n_clusters=2) #调用KMeans方法实现聚类（分两类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
## 自定义类别的颜色：
color_map = {0: 'red', 1: 'blue'}
colors = np.array([color_map[cat] for cat in y_pred])
print("-" * 10)
print("-" * 10)
n_4 = np.array(['第一季度','第一季度','第二季度','第二季度','第三季度','第三季度','第四季度']) #创建一个一维数组
print(n_4)
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("苹果销量的分析比较（自动分两类）",fontsize=18) #图形标题
plt.grid(axis='x',linestyle=':',color='purple',alpha=0.6) #显示网格线，但不显示网格线的x轴
plt.scatter(n_4,n_1[:,1],c=colors) #绘制散点图，自定义了不同类别的点的颜色
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('darkgrid') #设置Seaborn的背景风格为darkgrid
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[2,25],[3,12],[4,20],[5,23],[6,21],[7,11]]) #创建一个多维数组
print(n_1)
print("-" * 5)
kmodel = KMeans(n_clusters=3) #调用KMeans方法实现聚类（分三类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
print("-" * 10)
print("-" * 10)
n_2 = np.array(['第一季度','第一季度','第二季度','第二季度','第三季度','第三季度','第四季度']) #创建一个一维数组
print(n_2)
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("苹果销量的分析比较（自动分三类）",fontsize=18) #图形标题
plt.scatter(n_2,n_1[:,1],c=y_pred) #绘制散点图
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
###### （K-means聚类+散点图）
#coding=utf-8
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('darkgrid') #设置Seaborn的背景风格为darkgrid
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
from sklearn.cluster import KMeans
import numpy as np
n_1 = np.array([[1,10],[2,25],[3,12],[4,20],[5,23],[6,21],[7,11]]) #创建一个多维数组
print(n_1)
print("-" * 5)
kmodel = KMeans(n_clusters=3) #调用KMeans方法实现聚类（分三类）
y_pred = kmodel.fit_predict(n_1)
print('预测类别：',y_pred)
## 自定义类别的颜色：
color_map = {0: 'red', 1: 'blue', 2: 'green'}
colors = np.array([color_map[cat] for cat in y_pred])
print("-" * 10)
print("-" * 10)
n_2 = np.array(['第一季度','第一季度','第二季度','第二季度','第三季度','第三季度','第四季度']) #创建一个一维数组
print(n_2)
print("-" * 5)
print("-" * 5)
plt.figure(figsize=(8,6)) #自定义窗体的宽和高
plt.title("苹果销量的分析比较（自动分三类）",fontsize=20) #图形标题
plt.scatter(n_2,n_1[:,1],c=colors) #绘制散点图，自定义了不同类别的点的颜色
plt.show()
脚本运行的结果：
脚本运行后的图形效果：
相关文章：
Pandas+Excel+绘图库Matplotlib
Pandas+Excel+绘图库Matplotlib+Seaborn图表 |
