数据挖掘学习笔记

 #1.41数值类型

    
 int,float,bool
    
 #1.42字符串str
    
 s1='abcd'
    
 s2='''ab cd'''

 L1=[1,'a1',2,'aa']

    
 #[1, 'a1', 2, 'aa']

 T1=(1,'a1')

    
 T1=(1,'C1','A1')
    
 #(1, 'C1', 'A1')
    
  
    
 T1[1]=2
    
 # 'tuple' object does not support item assignment
    
 ​

 J1={266,3,'h'}

    
 #{266, 3, 'h'}
    
 ​
    
 J2={266,3,3,'h','a','A','h'}
    
 #{'A', 3, 266, 'h', 'a'} 
    
 ​
    
 J2[0]
    
 #'set' object does not support indexing

 d1={1:1,'J':{266,2,2},'T':(3,'A'),'L':[5,5],3:'''6'''}

    
 #{1: 1, 'J': {2, 266}, 'T': (3, 'A'), 'L': [5, 5], 3: '6'}
    
 ​
    
 d1[3]
    
 #'6'

 #通用

    
 s2='hello world!'
    
 ​
    
 s2[0:]
    
 #'hello world!'
    
 ​
    
 s2[0:1]
    
 #'h' 
    
 #包左不包右
    
 ​
    
 s2[:]
    
 #'hello world!'
    
 ​
    
 s2[-1]
    
 #'!'
    
 ​
    
 s2[0:5:2]
    
 #'hlo'
    
 #从s2[0]开始两步截取一次
    
 #[开始索引：结束索引：步长]
    
  
    
  
    
 s2[::-1]
    
 #'!dlrow olleh'

    len(s2)

 s2='hello world!'

    
 max(s2)
    
 #'w'

 'e'in s2

    
 #True

 s2='''ab cd'''

    
 del s2
    
 s2
    
 # name 's2' is not defined

 L1=[1,'a1',2,'aa']

    
 #1创建空列表 
    
 L=list()
    
 #L=[]
    
  
    
 #2添加元素
    
 L.append('H')
    
  
    
 #3扩展列表
    
 L.extend(L1)#可以和元组做一下对比
    
  
    
 #某元素计数
    
 L.count('H')
    
  
    
 #返回某元素下标
    
 L.index('H')
    
  
    
 #元素排序 需要同为str或者int时
    
 L.sort()

 #1创建空元组

    
 T=tuple()
    
 T=()
    
 #2元素计数
    
 T1.count('a1')
    
 #3返回下标
    
 T1.index('a1')
    
  
    
 #4元组连接
    
 T+T1 #和列表做一下对比

 s1='abcd'

    
 #创建空字符串
    
 S=str()
    
 ​
    
 #查找子串 查找子串开始出现的索引位置,没有找到则返回—1
    
 #第一个参数为需要查找的子串,第二个参数为指定待查字符串的开始位置，第三个参数为指定待查字符串的长度
    
 s1.find('a',1,len(s1))
    
 ​
    
 #替换子串
    
 #(被替换子串，替换子串)
    
 s1.replace('a','aa')
    
 ​
    
 #字符串连接 和元组一样用+ 和列表不一样
    
 s1+S
    
 ​
    
 #字符串比较
    
 S==s1

 #创建字典

    
 d=dict()
    
 d={}
    
  
    
 #可以将嵌套元素转为字典(必须嵌套，length只能为2（1键1值）)
    
 d1=dict([[1,'aa']])
    
 ​
    
 #获取字典值 由键获取对应的值 
    
 d1.get(1)
    
 ​
    
 #字典赋值
    
 d.setdefault(2,['a','b'])
    
  
    
 # 第一种 若键不存在则会抛出KeyError异常
    
 person['city']
    
 # 第二种 不会抛出异常，不存在则返回None,也可以设置默认返回值
    
 person.get('city',"上海")
    
 # 第三种 与第二种类似，区别在于setdefault方法会更新字典
    
 person.setdefault('city', '上海')
    
 ————————————————
    
 版权声明：本文为博主「从小就拽」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    
 原文链接：

 def work(r):

    
     import math
    
     c=2*math.pi*r
    
     s=math.pi*r*r
    
     return(c,s)
    
 work(1)

  
    
 #嵌套列表(元素为元祖) 转为二维数组
    
 L3=[(1,2),(3,4)]
    
 L4=np.array(L3)
    
 #嵌套元祖(元素为元祖) 转为三维数组
    
 L5=((1,2),(3,4),(5,6))
    
 L6=np.array(L5)

 #numpy多维数组中的子数组必须具有相同的长度

    
 d3 = [[1,2,3],[4,5,6],[7,8,9,10]]
    
 A33 = np.array(d3)

 #创建3行4列元素全为1的数组

    
 z1 = np.ones((3,4))
    
 #创建3行4列元素全为0的数组
    
 z2 = np.zeros((3,4))

  
    
 #创建默认初始值为0 默认步长为1 末值为9的一维数组 
    
 z3 = np.arange(10)
    
  
    
 #创建初始值为2 步长为2 末值为9的一维数组
    
 z4 = np.arrange(2,10,2)
    
 #array([2, 4, 6, 8])

 #一维数组 仅返回一个元素 代表这个数组的长度

    
 d11 = np.array([1,2,3,4,5,7])
    
 s11 = d11.shape
    
 s11
    
 #(6,)
    
  
    
 #二维数组 返回元组中有两个值 (行数，列数）
    
 d2 = [[1,2,3],[4,5,6],[7,8,9]]
    
 A22 = np.array(d2)
    
 s22 = d22.shape
    
 s22
    
 #(3, 3)

 r = np.array(range(10))

    
 r1 = r.reshape((2,5))
    
 r1

 A = np.array([[1,2],[3,4]])

    
 B = np.array([[5,6],[7,8]])
    
 #A数组所有元素取平方 然后与B数组对应元素之间相除
    
 C1 = A**2/B
    
  
    
 #数学运算
    
 M1 = np.sqrt(A)         #取平方根
    
 M2 = np.abs([-1,-2,10]) #取绝对值

 #D[①，②] ①控制行下标 ②控制列下标  下标从零开始

    
 #取所有行或所有列 用:代替
    
 D = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
    
 D12 = D[1,0]       #访问行为1 列为0的数据
    
 #5
    
 D03 = D[:,[0,3]]   #访问0，3列数据

 #*行控制 还可以通过逻辑列表来实现

    
 D0 = D[D[:,0]>4,:]        #取满足0列大于4所有列数据
    
 D31 = D[D[:,0]>5,[3,1]]   #取满足第0列大于4的3列数据 和 第0列大于5的1列数据
    
 D31
    
 #array([ 8, 10])

 TF = [False,True,True]

    
 Dtf = D[TF,[3,1]]
    
 Dtf
    
 #array([ 8, 10])

 D = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

    
 print(D[:,0]>4)
    
 #[False  True  True]
    
  
    
 print(np.ix_(D[:,0]>4 ))
    
 #(array([1, 2], dtype=int64),)

 Dix1 = D[np.ix_(D[:,0]>4),[3,1]]

    
 print(Dix1)
    
 print("-------这里注意看区别--------")
    
 Dix2 = D[np.ix_(D[:,0]>4,[3,1])]
    
 print(Dix2)

 import numpy as np

    
 A = np.array([[1,2],[3,4]])
    
 B = np.array([[5,6],[7,8]])
    
 C_s = np.hstack((A,B))  #水平连接要求行数相同
    
 C_v = np.vstack((A,B))  #垂直链接要求列数相同
    
 C_v

 #存

    
 np.save('data77',C_v)

 #加载数据集

    
 np.load('data77.npy')

 #一维变二维

    
 arr = np.arange(12).reshape(3,4)
    
  
    
 #二维变一维
    
 arr1 = arr.ravel()

 arr2 = np.array([1,4,33,22,66,777,2,33,777])

    
 arr3 = np.sort(arr2)
    
 #array([  1,   2,   4,  22,  33,  33,  66, 777,777])

 maxIndex = np.argmax(arr2)

    
 minIndex = np.argmin(arr2)
    
 maxIndex
    
 #5

 arr4 = arr2.reshape(3,3)

    
 print(arr4)
    
 maxIndex2 = np.argmax(arr4)
    
 maxIndex2

 maxIndex3 = np.argmax(arr4,axis = 0) #各列最大值的索引值

    
 #array([1, 1, 1], dtype=int64)
    
 minIndex3 = np.argmin(arr4,axis = 1) #各行最小值的索引值
    
 #array([0, 0, 0], dtype=int64)

 s1 = pd.Series([1,-2,2,3,'hq'])

    
 s1

 s2 = pd.Series(np.array([1,2,77]))

    
 s2

 s4 = pd.Series([1,-2,2,3,'hq'],index=['a','b','c','d','e'])

    
 s4

 s3 = pd.Series({'red':200,'blue':1000,'yellow':222})

    
 s3

 s1[0]

    
 #1
    
  
    
 s4['a']
    
 #1
    
  
    
 s3['red']
    
 #200

 s1 = pd.Series([1,-2,2,3,'hq'])

    
 s1.values
    
 #array([1, -2, 2, 3, 'hq'], dtype=object)
    
 s1.index
    
 #RangeIndex(start=0, stop=5, step=1)
    
 #这里注意stop=5
    
  
    
 s3 = pd.Series({'red':200,'blue':1000,'yellow':222})
    
 s3.values
    
 #array([ 200, 1000,  222], dtype=int64) #也是数组
    
 s3.index
    
 #Index(['red', 'blue', 'yellow'], dtype='object')

 S5 = pd.Series([1,'xl','xl',2,3,'pd'])

    
 S5

 S51 = S5.unique()

    
 S51
    
 #array([1, 'xl', 2, 3, 'pd'], dtype=object)

 S5 = pd.Series([1,'xl','xl',2,3,'pd'])

    
 S52 = S5.isin([1,'xl'])
    
 S52

 S5 = pd.Series([1,'xl','xl',2,3,'pd'])

    
 S53 = S5.value_counts()
    
 S53

 s6 = pd.Series([10,'hq','hq',np.nan])#np.nan为空值

    
 s6.isnull()

 s6[s6.isnull()]

    
 #3    NaN

 #~为取反 采用逻辑数组通过索引获取数据

    
 s61 = s6[~s6.isnull()]
    
  
    
 s62 = s6[s6.notnull()]
    
  
    
 s63 = s6.dropna
    
  
    
 #三者执行结果一样

 s1 = pd.Series([1,-2,7,'hq','dd'],index=['a','b','c','d','e'])

    
 #索引连续
    
 print(s1[0:2])

 #索引不连续

    
 s1[[0,1,3]]

 #索引为连续数组

    
 s2 = pd.Series([1,2,4.5,7,9])
    
 s2[s2>4]

 s = pd.Series([1,2,4,5,6,7,8,9,10])

    
 ssum = s.sum()
    
 print(ssum)#52
    
  
    
 smax = s.max()
    
 print(smax)#10
    
  
    
 smin = s.min()
    
 print(smin)#1
    
  
    
 #求平均值
    
 smean = s.mean()
    
 print(smean)#5.777777777777778
    
 #求标准差
    
 sstd = s.std()
    
 print(sstd)#3.0731814857642954

 dic2 = {'a':[7,2,9,6],'b':['a','q','4','r'],'c':[3,4,5,9]}

    
 df2 = pd.DataFrame(dic2)
    
  
    
 print(df2)
    
 dfsv = df2.sort_values('a',ascending='False')#默认True为降序
    
 dfsv

 #第一部分 创建画布与子图

    
 #1创建画布
    
 plt.figure(1)
    
 #2将figue分成不同块 实现分面绘图
    
 plt.subplot(2,1,1)#分为2×1图形阵 选择第一张图片绘图
    
  
    
 #第二部分 添加画布内容
    
 plt.title("y = x^2 & y = x") #添加标题
    
 plt.xlabel("x") #添加x轴名称
    
 plt.ylabel("y") #添加y轴名称
    
 plt.xlim((0,1))   #指定x轴范围
    
 plt.ylim((0,1))   #指定y轴范围
    
 plt.xticks([0,0.3,0.6,1]) #设置x轴刻度
    
 plt.yticks([0,0.5,1])     #设置y轴刻度
    
 x = np.linspace(0,1,1000) #返回间隔类均匀的数值序列（start,stop,num)
    
 plt.plot(x,x**2)
    
 plt.plot(x,x)
    
 plt.legend(['y=*^2','y=x']) #绘制图形之后添加图列
    
  
    
 #第三部分 图形保存与展示
    
 plt.savefig('1.png')
    
 plt.show

 # 这里没有创建画布是因为 只要调用绘图命令 系统会默认创建画布

    
 plt.rcParams['font.sans-serif'] = 'SimHei'#设置字体 否则中文无法正常显示
    
 plt.rcParams['axes.unicode_minus'] = False
    
 plt.title('sin曲线')
    
 x = np.arange(0,10,0.2)
    
 y = np.sin(x)
    
 plt.plot(x,y)
    
 plt.savefig('3.png')
    
 plt.show()

 #绘制某车次某日上车人数

    
 #读取文件
    
 data = pd.read_excel('car1.xlsx')
    
 #筛选车次这列值为DO2的，指定日期，上车人数这两列，以日期值做降序排列
    
 filterData = data.loc[data['车次'] == 'D02',['日期','上车人数']].sort_values('日期')
    
 #设置x , y 值并绘图
    
 x1 = np.arange(1,len(filterData.iloc[:,0])+1)
    
 y1 = filterData.iloc[:,1]
    
 plt.scatter(x1,y1)
    
 plt.rcParams['font.sans-serif'] = 'SimHei'
    
 plt.title('D02车次上车人数散点图')
    
 plt.xlabel('日期')
    
 plt.ylabel('上车人数')
    
 #设置x轴的数目和取值
    
 plt.xticks([1,5,10,15,20,24],filterData['日期'].values[[0,4,9,14,19,23]],rotation = 90)
    
 plt.show()

 data = pd.read_excel('car1.xlsx')

    
  
    
 xd02 = data.loc[data['车次'] == 'D02',['日期','上车人数']]
    
 x2 = np.arange(1,len(xd02.iloc[:,0])+1)
    
 y2 = xd.iloc[:,1]
    
  
    
 xd03 = data.loc[data['车次'] == 'D03',['日期','上车人数']]
    
 x3 = np.arange(1,len(xd03.iloc[:,0])+1)
    
 y3 = xd03.iloc[:,1]
    
  
    
 plt.plot(x2,y2,'r*--')
    
 plt.plot(x3,y3,'b*--')
    
 plt.xticks([1,5,10,15,20,24],filterData['日期'].values[[0,4,9,14,19,23]])
    
  
    
 plt.rcParams['font.sans-serif'] == 'SimHei'
    
 plt.title('D02,D03上车人数走势图')
    
 plt.xlabel('日期')
    
 plt.ylabel('人数')
    
 plt.legend(['D02','D03'])
    
 plt.show()

 import pandas as pd

    
 import numpy as np
    
 #数据填充前
    
 c = np.array([[1,2,3,4,],[4,5,6,np.nan],[5,6,7,8],[9,4,np.nan,0]])
    
 C= pd.DataFrame(c)
    
 C

 #1导入数据预处理需要的填充模块Imputer

    
 from sklearn.preprocessing import Imputer

 #2利用Imputer创建填充对象imp

    
 imp = Imputer(missing_values = 'NaN',strategy = 'mean',axis=0)
    
 #3调用imp中的fit()拟合方法，对待填充数据进行拟合训练
    
 imp.fit(C)
    
 #4调用imp中的transform方法，返回填充后的数据集
    
 tc = imp.transform(C)
    
 tc

 b = np.array([[1,999999,3,4,],[4,5,6,np.nan],[5,66666666,7,8],[9,4,np.nan,0]])

    
 B= pd.DataFrame(b)
    
 B

 #1进行规范化之前需要填充处理

    
 imp1 = Imputer(missing_values= np.nan,strategy='median',axis=1)
    
 imp1.fit(B)
    
 tB = imp1.transform(B)

 X = tB

    
 #2导入均值-方差规范化处理模块
    
 from sklearn.preprocessing import StandardScaler
    
 #3利用StandardScalar创建均值—方差规范化对象scaler
    
 scalar = StandardScaler()
    
 #4调用scalar对象中的fit拟合方法 对数据就行拟合训练
    
 scalar.fit(X)
    
 #5transform返回规范后的数据集
    
 tX = scalar.transform(X)
    
 tX

 X1 = tB

    
 from sklearn.preprocessing import MinMaxScaler
    
 min_max_Scalar = MinMaxScaler()
    
 min_max_Scalar.fit(X1)
    
 min_max_Scalar.transform(X1)

 #首先要进行数据预处理

    
 X = data.iloc[:,1:]
    
  
    
 #1空值填充
    
 #①导入数据预处理需要的填充模块Imputer
    
 from sklearn.preprocessing import Imputer
    
 #②利用Imputer创建填充对象imp
    
 imp = Imputer(missing_values = 'NaN',strategy = 'median',axis=0)
    
 #③调用imp中的fit()拟合方法，对待填充数据进行拟合训练
    
 imp.fit(X)
    
 #④调用imp中的transform方法，返回填充后的数据集
    
 tc = imp.transform(X)
    
 tc

 #2进行数据规范化

    
 X1 = tc
    
 from sklearn.preprocessing import MinMaxScaler
    
 min_max_Scalar = MinMaxScaler()
    
 min_max_Scalar.fit(X1)
    
 X1=min_max_Scalar.transform(X1)
    
 X1

 #对标准化后的X1做主成分分析

    
 #①导入主成分分析模块PCA
    
 from sklearn.decomposition import PCA
    
 #②利用PCA创建主成分分析对象pca 设置累计贡献率在95%以上
    
 pca = PCA(n_components=0.95)
    
 #③调用pca中的fit()拟合方法，对待填充数据进行拟合训练
    
 pca.fit(X1)
    
 #④调用pca中的transform方法，返回提取的主成分
    
 Y= pca.transform(X1)
    
 Y

 #⑤返回pca对象属性

    
 # 特征向量
    
 tzxl  = pca.components_
    
 #特征值
    
 tzz = pca.explained_variance_
    
 #返回主成分方差百分比（贡献率）
    
 gxl = pca.explained_variance_ratio_
    
 #主成分表达式及验证
    
 Y00 = sum(X1[0,:]*tzxl[0,:])
    
 Y01 = sum(X1[1,:]*tzxl[0,:])
    
 Y02 = sum(X1[2,:]*tzxl[0,:])
    
 Y03 = sum(X1[3,:]*tzxl[0,:])

 #综合得分 = 各个主成分X贡献率之和

    
 F=gxl[0]*Y[:,0]+gxl[1]*Y[:,1]+gxl[2]*Y[:,2]
    
 dq=list(data['地区'].values)  #提取地区
    
 Rs=pd.Series(F,index=dq)           #以地区作为index，综合得分为值，构建序列
    
 Rs=Rs.sort_values(ascending=False) #按综合得分降序进行排序
    
 pd.DataFrame(Rs,columns=['综合得分'])

 #综合得分 = 各个主成分X贡献率之和

    
 F=gxl[0]*Y[:,0]+gxl[1]*Y[:,1]+gxl[2]*Y[:,2]
    
 dq=list(data['地区'].values)  #提取地区
    
 Rs=pd.Series(F,index=dq)           #以地区作为index，综合得分为值，构建序列
    
 Rs=Rs.sort_values(ascending=False) #按综合得分降序进行排序
    
 pd.DataFrame(Rs,columns=['综合得分'])

 import pandas as pd

    
 data = pd.read_excel('发电场数据.xlsx')
    
  
    
 #1线性回归分析
    
 #①确定自变量x和因变量y
    
 x = data.iloc[:,0:4]  #x = data.iloc[:,0:4].as_matrix
    
 y = data.iloc[:,4]
    
  
    
 #②导入线性回归模块
    
 from sklearn.linear_model import LinearRegression as LR
    
  
    
 #③创建线性回归对象lr
    
 lr = LR()
    
 #④调用lr对象中的fit()方法 对数据进行拟合训练
    
 lr.fit(x,y)
    
  
    
 #⑤调用lr对象中的score()方法，返回其拟合优度（判定系数），观察其线性关系是否显著
    
 Rlr = lr.score(x,y)#判定系数R^2
    
  
    
 #⑥取lr对象中的coef_,intercept_属性，返回x对应的回归系数和回归系数常数项
    
 c_x = lr.coef_      #lr对象中的coef_属性
    
 c_b = lr.intercept_ #lr对象中的intercept_
    
  
    
 #2利用线性回归模型进行预测
    
 #⑦预测
    
 #方法①：利用lr对象中的predict()方法进行预测
    
 import numpy as np
    
 rx = np.array([11,22,33.3,55.5]).reshape(1,4)
    
 #方法②：利用线性回归方程进行预测
    
 r1 = x1*c_x
    
 R2 = r1.sum()+c_b