numpy.array的数据结构只能有一种数据类型
不像list可以存放多种数据类型

keywords: 开源    数据计算扩展

functions: ndarray    多维操作    线性代数

python数据分析包

python数据分析重要的几个库：numpy、scipy、matplotlib、pandas、-scikit-learn、Keras。

开发工具：Anaconda

#coding:utf-8
import numpy as np
from pylab import *
##插值
x=np.linspace(0,1,10)
y=np.sin(2*np.pi*x)
from scipy.interpolate import interp1d
li=interp1d(x,y,kind='cubic')
x_new=np.linspace(0,1,50)
y_new=li(x_new)
figure()
plot(x,y,'r')
plot(x_new,y_new,'k')
plt.show()
print(y_new)

import numpy as np
def main():
    ##积分
    from scipy.integrate import quad,dblquad,nquad#引入积分模块
    print (quad(lambda x:np.exp(-x),0,np.inf))#0到无穷大的积分，返回的是一个值和误差
    print (dblquad(lambda t,x:np.exp(-x*t)/t**3,0,np.inf,lambda x:1,lambda x:np.inf))#二元积分,两个参数t，x，先定义t的取值范围（常数），再定义x的取值范围（相当于t的函数）

    def f(x,y):##n维积分
        return x*y
    def bound_y():#定义y的边界
        return [0,0.5]
    def boundx(y):#定义x的边界
        return [0,1-2*y]
    print (nquad(f,[boundx,bound_y]))
if __name__=='__main__':
    main()

###子图与多种图形绘制
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.scatter(X,Y,s=75,c=T,alpha=.5)
plt.xlim(-1.5,1.5),plt.xticks([])#指定x轴范围
plt.ylim(-1.5,1.5),plt.yticks([])
plt.axis()
plt.title('scatter')
plt.xlabel('x')
plt.xlabel('y')
# plt.show()


###柱状图
ax=fig.add_subplot(332)
n=10#10个点
X=np.arange(n)#
Y1=(1-X/float(n))*np.random.uniform(0.5,1.0,n)#构造0到1之间的随机数
Y2=(1-X/float(n))*np.random.uniform(0.5,1.0,n)
ax.bar(X,+Y1,facecolor='#9999ff',edgecolor='white')#+Y1就是将Y1放在上，-Y2将Y2放在下，配置柱体颜色及边缘颜色
ax.bar(X,-Y2,facecolor='#ff9999',edgecolor='white')
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):
    plt.text(x+0.4,-y-0.05,'%.2f'% y,ha='center',va='top')
plt.title('Bar')
# plt.show()


###饼图
ax=fig.add_subplot(333)
n=20
Z=np.ones(n)
Z[-1]*=2
ax.pie(Z,explode=Z*0.05,colors=['%f'%(i/float(n)) for i in range(n)],
        labels=['%.2f'%(i/float(n)) for i in range(n)])#explode表示每个扇形离中心的距离，color设置成每个扇形都有不同的颜色，这里是灰度图
plt.gca().set_aspect('equal')#设置为正圆而非椭圆，否则会随着画幅的大小发生形变
plt.xticks([])
plt.yticks([])
# plt.show()


###极坐标图
fig.add_subplot(334,polar=True)
n=20
theta=np.arange(0.0,2*np.pi,2*np.pi/n)
redii=10*np.random.rand(n)
plt.polar(theta,redii)
# plt.show()


###热力图
fig.add_subplot(335)
from matplotlib import cm
data=np.random.rand(3,3)
cmap=cm.Blues
map=plt.imshow(data,interpolation='nearest',cmap=cmap,aspect='auto',vmin=0,vmax=1)
# plt.show()


###3D图
from mpl_toolkits.mplot3d import Axes3D
ax=fig.add_subplot(336,projection='3d')
ax.scatter(1,1,3,s=100)
# plt.show()

###热区图
fig.add_subplot(313)
def f(x,y):
    return(1-x/2+x**5+y**3)*np.exp(-x**2-y**2)
n=255
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)
plt.savefig('F:\python_codes\matplotlib_exampls.png')
plt.show()

###基本线图绘制
import matplotlib.pyplot as plt
x=np.linspace(-np.pi,np.pi,256,endpoint=True)
c,s=np.cos(x),np.sin(x)
plt.figure(1)
plt.plot(x,c,color='blue',linewidth=1.0,linestyle='-',label='COS',alpha=0.5)
plt.plot(x,s,'r*',label='SIN')
plt.title=('COS&SIN')
ax=plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.spines['left'].set_position(('data',0))#左边线的位置移到数据为0的地方
ax.spines['bottom'].set_position(('data',0))#将下边线的位置移到数为0的地方
plt.legend(loc='upper left')
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)#进行绿色填充
t=1
plt.plot([t,t],[0,np.cos(t)],'y',linewidth=3,linestyle='--')#加一条与y轴平行的虚竖线
plt.annotate('cos(1)',xy=(t,np.cos(1)),xycoords='data',xytext=(+10,+30),
             textcoords='offset points',arrowprops=dict(arrowstyle='-'))#给上面那条虚竖线加（相对位置）注释
plt.show()

python数据分析：

              numpy：数据结构基础

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

              matplotlib：丰富的可视化套件

              pandas：基础数据分析套件

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

#encoding=utf-8
'''
Keras
另一种机器学习模型人工神经网络
人工神经网络有两个比较著名的框架，一个是诞生于LISA lab的Theano，一个是谷歌开源的Tensorflow
Keras是二者的高层应用API，简化了构建人工神经网络的步骤，让人工神经网络更容易实现
Windows下的Tensorflow还不是很成熟，所以接下来的实例中采用基于Theano的Keras
官网：https://keras.io/

1、人工神经网络简单介绍Neural Net
人工神经网络的是一种机器学习运算模型
计算学习的运算模型本质上来说就是构造一种映射函数，人工神经网络也不例外
从数学上可以证明，人工神经网络可以映射成所有的非线性函数
神经网络由大量的节点（或者我们可以称之为神经元）直接相互连接构成的
通过对节点的输入进行加权求和，这里的节点的输入不一定是网络的输入，这里的权值就是模型所需要训练的参数，最后通过一个非线性函数，实现对模型的非线性处理
常用的非线性函数：sigmoid、thanh、ReLU、softplus
人工神经网络一般分为输入层（Input layer）、隐含层（Hidden layer）、输出层（Output layer）
层与层之间相互连接，一般情况下同一层以内是不进行连接的，当然也有特殊情况比如RNN节点对自己进行反馈连接
一般的数据分析中，隐含层只有一层就够了，如果隐含层有很多层的就是深度学习网络（其参数计算过程与浅层神经网络的训练过程不太一样）

2、keras实现人工神经网络Keras Installation & Neural Network with Keras
Installation：因为Anaconda不自带，所以需要额外安装
1、打开Anaconda命令行prompt
2、输入命令conda install mingw libpython
3、输入命令pip install keras（windows下会先安装theano再安装keras）
然后使用pycharm运行程序一次报错No module named tensorflow
这里是因为如果使用theano下的keras需要指定
只要运行过keras就会在电脑有c:\user\电脑名字\keras\keras.jason
备份之后修改这个文件，修改两处，修改为"image_dim_ordering":"th"和"backend":"theano"，保存关掉
再运行提示用的是Theano客户端（Using Theano backend）就成功了
'''
import numpy as np
from keras.models import Sequential#Sequential可以认为是人工神经网络各个层的容器
from keras.layers import Dense,Activation#Dense表示那些求和的层，Activation就是激活函数
from keras.optimizers import SGD#这里指的是随机梯度下降算法
def main():
    from sklearn.datasets import load_iris#继续使用上一节的iris数据集
    iris=load_iris()
    #由于神经网络用的是分类器，所以需要把序列进行标签化
    print(iris["target"])#输出的结果只有三种要么0要么1要么2
    from sklearn.preprocessing import LabelBinarizer#进行标签化
    print(LabelBinarizer().fit_transform(iris["target"]))
    #下一步分成训练集和测试集，并进行标签化处理
    train_data, test_data, train_target, test_target = train_test_split(iris.data, iris.target, test_size=0.2,random_state=1)
    labels_train=LabelBinarizer().fit_transform(train_target)
    labels_test = LabelBinarizer().fit_transform(test_target)
    #下一步构建神经网络层
    model=Sequential(
        [
            Dense(5,input_dim=4),#输出有5个，输入有4个，定义四个属性值
            Activation("relu"),#激活函数是relu
            Dense(3),#下一个输入就是上一层的输出，一共5个这里可以省略了，只定义3个它的输出，这里是012三个label
            Activation("sigmoid"),#激活函数选择sigmoid
        ]
    )
    #还可以使用另一种方式定义结构,先定义一个Sequential，然后一层一层往里加也是可以的
    # model=Sequential()
    # model.add(Dense(5,input=4))

    #下面定义一个随机梯度下降算法的优化器
    sgd=SGD(lr=0.01,decay=1e-6,momentum=0.9,nesterov=True)#lr因子，decay表示远离弧长，momentum实质因子
    model.compile(optimizer=sgd,loss="categorical_crossentropy")#指定优化器optimizer，隐身函数loss
    model.fit(train_data,labels_train,nb_epoch=200,batch_size=40)#用训练数据进行训练，注意这里用的是labels_train
    #nb_epoch表示训练多少轮，batch_size表示训练一批共多少个数据
    #接下来可以预测
    print(model.predict_classes(test_data))#输入测试集

    #还可以用上一节讲到的混淆矩阵和准确率

    #模型比较大的话，参数训练可能会消耗比较多的时间，可以把这些因子存下来，以便下次再用
    model.save_weight("./data/w")#保存到指定目录
    model.load_weight("./data/w")#下一次直接读取出来

if __name__=='__main__':
    main()

##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()