##encoding=utf-8
'''
scikit-learn 是基于python的数据挖掘建模和机器学习的工具包
可以非常方便的实现分类、回归、降维等数据挖掘和机器学习的常用的操作
是基于python的高级数据分析中非常重要的工具包
官网：http://scikit-learn.org/
也是开源软件，可以在github上找到开源的代码
Github：https://github.com/scikit-learn/scikit-learn

1、机器学习与决策树Machine learning&Decision Tree
2、scikit-learn实现决策树Realizing Decision Tree

机器学习
权威解释：计算机程序如何随着经验积累自动提高性能
实际上，机器学习模拟的是人的学习，人做出决定的时候是基于以往的经验
机器的经验是历史数据，本质是函数
例如：垃圾邮件检测
是否群发或者邮件内容是否包含链接是判断是否是垃圾邮件的重要因子，我们事先告诉机器哪些是垃圾邮件哪些不是
基于我们定义的属性以及定义需要用到的数据，就可以得到一个判断邮件是否是垃圾邮件的模型
下次输入参数的时候，机器可以根据训练好的模型（或者可以称为一个函数）作出判断
这其中最基础的就是数据，对做决定起着最重要的关键作用的就是机器学习算法

机器学习：因子----》结果
结果：不打标记----》无监督学习（例如：对植物的分类，不知道属性是什么，只是简单的聚类）
       打标记----》监督学习（例如垃圾邮件检测，我们会告诉机器到底是不是垃圾邮件，需要打标记）
                       如果打标记的数据结果是有限离散的----》分类算法
                       如果打标机的数据结果是连续的----》回归算法
决策树：监督学习  树形结构     
         每个内部节点表示一个属性上的测试，每个分支代表一个测试输出，每个叶节点代表一种类别
         例如是否出去玩，天气是sunny有2个出去玩3个不出去玩，如果是rain有3个出去玩2个不出去玩，如果晴天的情况下再看湿度
              可以利用信息熵的概念H(U)=E[-logpi]，所有概率*log概率的和结果取负值
              把原始数据集分类成几部分之后可以得到新的信息熵，叶子信息熵=本节点算法*（叶子实例集个数占上节点总个数的比值）
              叶子信息熵和上节点信息熵差值最大的当做判断条件

'''
#scikit-learn 实现决策树

# Iris数据集，多重变量数据集
# 1、花萼长度；2花萼宽度；3、花瓣长度；4、花瓣宽度；通过这四种属性判断出鸢尾属于哪个种类
# 5、种类：Iris Setosa（山鸢尾）、Iris Versicolour（杂色鸢尾）、Virginica（维吉尼亚鸢尾）
#数据挖掘和机器学习大致分为三个步骤：1数据预处理2数据建模3结果验证

import numpy as np
import pandas as pd
def main():
    #Pre-processing
    from sklearn.datasets import load_iris
    iris=load_iris()
    print(iris)#结果有个data属性就是四种属性值共150个值，target是标注共三类
    print(len(iris["data"]))#数据预处理有很多种，比如降维处理，由于鸢尾数据比较规则，所以只进行一步
    from sklearn.cross_validation import train_test_split
    train_data,test_data,train_target,test_target=train_test_split(iris.data,iris.target,test_size=0.2,random_state=1)
    #把数据分为验证数据和测试数据，比例是test_size设置为0.2，即验证数据集占整体20%，random_state=1表示随机的选择
    #上面表示预处理结束，下面进行建模
    #Model
    from sklearn import tree#引入决策树
    clf=tree.DecisionTreeClassifier(criterion="entropy")#建立一个决策树分类器，标准选择entropy
    clf.fit(train_data,train_target)#用训练集进行训练，用train_data和train_target建立了一种决策树关系
    y_pred=clf.predict(test_data)#用test_data进行预测
    #sklearn大多数的模型都会有fit（表示建立模型）和predict（表示预测）结构
    #下面开始验证
    #Verify 用两种方法进行验证1准确率2混淆矩阵
    from sklearn import metrics
    print(metrics.accuracy_score(y_true=test_target,y_pred=y_pred))#得结果96.6%表示准确率比较高
    #y_true表示真实的值，y_pred右边录入预测值
    print(metrics.confusion_matrix(y_true=test_target,y_pred=y_pred))
    #混淆矩阵的横轴表示实际值，纵轴表示预测值，最理想情况下是对角矩阵，两边都是0

    #决策树可以直接输出到文件
    with open("./data/tree.dot","w") as fw:
        tree.export_graphviz(clf,out_file=fw)

if __name__=='__main__':
    main()

#encoding=utf-8
'''
pandas 数据分析库
是为了解决数据分析任务而创建的一种基于numpy的工具
纳入了大量的库和一些标准的数据模型，提供了非常高效的操作大型数据集的方法，提供了大量使我们快速的便捷的处理数据的函数
使得python成为广泛使用的高效的数据环境
官网：http://pandas.pydata.org

'''
import numpy as np
import pandas as pd

from pylab import *
def main():
    # 1、pandas基础数据结构Series & DataFrame
    s=pd.Series([i*2 for i in range(1,11)])#series是pandas当中一个基本的数据结构，填入数组1~10
    print(type(s))#得<class 'pandas.core.series.Series'>
    dates=pd.date_range("20170301",periods=8)#periods表示8天，下面是第二个数据结构，dataframe
    df=pd.DataFrame(np.random.randn(8,5),index=dates,columns=list("ABCDE"))
    #定义8行5列随机数，index是主键（索引），columns表示属性命名，这里list将字符串序列化可以得到一个数组
    print(df)
    #dataframe还有下面这种定义方式，分别定义各个属性的值
    # df=pd.DataFrame({"A":1,"B":pd.Timestamp("20170301"),"C":pd.Series(1,index=list(range(4)),dtype="float32"),\
    #     "D":np.array([3]*4,dtype="float32"),"E":pd.Categorical(["police","student","teacher","doctor"])})
    # print(df)
    #2、pandas基本操作Basic & Select & Set
    #basic
    print(df.head(3))#head就是打印出前几行
    print(df.tail(3))#tail就是打印出后几行
    print(df.index)#可以直接打印出dataframe的index
    print(df.values)#values已经是数组了
    print(df.T)  # 矩阵转置
    #print(df.sort(columns="C"))  # 排序,可以针对某一列进行排序，升序，index也变了
    print(df.sort_index(axis=1,ascending=False))  # axis=1表示通过属性值进行排序，ascending=False表示进行 降序
    print(df.describe())  # 打印出所有属性值的数量，可大致了解数据
    #select
    print("下面开始学select")
    print(type(df["A"]))  #得<class 'pandas.core.series.Series'>，dataframe由各个series组成的，series是dataframe的一个特例，所以操作通用
    print(df[:3])  # 数组中可以直接这么用，dataframe也可以用下标进行切片
    print(df["20170301":"20170304"])  #用index进行切片
    print(df.loc[dates[0]])#更为通用的可以用loc函数进行处理
    print(df.loc["20170301":"20170304",["B","D"]])#进行多维度的进行选择，取20170301到20170304的数据且B列到D列的数据
    print(df.at[dates[0],"C"])#也可以通过at指定特定的一个值
    #print(df.at[20170301,"C"]) 但这样写不行

    print("上面通过索引进行选择，下面通过下标进行选择")#通过命令iloc
    print(df.iloc[1:3,2:4])#1到3行且2到4列，左包含右不包含
    print(df.iloc[1,4])#指定一个
    print(df.iat[1, 4])
    print("有条件语句")
    print(df[df.B>0][df.A<0])#注意这里是df.B不能直接写成B
    print(df[df> 0])#表里>0的元素直接返回数，<0的元素返回NaN
    print(df[df["E"].isin([1,2])])#表示数值是不是在后面的范围里，因为表里都是浮点数，所以应该返回空即Index: []

    #set
    print("对dataframe属性进行设置修改")
    s1=pd.Series(list(range(10,18)),index=pd.date_range("20170301",periods=8))
    df["F"]=s1
    print(df)#可得新加了属性F一列
    df.at[dates[0],"A"]=0
    print(df)
    df.iat[1,1]=1
    df.loc[:,"D"]=np.array([4]*len(df))#D列全赋成4，这里需要添加一个数组
    print(df)
    df2=df.copy()
    df2[df2>0]=-df2#把所有>0的数变成负的，于是表里所有数都变成负数了
    print(df2)

    #3、pandas缺失值处理Missing Data Processing

    #Missing Values
    print("Missing Values")
    df1=df.reindex(index=dates[:4],columns=list("ABCD")+["G"])
    #定义的df1取df的前四行，columns取ABCD列且加一个G列
    df1.loc[dates[0]:dates[1],"G"]=1#给G列的第一行第二行进行赋值成1
    print(df1)#其中有NaN值，也就是所谓空值
    #缺失的处理方式有两种，一种是直接丢弃，另一种是进行填充，包括填充固定值以及插值（可参考scipy中插值算法）
    print(df1.dropna())#带有NaN的两行数据没了
    print(df1.fillna(value=2))

    #4、pandas表统计与整合 数据融合和形状定义Merge&Reshape
    #Statistic
    print("统计方面的应用")
    print(df.mean())#求所有属性的均值，返回结果的属性就是series
    print(df.var())  #求方差
    s=pd.Series([1,2,4,np.nan,5,7,9,10],index=dates)
    print(s)
    print(s.shift(2))#把所有的值移位2个，而后面的值不会补到前面，前面的值为NaN
    print(s.diff())#不填数字表示一阶，递减的结果，第一个数字前面没有，所以减去的结果是NaN
    print(s.value_counts())#每一个值在series当中出现的次数，绘制直方图比较方便
    print(df.apply(np.cumsum))#通过apply直接填入函数，cumsum表示后面所有的值都是前面的累加值，参考D列
    print(df.apply(lambda x:x.max()-x.min()))#还可以自定义函数，打印每个属性的最大值和最小值的差，即极差


    #Concat
    print("表格拼接和类sql的操作")
    pieces=[df[:3],df[-3:]]
    print(pd.concat(pieces))#拼接df的前三行和df的后三行
    left=pd.DataFrame({"key":["x","y"],"value":[1,2]})#key和value是两个属性
    right=pd.DataFrame({"key":["x","z"],"value":[3,4]})
    print("LEFT:",left)
    print("RIGHT:",right)
    print(pd.merge(left,right,on="key",how="left"))#类似sql中的join函数
    # 保留了左边的x和y，根据key属性拼接，拼接方式how是left，默认为inner会去掉所有不同的，也可以是outer，所有值都会有
    df3=pd.DataFrame({"A":["a","b","c","b"],"B":list(range(4))})
    print(df3.groupby("A").sum())#按照A属性分类，将B聚合

    #Reshape
    print("透视功能，交叉分析，透视表")
    import datetime
    df4=pd.DataFrame({'A':['one','one','two','three']*6,#这表格有24行
                      'B':['a','b','c']*8,
                      'C':['foo','foo','foo','bar','bar','bar']*4,
                      'D':np.random.randn(24),
                      'E':np.random.randn(24),
                      'F':[datetime.datetime(2017,i,1) for i in range(1,13)]+#F属性元素都是拼接来的
                          [datetime.datetime(2017, i, 15) for i in range(1, 13)]})
    print(pd.pivot_table(df4,values="D",index=["A","B"],columns=["C"]))#透视交叉表的命令是pivot_table
    #对df4进行操作，输出值是D，赋值项是A和B，列值是C，F没用到即为空

    #5、pandas时间序列、图形绘制和文件操作Time Series & Graph & Files
    #Time Series
    print("时间序列")
    t_exam=pd.date_range("20170301",periods=10,freq="S")#periods定义有多少个时间段，freq参数定义为s表示秒
    print(t_exam)

    #Graph
    print("绘图功能")#除了用matplotlib实现，pandas可自己实现画图
    ts=pd.Series(np.random.randn(1000),index=pd.date_range("20170301",periods=1000))
    ts=ts.cumsum()
    ts.plot()
    show()

    #File
    print("文件操作")
    df6=pd.read_csv("./data/test.csv")
    print("Csv",df6)
    df7 = pd.read_excel("./data/test.xlsx","Sheet1")
    print("Excel",df7)
    df6.to_csv("./data/test2.csv")
    df7.to_excel("./data/test2.xlsx")


if __name__=='__main__':
    main()

#encoding=utf-8
'''
因为python的数据类型比较灵活，[]内可以放下各种，但每次计算前先要判断所以速度较慢
numpy中可以把list内容指定为某一种数据类型，所以比较快
'''

import numpy as np
from numpy.linalg import *

def main():
    lst = [[1, 3, 5], [2, 4, 6]]
    print(type(lst))
    np_lst=np.array(list)
    print(type(np_lst))
    np_lst=np.array(lst,dtype=np.float)#属性dtype可指定元素唯一的类型
    #bool,int,int8,int16,int32,int64,int128,uint8,uint16,uint32,uint64,uint128,float,float16/32/64,complex64/128,str等
    # 其中uint是不带符号数,complex是复数
    print(np_lst.shape)#得（2L，3L），表示2行3列
    print(np_lst.ndim)#得2，表示维度
    print(np_lst.dtype)#得float64，因为float默认是64位的
    print(np_lst.itemsize)#得8，因为float64占8个字节
    print(np_lst.size)#得6，因为一共有6个元素

 #2 numpy常用Array
    print(np.zeros([2, 4]))#得2行4列的元素都是0的矩阵，常用作初始化
    print(np.ones([3, 5]))#得3行5列的元素都是1的矩阵
    print("Rand:")
    print(np.random.rand(2,4))#得2行4列随机数矩阵，这里的随机数都是均匀分布的，0~1之间的
    print(np.random.rand())#得一个随机数
    print("RandInt:")#得一个随机的整数，
    print(np.random.randint(1,10,3))#参数不能为空，齐总1,10表范围 第三个参数表示个数
    print("Randn:")#得一个标准正态分布的随机数
    print(np.random.randn(2,4))#得一个2行4列的正态分布的随机数矩阵
    print("Choice:")#得一个在可选范围内的随机
    print(np.random.choice([10,20,30]))#在10,20,30这三个数中随机选择一个数
    print("Distribute:")#可以得各种分布的数，比如下面
    print(np.random.beta(1,10,100))#得alpha=1，beta=10的Beta分布的0到1之间的数字100个

#3 numpy常用操作
    print(np.arange(1,11).reshape([2,-1]))#得1到11（含1不含11）的等差数列，reshape为2行5列（其中5可缺省为-1）
    lst=np.arange(1,11).reshape([2,-1])
    print("Exp:")
    print(np.exp(lst))#得e指数操作的结果，lst每个元素为幂指数
    print("Exp2:")
    print(np.exp2(lst))#得2的指数操作的结果，lst每个元素为幂指数
    print("Sqrt:")
    print(np.sqrt(lst))#得对lst每个元素进行开平方的结果
    print("Sin:")
    print(np.sin(lst))#得对lst每个元素进行三角函数的结果
    print("Log:")
    print(np.log(lst))#得对lst每个元素进行对数的结果
    lst=np.array([[[1,2,3,4],
                   [4,5,6,7]],
                  [[7,8,9,10],
                   [10,11,12,13]],
                  [[14,15,16,17],
                   [18,19,20,21]]])
    print("Sum")
    print(lst.sum(axis=0))#axis与数组维度有关系，不写axis时候默认不分维度所有元素相加的和
                          #axis=0是只对最外层数组（即分成3个数组的相应元素的算法）进行sun操作,结果为[[22 25 28 31] [32 35 38 41]]其中1+7+14=22；2+8+15=25
    print(lst.sum(axis=1))#axis=1是再进一层（即分成两个数组相应元素的算法），结果为[[ 5  7  9 11] [17 19 21 23] [32 34 36 38]] 其中1+4=5；2+5=7
    print(lst.sum(axis=2))#axis=2是再再进一层，结果为[[10 22] [34 46] [62 78]]其中1+2+3+4=10；4+5+6+7=22
    print("Max")
    print(lst.max(axis=1))#axis与数组维度有关系，不写axis时候默认不分维度所有元素的最大值
                          #axis=0,1,2含义和上面类似
    print("Min")
    print(lst.min(axis=0))
    lst1= np.array([10,20,30,40])
    lst2= np.array([4, 3, 2, 1])
    print("Add")
    print(lst1 + lst2)#得[14 23 32 41]
    print("Sub")
    print(lst1 - lst2)  # 得[ 6 17 28 39]
    print("Mul")
    print(lst1 * lst2)  # 得[40 60 60 40]
    print("Div")
    print(lst1 / lst2)  # 得[  2.5   6.66666667  15.  40.  ]
    print("Square")
    print(lst1**2)  # 得[ 100  400  900 1600]
    print("Dot")#点乘，即矩阵相乘，a矩阵的第一行元素分别乘以b矩阵的第一列元素 的和为结果的第一行第一列的一个元素
    print(np.dot(lst1.reshape([2,2]),lst2.reshape([2,2])))  # 得[[ 80  50] [200 130]]即80=10*4+2*2
    print("Concatenate")#给numpy中的array元素追加
    print(np.concatenate((lst1,lst2),axis=0))  # 得[10 20 30 40  4  3  2  1]
    print("Vstack")  # 给numpy中的array元素纵向追加
    print(np.vstack((lst1,lst2)))#得[[10 20 30 40] [ 4  3  2  1]]
    print("Hstack")  # 给numpy中的array元素横向追加
    print(np.hstack((lst1, lst2)))#得[10 20 30 40  4  3  2  1]
    print("Split")  # 给numpy中的array元素分开
    print(np.split(lst1,2))#分成2份，得[array([10, 20]), array([30, 40])]
    print("Copy")  # 给numpy中的array进行拷贝
    print(np.copy(lst1))

#4 numpy矩阵操作与线性方程组liner
    print("Eye")#线性代数中的单位矩阵
    print(np.eye(3))#得[[ 1.  0.  0.][ 0.  1.  0.][ 0.  0.  1.]]
    lst=np.array([[1,2],[3,4]])
    print("Inv:")#矩阵的逆，AB=BA=E ，则我们称B是A的逆矩阵
    print(inv(lst))#得[[-2.   1. ]  [ 1.5 -0.5]]
    print("T:")  # 转置矩阵，将矩阵的行列互换得到的新矩阵称为转置矩阵
    print(lst.transpose())  # 得[[1 3] [2 4]]
    print("Det:")  #求行列式,定义域为det的矩阵A，取值为一个标量，写作det(A)或 | A |
    print(det(lst))  # 得-2.0=1*4-2*3(仅对应二阶)
    print("Eig")  # 特征值（第一个array）和特征向量（第二个array）
    print(eig(lst))  # 得(array([-0.37228132,  5.37228132]), array([[-0.82456484, -0.41597356],[ 0.56576746, -0.90937671]]))
    y=np.array([[5.],[7.]])
    print("Solve")#可以用numpy直接解方程组x+2y=5；3x+4y=7
    print(solve(lst,y))#得[[-3.] [ 4.]]

#5 numpy其它应用简介
    print("FFT:")  # 快速傅里叶变换 (fast Fourier transform),信号处理领域常用到的一个概念
    print(np.fft.fft(np.array([1,1,1,1,1,1,1,1])))  # 得[ 8.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
    print("Coef:")  # 皮尔逊相关系数( Pearson correlation coefficient）是数据领域中常用到的系数
                    # 在统计学中，用于度量两个变量X和Y之间的相关（线性相关），其值介于-1与1之间。
    print(np.corrcoef([1,0,1],[0,2,1]))#得[[ 1.  -0.8660254] [-0.8660254  1.]]
    print("Poly:")#生成一元多次函数
    print(np.poly1d([2,1,3]))#得2 x的2次 + 1 x + 3

    #登陆官网查更加细致的api

if __name__=='__main__':
    main()

#encoding=utf-8
'''
scipy函数库是numpy基础上增加了众多数学、科学以及工程计算常用的库函数
例如线性代数、常微分方程、信号处理、图像处理，稀疏矩阵等
关键字：数据计算库
官网：https://www.scipy.org/
'''
import numpy as np
from pylab import *#引入一个绘图模块，是matplotlib的常用函数

def main():

#1- scipy积分 Integral
    from scipy.integrate import quad,dblquad,nquad
    #quad是积分模块,nquad表示n维积分
    #在数学分析中，给定函数的定积分的计算不总是可行的
    #数值积分是利用黎曼积分等数学定义，用数值逼近的方法近似计算给定的定积分值。
    print(quad(lambda x:np.exp(-x),0,np.inf))#用quad定义一个lambda函数，exp指对数，x范围是从0到无穷大
    #得(1.0000000000000002, 5.842607038578007e-11) 数值积分是计算出一个值和一个误差，最终的值在前面结果+—右边范围之间
    print(dblquad(lambda t,x:np.exp(-x*t)/t**3,0,np.inf,lambda x:1,lambda x:np.inf))
    #先定义t的取值范围可以用常数表示，再定义x的取值范围因为x相当于是t的函数，所以用函数定义
    #得结果(0.3333333333366853, 1.3888461883425516e-08)
    def f(x,y):#定义一个函数
        return x*y
    def bound_y():#定义y的取值范围
        return [0,0.5]
    def bound_x(y):#定义x的边界，由y得到的范围
        return [0,1-2*y]
    print(nquad(f,[bound_x,bound_y]))#得值得取值范围(0.010416666666666668, 4.101620128472366e-16)
#scipy优化器Optimizer
    from scipy.optimize import minimize#引入一个计算最小值的模块
    def rosen(x):
        return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0+(1-x[:-1])**2.0)
    x0=np.array([1.3,0.7,0.8,1.9,1.2])  #想用optimizer算法的话需要
    res=minimize(rosen,x0,method="nelder-mead",options={"xtol":1e-8,"disp":True})
    #计算rosen的最小值，method使用的nelder-mead算法，以动5个点为基础，不断地去掉得到最高的点，然后优化成最小值
    #xtol表示精度，disp：True表示显示中间过程

    print("ROSE MINI:",res)#打印出结果和中间过程
    print("ROSE MINI:",res.x)#打印出属性

    #求在约束条件下目标函数的最小值
    def func(x):#这里x可以是任何参数
        return -(2*x[0]*x[1]+2*x[0]-x[0]**2-2*x[1]**2)
    def func_deriv(x):#表示定义的原函数即目标函数相对于x和相对于y的颠倒数
        dfdx0=-(-2*x[0]+2*x[1]+2)#相对于x的倒数
        dfdx1=-(2*x[0]-4*x[1])#相对于y的倒数
        return np.array([dfdx0,dfdx1])
    #下面定义一个约束条件，分别是相等于0，jac表示求偏导，直接给出偏导式而不是计算机计算可以提高计算速度
    cons=({"type":"eq","fun":lambda x:np.array([x[0]**3-x[1]]),"jac":lambda x:np.array([3.0*(x[0]**2.0),-1.0])},
         {'type':'ineq','fun':lambda x:np.array([x[1]-1]),'jac':lambda x:np.array([0.0,1.0])})
    res=minimize(func,[-1.0,1.0],jac=func_deriv,constraints=cons,method='SLSQP',options={'disp':True})
    #目标函数func，取值范围-1到1，jac表示雅克比行列式，constraints表示约束条件，method表示方法，disp:True表示显示中间过程
    print("RESTRICT:",res)#在x: array([ 1.00000009,  1.])的时候取到最小值
    #还可以用优化器求根
    from scipy.optimize import root
    def fun(x):
        return x+2*np.cos(x)
    sol=root(fun,0.1)#指定初值0.1，求根
    print("ROOT:",sol.x,sol.fun)#得结果x:array([ 1.00000009,1. ])   ROOT: [-1.02986653] [ 0.]
    
#scipy插值Interpolation
    x=np.linspace(0,1,10)#定义10个数
    y=np.sin(2*np.pi*x)
    from scipy.interpolate import interp1d#引入插值算法，以一维插值为例
    li=interp1d(x,y,kind="cubic")#如果不写任何函数则以线性函数插值，kind=cubic表示三次函数插值
    x_new=np.linspace(0,1,50)#定义50个数
    y_new=li(x_new)#l插值算法返回的是函数，输入自变量可得算法的值
    figure()#画出来
    plot(x,y,"r")#用红色表示原数据,因为只有十个数显得比较折线
    plot(x_new,y_new,"k")#用黑色表示新的数据，因为插入新的数，所以线平滑了很多
    show()
    print(y_new)


#scipy线性计算与矩阵分解 Linear
    from scipy import linalg as lg
    arr=np.array([[1,2],[3,4]])
    print("Det:",lg.det(arr))#计算行列式，得-2.0
    print("Inv:",lg.inv(arr))#计算幂矩阵，得Inv: [[-2.   1. ] [ 1.5 -0.5]]
    b=np.array([6,14])
    print("Sol:",lg.solve(arr,b))#用scipy解线性方程组的，左边是未知数的因子，右边是相等的值，得 [ 2.  2.]
    print("Eig:",lg.eig(arr))#计算特征值，得(array([-0.37228132+0.j,  5.37228132+0.j]), array([[-0.82456484, -0.41597356], [ 0.56576746, -0.90937671]]))
    print("LU:",lg.lu(arr))#用scipy进行矩阵分解，得(array([[ 0.,  1.],       [ 1.,  0.]]), array([[ 1.        ,  0.        ],[ 0.33333333,  1.        ]]), array([[ 3.        ,  4.        ],       [ 0.        ,  0.66666667]]))
    print("QR:",lg.qr(arr))#QR分解，得(array([[-0.31622777, -0.9486833 ], [-0.9486833 ,  0.31622777]]), array([[-3.16227766, -4.42718872],[ 0.        , -0.63245553]]))
    print("SVD:",lg.svd(arr))#奇异值分解，得(array([[-0.40455358, -0.9145143 ],[-0.9145143 ,  0.40455358]]), array([ 5.4649857 ,  0.36596619]), array([[-0.57604844, -0.81741556],[ 0.81741556, -0.57604844]]))
    print("Schur:", lg.schur(arr))#Schur分解，得(array([[-0.37228132, -1.  ], [ 0.        ,  5.37228132]]), array([[-0.82456484, -0.56576746],       [ 0.56576746, -0.82456484]]))

#scipy的学习方法
    '''
    官网：https://www.scipy.org/--->Documentation--->Scipy的
    Tutorial里面有一些单元
    比如基本的函数，特殊的函数，积分，优化器，插值，fft，信号处理包括滤波器的设计，线性矩阵，稀疏矩阵稀疏图，空间坐标器，统计功能，图形处理功能，子文件处理功能
    Api接口
    
    
    '''




if __name__=='__main__':
    main()

python数据分析：

              numpy：数据结构基础

              scipy：强大的科学计算方法（矩阵分析，信号分析，数理分析....）

              matplotlib：丰富的可视化套件

              pandas：基础数据分析套件

              scikit-learn：强大的数据分析建模库

              keras：人工神经网络

#encoding=utf-8
'''
matplotlib就是一个绘图库
官网：http://matplotlib.org/
'''
import numpy as np
import matplotlib.pyplot as plt #用此来绘制一条线

def main():

    '''
# 1 基本线图绘制line
    x = np.linspace(-np.pi, np.pi, 256, endpoint=True)#定义一个横轴，类似matlab
                    #定义在-pi到pi之间有256个点，endpoint定义是否包含最后一个点
    c,s=np.cos(x),np.sin(x)#定义一个余弦函数c，定义一个正弦函数s
    plt.figure(1)#指定第一个图
    # plt.plot(x,c)#进行绘图,定义自变量x，因变量c
    # plt.plot(x,s)#进行绘图,定义自变量x，因变量c
    # plt.show()#可以显示简单的余弦函数和正弦函数
    plt.plot(x,c,color="blue",linewidth=1.0,line,label="COS",alpha=0.5)#加其他属性，修改线型
    #color指定颜色blue，linewidth指定线宽为1.0，linestyle指定线型是直线，加一个label,alpha指定透明度
    plt.plot(x,s,"r*",label="SIN")
    #用另一种方式指定线型属性，r表示红色，*表示线型是星，再加个label
    plt.title("COS & SIN")  # 加一些东西，定义一个标题
    #此时界面上除了正弦反弦函数还有四条直线
    #如果想加横轴纵轴，先把两条线隐藏另外两条线放到中间即可
    ax=plt.gca()#gca()就是轴的编辑器
    ax.spines["right"].set_color("none")#spines就是四条直线
    ax.spines["top"].set_color("none")#“none”表示隐藏
    ax.spines["left"].set_position(("data",0))#放到数据域的0位置
    ax.spines["bottom"].set_position(("data",0))
    ax.xaxis.set_ticks_position("bottom")#指定xaxis的位置，在横轴的下面
    ax.yaxis.set_ticks_position("left")#指定yaxia的位置，在纵轴的左边
    plt.xticks([-np.pi, -np.pi / 2, 0, np.pi / 2, np.pi], [r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])
    #设置横轴，需要两个数组，第一个数组指定横轴需要标识的位置，第二个数组指定横轴标识的内容（写成pi字符）
    plt.yticks(np.linspace(-1, 1, 5, endpoint=True))#直接给y轴标数字
    #下面可以设置横纵轴标识符的大小
    for label in ax.get_xticklabels()+ax.get_yticklabels():#得到所有横轴和纵轴的坐标标识
        label.set_fontsize(16)#设置标识符字大小
        label.set_bbox(dict(facecolor="white",edgecolor="None",alpha=0.2))#设置label小方块格式，也横纵坐标标识符小方块格式
                    #facecolor是背景颜色，edgecolor是边缘颜色，alpha透明度
    plt.legend(loc="upper left")#指定legend位置，也就是图例偏上偏左
    plt.grid()#打印出网格线
    # plt.axis([-1,1,-0.5,1]) #指定显示范围
    #前面两个指定横轴最小最大，后面两个指定纵轴最小最大

    #接下来是一些有意思的功能
    plt.fill_between(x,np.abs(x)<0.5,c,c>0.5,color="green",alpha=0.25)#填充功能
    #x表示横轴，第二个是判断型元素，真返回1，假返回0；c表示纵轴
    t=1#在t=1的地方进行注释，加条线
    plt.plot([t,t],[0,np.cos(t)],"y",linewidth=3,line)
    #“y”表示黄色，线型宽3，“--”表示虚线
    #下面给这条线加个注释
    plt.annotate("cos(1)",#画的是cos（1）
                 xy=(t,np.cos(1)),#加的点的位置
                 xycoords="data",#以被注释的坐标点xy为参考 (默认值)
                 xytext=(+10,+30),#如果不指定，注释会加到点上被覆盖住，所以有个偏移量
                 textcoords="offset points",#给偏移量指定是相对位置
                 arrowprops=dict(arrow,connection))#指定箭头类型
                                                 #这里设置箭头的属性，弧度为0.2

    plt.show()
    '''
#子图与多种图形绘制
#scatter散点图
    fig=plt.figure()
    ax=fig.add_subplot(3,3,1)#图画在了三行三列第一个位置上
    n=128
    X=np.random.normal(0,1,n)#生成随机数
    Y=np.random.normal(0,1,n)
    T=np.arctan2(Y,X)#T主要是用来上色
    #plt.axes([0.025,0.025,0.95,0.95])#如果没指定ax的显示指定范围
    ax.scatter(X,Y,s=75,c=T,alpha=.5)#用来画三点，s表示点的大小，c表示color，alpha表示透明度
    plt.xlim(-1.5,1.5),plt.xticks([])#x的范围，这里xticks设为空
    plt.xlim(-1.5,1.5),plt.yticks([])
    plt.axis()
    plt.title("scatter")
    plt.xlabel("x")
    plt.ylabel("y")
    #plt.show()

#bar条状图
    fig.add_subplot(332)#也可以这么表示三行三列第二个图，但如果分10个以上则不能这么写
    #只要加了add_subplot，接下来plt画图会在子图上，不赋值也可
    n=10#定义十个点
    X=np.arange(n)
    Y1 = (1 - X / float(n)) * np.random.uniform(0.5, 1.0, n)#随机数范围在0.5~1之间
    Y2 = (1 - X / float(n)) * np.random.uniform(0.5, 1.0, n)
    plt.bar(X,+Y1,facecolor='#9999ff',edgecolor='white')#正的Y1放在上面
    plt.bar(X, -Y2, facecolor='#ff9999', edgecolor='white')#负的Y2放在下面
    for x,y in zip(X,Y1):#给Y1添加注释,ha表示水平位置，va表示垂直位置
        plt.text(x+0.4,y+0.05,'%.2f'%y,ha='center',va='bottom')
    for x, y in zip(X, Y2):#给Y2添加注释
        plt.text(x + 0.4, - y - 0.05, '%.2f' % y, ha='center', va='top')

#Pie 饼图
    fig.add_subplot(333)
    n=20#20个不分
    Z=np.ones(n)#全1的部分
    Z[-1]*=2#最后一个设置成2
    plt.pie(Z,#数组传进去代表每一块的值
            explode=Z*.05,#每一个扇形与中心的距离
            colors=['%f'%(i/float(n)) for i in range(n)],#每一个都有不同的颜色，%f表示灰度颜色，这里是不同的灰度，也可用不同RGB色
            labels=['%.2f'%(i/float(n)) for i in range(n)])#每一个颜色的值打印出来
    plt.gca().set_aspect('equal')#成为一个正的圆，不然会根据跨度发生形变
    plt.xticks([]),plt.yticks([])

#polar极坐标的图
    fig.add_subplot(334,polar=True)#加上polar属性就是极值图，不然就是普通折线图
    n=20
    theta=np.arange(0.0,2*np.pi,2*np.pi/n)
    radii=10*np.random.rand(n)
    plt.polar(theta,radii)
    #plt.plot(theta,radii)#polt表示画折线

#heatmap热图
    fig.add_subplot(335)
    from matplotlib import cm
    data=np.random.rand(3,3)#定义3*3的随机数
    cmap=cm.Blues#蓝色系
    map=plt.imshow(data,
                   interpolation='nearest',#用离最近的差值方法
                   cmap=cmap,
                   aspect='auto',#指定缩放是auto
                   vmin=0,#指定cmap里最小值是0，白色
                   vmax=1)#最大值是指定的颜色Blue

#3D图
    from mpl_toolkits.mplot3d import Axes3D
    ax=fig.add_subplot(336,projection="3d")#需要指定projection是3d
    ax.scatter(1,1,3,s=100)#s表示尺寸，这里scatter也可以用plot之类的代替

#hot map 热力图
    fig.add_subplot(313)#3列一行第三个，指的横跨第三行
    def f(x,y):
        return (1-x/2+x**5+y**3)*np.exp(-x**2-y**2)
    n=256
    x=np.linspace(-3,3,n)
    y=np.linspace(-3,3,n)
    X,Y=np.meshgrid(x,y)
    plt.contourf(X,Y,f(X,Y),8,alpha=.75,cmap=plt.cm.hot)#热力图用contour，颜色用cmap指定

#保存图片
    plt.savefig("./data/fig.png")

    plt.show()#半截show（）了，就不会追加到同一个图里了

if __name__=='__main__':
    main()

numpy:数据结构基础

scipy:强大的科学计算方法

matplotlib:丰富的可视化套件

pandas:基础数据分析套件

scikit-learn:强大的数据分析建模库

keras:人工神经网络

科学计算工具：Anaconda

Python数据分析大家族

numpy：数据结构基础 number python

scipy：强大的科学计算方法（矩阵分析、信号分析、数理分析）

matplolib：丰富的可视化套件

pandas：基础数据分析套件

scikit-learn：强大的数据分析建模库

keras：人工神经网络

Python环境搭建

科学计算工具：Anaconda

import numpy as np
import pandas as pd


s = pd.Series([i * 2 for i in range(1, 11)])
print(type(s))
print(s)
dates = pd.date_range("20170301", periods=8)
df = pd.DataFrame(np.random.randn(8, 5), index=dates, columns=list("ABCDE"))
print(df["A"])
print(df[:3])  # 打印前3行
print(df["20170301":"20170302"])  # 打印对应范围的行
print(df.loc[dates[0]])  # 答应某一行
print(df.loc["20170301":"20170303", ["B", "D"]])  # 打印对应范围的行及其对应的属性值
print(df.at[dates[0], "C"])  # 打印某行某列的值
print(df.iloc[1:3])  # 打印1:3行
print(df.iloc[1:3, 2:4])  # 打印1:3行 2:4列
print(df.iat[1, 3])  # 打印1:3行
print(df[df.B > 0][df.A < 0])
print(df[df < 0.0])
print(df[df["E"].isin([1, 2])])

# set
sl = pd.Series(list(range(10, 18)), index=pd.date_range("20170301", periods=8))
df["F"] = sl  # 插入一列
print(df)
df.at[dates[0], "A"] = 0
print(df)
df.iat[1, 1] = 1
df.loc[:, "D"] = np.array([4] * len(df))
print(df)
df2 = df.copy()
df2[df2 > 0] = -df2  # 将所有正数变为负数
print(df2)

# Miss values
df1 = df.reindex(index=dates[:4], columns=list("ABCD") + ["G"])
df1.loc[dates[0]:dates[1], "G"] = 1
print(df1)
print(df1.dropna())  # 丢弃缺失
print(df1.fillna(value=2))  # 缺失值补2

# Statistic
print(df.mean())  # 平均值
print(df.var())  # 方差
ss = pd.Series([1, 2, 4, np.nan, 5, 7, 9, 10], index=dates)
print(ss)
print(ss.shift(2))  # 把所有的值移后2
print(s.diff())  # 差分，不填数字则为一阶
print(s.value_counts())  # 每个值出现的次数
print(df)
print(df.apply(np.cumsum))  # 累加
print(df.apply(lambda x: x.max() - x.min()))  # 极差

# Concat
pieces = [df[:2], df[-2:]]
print(pd.concat(pieces))  # 拼接前2行和后2行
left = pd.DataFrame({"key": ["x", "y"], "value": [1, 2]})
right = pd.DataFrame({"key": ["x", "z"], "value": [3, 4]})
print("left", left)
print("right", right)
print(pd.merge(left, right, on="key", how="right"))  # 拼接，how：拼接方式，inner(去掉缺省值，outer（保留所有缺省值
df3 = pd.DataFrame({"A": ["a", "b", "c", "b"], "B": list(range(4))})
print(df3)
print(df3.groupby("A").sum())  # 对A聚合，两个B相加

# #Reshape
import datetime

df4 = pd.DataFrame({'A': ['one', 'one', 'two', 'three'] * 6,  # 此表格共有24行

                    'B': ['a', 'b', 'c'] * 8,

                    'C': ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 4,

                    'D': np.random.randn(24),  # 随机数

                    'E': np.random.randn(24),

                    'F': [datetime.datetime(2017, i, 1) for i in range(1, 13)] +

                         [datetime.datetime(2017, i, 15) for i in range(1, 13)]})

# pivot_table透视表
print(df4)
print(pd.pivot_table(df4, values="D", index=["A", "B"], columns=["C"]))  # 输出值，输出项，列值

# time series
t_exam = pd.date_range("20170301", periods=10, freq="S")
print(t_exam)

# 画图
ts = pd.Series(np.random.randn(1000), index=pd.date_range("20170301", periods=1000))
ts = ts.cumsum()
from pylab import *
ts.plot()
show()

# 文件操作
df6= pd.read_excel("./panda.xlsx","Sheet1")
print(df6)
df6.to_csv("./panda.csv")

存存存存存

Python数据分析与展示

#encoding-utf-8

import numpy as np

import pandas as pd

# 机器学习分3个步骤：数据预处理、数据建模、结果验证

def main():

#Pre-processing 预处理

from sklearn.datasets import load_iris

iris=load_iris() #直接引入iris数据集 data：150个，分4种属性值；target标度分三类0,1,2

print(iris)

print(len(iris["data"])) #原始数据150个

from sklearn.model_selection import train_test_split

# 数字氛围、 测试数据、  验证数据、                                                    验证数据集占整个的20%，随机选择验证数据                 

train_data,test_data,train_target,test_target=train_test_split(iris.data,iris.target,test_size=0.2,random_state=1)

# Model 建模

from sklearn import tree #引入决策树

# 决策树分类器  标准=熵

clf=tree.DecisionTreeClassifier(criterion="entropy")

# fit 用训练集进行训练

clf.fit(train_data,train_target)

y_pred=clf.predict(test_data)#通过验证集进行预测

#Verify \验证：1准确率；2混淆矩阵

from sklearn import metrics

print(metrics.accuracy_score(y_true=test_target,y_pred=y_pred))

print(metrics.confusion_matrix(y_true=test_target,y_pred=y_pred))

# 决策树直接输出文件export_graphviz

with open("./data/tree.dot","w") as fw:

tree.export_graphviz(clf,out_file=fw)

if __name__=="__main__":

main()

#statistic 

print(df.mean()) #均值

print(df.var()) #方差

print("~~~~~~~~~~~~~~~~~~~~************")

s=pd.Series([1,2,2,np.nan,5,7,9,10],index=dates) #构架series

print(s)

print(s.shift(2))

print(s.diff())

print(s.value_counts()) #返回值可以用来绘制直方图

print(df.apply(np.cumsum)) #累加

print(df.apply(lambda x:x.max()-x.min())) #极差：每个属性最大值减最小值

#concat

pieces=[df[:3],df[-3:]] #用下标获取到dataframe的一部分，前三行和后三行拼接在一起

print(pd.concat(pieces))

left=pd.DataFrame({"key":["x","y"],"value":[1,2]}) #建立两个dataframe

right=pd.DataFrame({"key":["x","z"],"value":[3,4]})

print("LEFT:",left)

print("RIGHT:",right)

print(pd.merge(left,right,on="key",how="inner"))

df3=pd.DataFrame({"A":["a","b","c","b"],"B":list(range(4))})

print(df3.groupby("A").sum())

# #Reshape

import datetime

df4=pd.DataFrame({'A':['one','one','two','three']*6, #此表格共有24行

'B':['a','b','c']*8,

'C':['foo','foo','foo','bar','bar','bar']*4,

'D':np.random.randn(24), #随机数

'E':np.random.randn(24),

'F':[datetime.datetime(2017,i,1) for i in range(1,13)]+

[datetime.datetime(2017,i,15) for i in range(1,13)]})

# pivot_table透视表

print(pd.pivot_table(df4,values="D",index=["A","B"],columns=["C"]))

#4--Linear

from scipy import linalg as lg

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

print("Det:",lg.det(arr))

print("Inv:",lg.inv(arr))

b=np.array([6,14])

print("Sol:",lg.solve(arr,b)) #解线性方程组

print("Eig:",lg.eig(arr)) #特征值

print("LU:",lg.lu(arr)) #矩阵分解，lu、qr、svd、schur

print("QR:",lg.qr(arr))

print("SVD:",lg.svd(arr))

print("Schur:",lg.schur(arr))

scipy 库是 numpy 基础上增加的众多数学，科学以及工程计算常用的的库函数，例如线性代数，常微分方程，信号处理，图像处理，稀疏矩阵 等