Python学习_科学计算

Posted 莫失莫忘Lawlite

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python学习_科学计算相关的知识,希望对你有一定的参考价值。

Python科学计算

  • 包含Numpy、Matplotlib、Scipy、Pandas和scikit-learn

一、Numpy

1、Numpy特征和导入

  • (1)用于多维数组的第三方Python包
  • (2)更接近于底层和硬件 (高效)
  • (3)专注于科学计算 (方便)
  • (4)导入包:import numpy as np

2、list转为数组

  • (1)a = np.array([0,1,2,3])
  • (2)输出为:[0 1 2 3]
  • (3)数据类型:<type ‘numpy.ndarray‘>

3、一维数组

  • (1)a = np.array([1,2,3,4])属性
    a.ndim–>维度为1
    a.shape–>形状,返回(4,)
    len(a)–>长度,4
  • (2)访问数组
    a[1:5:2]下标1-5,下标关系+2
  • (3)逆序

    a[::-1]

4、多维数组

  • (1)二维:a = np.array([[0,1,2,3],[1,2,3,4]])
    输出为:

    [[0 1 2 3]
    [1 2 3 4]]
    a.ndm –>2
    a.shape –>(2,4)–>行数,列数
    len(a) –>2–>第一维大小

  • (2)三维:a = np.array([[[0],[1]],[[2],[4]]])
    a.shape–>(2,2,1)

5、用函数创建数组

  • (1)np.arange()

    a = np.arange(0, 10)
    b = np.arange(10)
    c = np.arange(0,10,2)
    输出:

    [0 1 2 3 4 5 6 7 8 9]
    [0 1 2 3 4 5 6 7 8 9]
    [0 2 4 6 8]

  • (2)np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
    等距离产生num个数
  • (3)np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
    以log函数取

6、常用数组

  • (1)a = np.ones((3,3))
    输出:

    [[ 1. 1. 1.]
    [ 1. 1. 1.]
    [ 1. 1. 1.]]

  • (2)np.zeros((3,3))

  • (3)np.eye(2)单位矩阵
  • (4)np.diag([1,2,3],k=0)对角矩阵,k为对角线的偏移

7、随机数矩阵

  • (1)a = np.random.rand(4)
    输出:[ 0.99890402 0.41171695 0.40725671 0.42501804]范围在[0,1]之间
  • (2)a = np.random.randn(4) Gaussian函数,
  • (3)生成100个0-m的随机数: [t for t in [np.random.randint(x-x, m) for x in range(100)]]

8、查看数据类型

  • (1)a.dtype

9、数组复制

  • (1)共享内存
    a = np.array([1,2,3,4,5])
    b = a
    print np.may_share_memory(a,b)

输出:True
说明使用的同一个存储区域,修改一个数组同时另外的也会修改
- (2)不共享内存
b = a.copy()

10、布尔型

  • (1)
    a = np.random.random_integers(0,20,5)
    print a
    print a%3==0
    print a[a % 3 == 0]

输出:
[14 3 6 15 4]
[False True True True False]
[ 3 6 15]

11、中间数、平均值

  • (1)中间数np.median(a)
  • (2)平均值np.mean(a)

12、矩阵操作

  • (1)乘积np.dot(a,b)
    a = np.array([[1,2,3],[2,3,4]])
    b = np.array([[1,2],[2,3],[2,2]])
    print np.dot(a,b)

或者使用np.matrix()生成矩阵,相乘需要满足矩阵相乘的条件
- (2)内积np.inner(a,b)
行相乘

  • (3)逆矩阵np.linalg.inv(a)
  • (4)列的最大值np.max(a[:,0])–>返回第一列的最大值
  • (5)每列的和np.sum(a,0)
  • (6)每行的平均数np.mean(a,1)
  • (7)求交集p.intersect1d(a,b),返回一维数组
  • (8)转置:np.transpose(a)
  • (9)两个矩阵对应对应元素相乘(点乘):a*b

13、文件操作

  • (1)保存:tofile()
    a = np.arange(10)
    a.shape=2,5
    a.tofile("test.bin")

读取:(需要注意指定保存的数据类型)

    a = np.fromfile("test.bin",dtype=np.int32)
    print a
  • (2)保存:np.save("test",a)–>会保存成test.npy文件
    读取:a = np.load("test")

14、组合两个数组

  • (1)垂直组合
    a = np.array([1,2,3])
    b = np.array([[1,2,3],[4,5,6]])

    c = np.vstack((b,a))
  • (2)水平组合
    a = np.array([[1,2],[3,4]])
    b = np.array([[1,2,3],[4,5,6]])

    c = np.hstack((a,b))

15、读声音Wave文件

  • (1)wave
    import wave
    from matplotlib import pyplot as plt
    import numpy as np

    # 打开WAV文档
    f = wave.open(r"c:\WINDOWS\Media\ding.wav", "rb")

    # 读取格式信息
    # (nchannels, sampwidth, framerate, nframes, comptype, compname)
    params = f.getparams()
    nchannels, sampwidth, framerate, nframes = params[:4]

    # 读取波形数据
    str_data = f.readframes(nframes)
    f.close()

    #将波形数据转换为数组
    wave_data = np.fromstring(str_data, dtype=np.short)
    wave_data.shape = -1, 2
    wave_data = wave_data.T
    time = np.arange(0, nframes) * (1.0 / framerate)

    # 绘制波形
    plt.subplot(211) 
    plt.plot(time, wave_data[0])
    plt.subplot(212) 
    plt.plot(time, wave_data[1], c="g")
    plt.xlabel("time (seconds)")
    plt.show()

16、where

  • (1)找到y数组中=1的位置:np.where(y==1)

17、np.ravel(y)

  • 将二维的转化为一维的,eg:(5000,1)-->(5000,)

二、Matplotlib

1、关于pyplot

  • (1)matplotlib的pyplot子库提供了和matlab类似的绘图API,方便用户快速绘制2D图表。
  • (2)导入包:from matplotlib import pyplot as plt

2、绘图基础

  • (1)sin和cos
    x = np.linspace(-np.pi, np.pi,256,endpoint=True)
    C,S = np.cos(x),np.sin(x)
    plt.plot(x,C)
    plt.plot(x,S)
    plt.xlabel("x")
    plt.ylabel("y")
    plt.show()
  • (2)指定绘图的大小

    plt.figure(figsize=(8,6), dpi=80)

  • (3)指定线的颜色、粗细和类型

    plt.plot(x,C,color=”blue”,linewidth=2.0,linestyle=”-“,label=”cos”)
    蓝色、宽度、连续、label(使用legend会显示这个label)

  • (4)指定x坐标轴范围

    plt.xlim(-4.0,4.0)

  • (5)设置y抽刻度间隔
    plt.yticks(np.linspace(-1, 1, 15, endpoint=True))
  • (6)显示图例

    plt.legend(loc=”upper left”)
    显示在左上方

  • (7)一个figure上画多个图subplot方式

    plt.subplot(1, 2, 1)
    plt.subplot(1, 2, 2)
    例如:plt.subplot(m, n, p)
    代表图共有的m行,n列,第p个图
    p是指第几个图,横向数
    上面代表有一行,两个图

  • (8)一个figure上画多个图,axes方式

    plt.axes([.1, .1, .8, .8])
    plt.axes([.2, .2, .3, .3])

  • (9)填充

    plt.fill_between(x, y1, y2=0, where=None, interpolate=False, step=None,
    hold=None, data=None)

    eg:

    plt.fill_between(X, 1, C+1, C+1>1,color="red")
    plt.fill_between(X, 1, C+1, C+1<1,color="blue")

3、散点图

  • (1)

    plt.scatter(X,Y)

4、条形图

  • (1)

    plt.bar(X, Y, facecolor="red", edgecolor="blue" )
    填充颜色为facecolor,边界颜色为edgecolor

5、等高线图

  • (1)只显示等高线contour
  • (2)显示表面contourf
  • (3)注意三维图要用到meshgrid转化为网格
    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),alpha=.5)
    C = plt.contour(X,Y,f(X, Y),colors="black",linewidth=.5)
    plt.clabel(C)

    plt.show()

6、显示图片imshow

  • (1)
    def f(x,y):
    return (1 - x / 2 + x ** 5 + y ** 3 ) * np.exp(-x ** 2 - y ** 2)
    n = 10
    x = np.linspace(-3, 3, 3.5 * n)
    y = np.linspace(-3, 3, 3.0 * n)
    X, Y = np.meshgrid(x, y)
    z = f(X,Y)
    plt.imshow(z)
    plt.show()

7、饼图pie

  • (1)传入一个序列
    plt.figure(figsize=(8,8))
    n = 20
    Z = np.arange(10)
    plt.pie(Z)
    plt.show()

8、三维表面图*

  • (1)需要导入包:from mpl_toolkits.mplot3d import Axes3D
  • (2)
    fig = plt.figure()
    ax = Axes3D(fig)
    X = np.arange(-4, 4, 0.25)
    Y = np.arange(-4, 4, 0.25)
    X, Y = np.meshgrid(X, Y)
    R = np.sqrt(X ** 2 + Y ** 2)
    Z = np.sin(R)
    ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=plt.cm.hot)
    ax.contourf(X, Y, Z, zdir=‘z‘, offset=-2, cmap=plt.cm.hot)
    ax.set_zlim(-2, 2)
    plt.show()

三、Scipy

1、 Scipy特征

  • (1)内置了图像处理, 优化,统计等等相关问题的子模块
  • (2)scipy 是Python科学计算环境的核心。 它被设计为利用 numpy 数组进行高效的运行。从这个角度来讲,scipy和numpy是密不可分的。

2、文件操作io

  • (1)导包:from scipy import io as spio
  • (2)保存mat格式文件

    spio.savemat("test.mat", {‘a‘:a})

  • (3)加载mat文件

    data = spio.loadmat("test.mat")
    访问值:data[‘a’]–>相当于map

  • (4)读取图片文件
    导包:from scipy import misc
    读取:data = misc.imread("123.png")
    [注1]:与matplotlib中plt.imread(‘fname.png‘)类似
    [注2]:执行misc.imread时可能提醒不存在这个模块,那就安装pillow的包

3、线性代数操作linalg

  • (1)求行列式det

    res = linalg.det(a)

  • (2)求逆矩阵inv

    res = linalg.inv(a)
    若是矩阵不可逆,则会抛异常LinAlgError: singular matrix

  • (3)奇异值分解svd
    u,s,v = linalg.svd(a)
    [注1]:s为a的特征值(一维),降序排列,
    [注2]:a = u*s*v’(需要将s转换一下才能相乘)
    t = np.diag(s)
    print u.dot(t).dot(v)

4、梯度下降优化算法

  • (1)fmin_bfgs
    def f(x):
        return x**2-2*x
    initial_x = 0
    optimize.fmin_bfgs(f,initial_x)
[注]:initial_x为初始点(此方法可能会得到局部最小值)

- (2)fmin()fmin_cg等等方法

5、拟合(最小二乘法)

  • (1)curve_fit
    #产生数据
    def f(x):
        return x**2 + 10*np.sin(x)
    xdata = np.linspace(-10, 10, num=20)
    ydata = f(xdata)+np.random.randn(xdata.size)
    plt.scatter(xdata, ydata, linewidths=3.0, 
               edgecolors="red")
    #plt.show()
    #拟合
    def f2(x,a,b):
        return a*x**2 + b*np.sin(x)
    guess = [2,2]
    params, params_covariance = optimize.curve_fit(f2, xdata, ydata, guess)
    #画出拟合的曲线
    x1 = np.linspace(-10,10,256)
    y1 = f2(x1,params[0],params[1])
    plt.plot(x1,y1)
    plt.show()

6、统计检验

  • (1)T-检验stats.ttest_ind
    a = np.random.normal(0, 1, size=10)
    b = np.random.normal(1, 1, size=10)
    print stats.ttest_ind(a, b)  

输出:(-2.6694785119868358, 0.015631342180817954)
后面的是概率p: 两个过程相同的概率。如果其值接近1,那么两个过程几乎可以确定是相同的,如果其值接近0,那么它们很可能拥有不同的均值。

7、插值

  • (1)导入包:from scipy.interpolate import interp1d
    #产生一些数据
    x = np.linspace(0, 1, 10)
    y = np.sin(2 * np.pi * x)
    computed_time = np.linspace(0, 1, 50)
    #线性插值
    linear_interp = interp1d(x, y)
    linear_results = linear_interp(computed_time)
    #三次方插值
    cubic_interp = interp1d(x, y, kind=‘cubic‘)
    cubic_results = cubic_interp(computed_time)
    #作图
    plt.plot(x, y, ‘o‘, ms=6, label=‘y‘)
    plt.plot(computed_time, linear_results, label=‘linear interp‘)
    plt.plot(computed_time, cubic_results, label=‘cubic interp‘)
    plt.legend()
    plt.show()

8、求解非线性方程组

  • (1)optimize中的fsolve
    from scipy.optimize import fsolve
    def func(x):
        x0,x1,x2 = x.tolist()
        return [5*x1-25,5*x0*x0-x1*x2,x2*x0-27]
    initial_x = [1,1,1]
    result = fsolve(func, initial_x)
    print result

四、pandas

1、pandas特征与导入

  • (1)包含高级的数据结构和精巧的工具
  • (2)pandas建造在NumPy之上
  • (3)导入:
    from pandas import Series, DataFrame
    import pandas as pd

2、pandas数据结构

(1)Series

  • 一维的类似的数组对象
  • 包含一个数组的数据(任何NumPy的数据类型)和一个与数组关联的索引
    • 不指定索引:a = Series([1,2,3]) ,输出为

      0 1
      1 2
      2 3

      包含属性a.index,a.values,对应索引和值
    • 指定索引:a = Series([1,2,3],index=[‘a‘,‘b‘,‘c‘])
      可以通过索引访问a[‘b‘]
  • 判断某个索引是否存在:‘b‘ in a
  • 通过字典建立Series
dict = {‘china‘:10,‘america‘:30,‘indian‘:20}
print Series(dict)

输出:

america    30
china      10
indian     20
dtype: int64
  • 判断哪个索引值缺失:
dict = {‘china‘:10,‘america‘:30,‘indian‘:20}
state = [‘china‘,‘america‘,‘test‘]
a = Series(dict,state)
print a.isnull()

输出:(test索引没有对应值)

china      False
america    False
test        True
dtype: bool
  • 在算术运算中它会自动对齐不同索引的数据
a = Series([10,20],[‘china‘,‘test‘])
b = Series([10,20],[‘test‘,‘china‘])
print a+b

输出:

china    30
test     30
dtype: int64
  • 指定Series对象的nameindexname属性
a = Series([10,20],[‘china‘,‘test‘])
a.index.name = ‘state‘
a.name = ‘number‘
print a

输出:

state
china    10
test     20
Name: number, dtype: int64

(2)DataFrame

  • Datarame表示一个表格,类似电子表格的数据结构
  • 包含一个经过排序的列表集(按列名排序)
  • 每一个都可以有不同的类型值(数字,字符串,布尔等等)
  • DataFrame在内部把数据存储为一个二维数组的格式,因此你可以采用分层索引以表格格式来表示高维的数据
  • 创建:
    • 通过字典

      data = {‘state‘: [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘d‘],
      ‘year‘: [2000, 2001, 2002, 2001, 2002],
      ‘pop‘: [1.5, 1.7, 3.6, 2.4, 2.9]}
      frame = DataFrame(data)
      print frame

      输出:(按照列名排好序的[若是手动分配列名,会按照你设定的],并且索引会自动分配)

      pop state year
      0 1.5 a 2000
      1 1.7 b 2001
      2 3.6 c 2002
      3 2.4 d 2001
      4 2.9 d 2002
  • 访问
    • :与Series一样,通过列名访问:frame[‘state‘]或者frame.state
    • ix 索引成员(field),frame.ix[2],返回每一列的第3行数据
  • 赋值:frame2[‘debt‘] = np.arange(5.),若没有debt列名,则会新增一列
  • 删除某一列:del frame2[‘eastern‘]
  • 像Series一样, values 属性返回一个包含在DataFrame中的数据的二维ndarray
  • 返回所有的列信息:frame.columns
  • 转置:frame2.T

(3)索引对象

  • pandas的索引对象用来保存坐标轴标签和其它元数据(如坐标轴名或名称)
  • 索引对象是不可变的,因此不能由用户改变
  • 创建index = pd.Index([1,2,3])
  • 常用操作
    • append–>链接额外的索引对象,产生一个新的索引
    • diff –>计算索引的差集
    • intersection –>计算交集
    • union –>计算并集
    • isin –>计算出一个布尔数组表示每一个值是否包含在所传递的集合里
    • delete –>计算删除位置i的元素的索引
    • drop –>计算删除所传递的值后的索引
    • insert –>计算在位置i插入元素后的索引
    • is_monotonic –>返回True,如果每一个元素都比它前面的元素大或相等
    • is_unique –>返回True,如果索引没有重复的值
    • unique –>计算索引的唯一值数组

3、重新索引reindex

(1)Series

  • (1)重新排列
    a = Series([2,3,1],index=[‘b‘,‘a‘,‘c‘])
    b = a.reindex([‘a‘,‘b‘,‘c‘])
    print b
  • (2)重新排列,没有的索引补充为0,b=a.reindex([‘a‘,‘b‘,‘c‘,‘d‘],fill_value=0)
  • (3)重建索引时对值进行内插或填充
    a = Series([‘a‘,‘b‘,‘c‘],index=[0,2,4])
    b = a.reindex(range(6),method=‘ffill‘)
    print b

输出:

    0    a
    1    a
    2    b
    3    b
    4    c
    5    c
    dtype: object

method的参数
ffill或pad—->前向(或进位)填充
bfill或backfill—->后向(或进位)填充

(3)DataFrame

  • 与Series一样,reindex index
  • 还可以reindex column列,frame.reindex(columns=[‘a‘,‘b‘])

4、从一个坐标轴删除条目

(1)Series

  • a.drop([‘a‘,‘b‘]) 删除a,b索引项

(2)DataFrame

  • 索引项的删除与Series一样
  • 删除column—>a.drop([‘one‘], axis=1) 删除column名为one的一列

5、索引,挑选和过滤

(1)Series

  • 可以通过index值或者整数值来访问数据,eg:对于a = Series(np.arange(4.), index=[‘a‘, ‘b‘, ‘c‘, ‘d‘])a[‘b‘]a[1]是一样的
  • 使用标签来切片和正常的Python切片并不一样,它会把结束点也包括在内
a = Series(np.arange(4.), index=[‘a‘, ‘b‘, ‘c‘, ‘d‘])
print a[‘b‘:‘c‘]

输出包含c索引对应的值

(2)DataFrame

  • 显示前两行:a[:2]
  • 布尔值访问:a[a[‘two‘]>5]
  • 索引字段 ix 的使用
    • index为2,column为’one’和’two’—>a.ix[[2],[‘one‘,‘two‘]]
    • index为2的一行:a.ix[2]

6、DataFrame和Series运算

  • (1)DataFrame每一行都减去一个Series
    a = pd.DataFrame(np.arange(16).reshape(4,4),index=[0,1,2,3],columns=[‘one‘,    ‘two‘,‘three‘,‘four‘])
    print a
    b = Series([0,1,2,3],index=[‘one‘,‘two‘,‘three‘,‘four‘])
    print b
    print a-b

输出:

       one  two  three  four
    0    0    1      2     3
    1    4    5      6     7
    2    8    9     10    11
    3   12   13     14    15
    one      0
    two      1
    three    2
    four     3
    dtype: int64
       one  two  three  four
    0    0    0      0     0
    1    4    4      4     4
    2    8    8      8     8
    3   12   12     12    12

7、读取文件

  • (1)csv文件
    pd.read_csv(r"data/train.csv"),返回的数据类型是DataFrame类型

8、查看DataFrame的信息

  • (1)train_data.describe()
    eg:
       PassengerId    Survived      Pclass         Age       SibSp  count   891.000000  891.000000  891.000000  714.000000  891.000000   
mean    446.000000    0.383838    2.308642   29.699118    0.523008   
std     257.353842    0.486592    0.836071   14.526497    1.102743   
min       1.000000    0.000000    1.000000    0.420000    0.000000   
25%     223.500000    0.000000    2.000000   20.125000    0.000000   
50%     446.000000    0.000000    3.000000   28.000000    0.000000   
75%     668.500000    1.000000    3.000000   38.000000    1.000000   
max     891.000000    1.000000    3.000000   80.000000    8.000000   

五、scikit-learn

1、手写数字识别(SVM)

    from sklearn import datasets
    from sklearn import svm
    import numpy as np
    from matplotlib import pyplot as plt

    ‘‘‘
    使用sciki-learn中的数据集,一般有data,target,DESCR等属性属性
    ‘‘‘

    digits = datasets.load_digits()                 #加载scikit-learn中的数据集

    clf = svm.SVC(gamma=0.001,C=100)                    #使用支持向量机进行分类,gamma为核函数的系数
    clf.fit(digits.data[:-4],digits.target[:-4])        #将除最后4组的数据输入进行训练

    predict = clf.predict(digits.data[-4:])         #预测最后4组的数据,[-4:]表示最后4行所有数据,而[-4,:]表示倒数第4行数据

    print "预测值为:",predict
    print "真实值:",digits.target[-4:]

    #显示最后四个图像
    plt.subplot(2,2,1)
    plt.imshow(digits.data[-4,:].reshape(8,8))
    plt.subplot(2,2,2)
    plt.imshow(digits.data[-3,:].reshape(8,8))
    plt.subplot(2,2,3)
    plt.imshow(digits.data[-2,:].reshape(8,8))
    plt.subplot(2,2,4)
    plt.imshow(digits.data[-1,:].reshape(8,8))
    plt.show()

svm的参数参数解释:
- (1)C: 目标函数的惩罚系数C,用来平衡分类间隔margin和错分样本的,default C = 1.0;
- (2)kernel:参数选择有RBF, Linear, Poly, Sigmoid, 默认的是”RBF”;
- (3)degree:if you choose ‘Poly’ in param 2, this is effective, degree决定了多项式的最高次幂;
- (4)gamma:核函数的系数(‘Poly’, ‘RBF’ and ‘Sigmoid’), 默认是gamma = 1 / n_features;
- (5)coef0:核函数中的独立项,’RBF’ and ‘Poly’有效;
- (6)probablity: 可能性估计是否使用(true or false);
- (7)shrinking:是否进行启发式;
- (8)tol(default = 1e - 3): svm结束标准的精度;
- (9)cache_size: 制定训练所需要的内存(以MB为单位);
- (10)class_weight:每个类所占据的权重,不同的类设置不同的惩罚参数C,缺省的话自适应;
- (11)verbose: 跟多线程有关,不大明白啥意思具体;
- (12)max_iter: 最大迭代次数,default = 1000, if max_iter = -1, no limited;
- (13)decision_function_shape : ‘ovo’ 一对一, ‘ovr’ 多对多 or None 无, default=None
- (14)random_state :用于概率估计的数据重排时的伪随机数生成器的种子。

2、保存训练过的模型

joblib.dump(clf, "digits.pkl") #将训练的模型保存成digits.pkl文件
加载模型:
clf = joblib.load("digits.pkl")
其余操作数据即可,预测

3、鸢尾花分类(svm,分离出测试集)

    from sklearn import datasets
    from sklearn.cross_validation import train_test_split
    from sklearn.svm import SVC
    import numpy as np
    ‘‘‘
    加载scikit-learn中的鸢尾花数据集
    ‘‘‘

    #加载鸢尾花数据集
    iris = datasets.load_iris()
    iris_data = iris.data;          #相当于X
    iris_target = iris.target;      #对应的label种类,相当于y

    x_train,x_test,y_train,y_test =     train_test_split(iris_data,iris_target,test_size=0.2)       #将数据分成训练集x_train和测试集x_test,测试集占总数据的0.2

    model = SVC().fit(x_train,y_train);     #使用svm在训练集上拟合
    predict = model.predict(x_test)         #在测试集上预测
    right = sum(predict == y_test)          #求预测正确的个数

    print (‘测试集准确率:%f%%‘%(right*100.0/predict.shape[0]))        #求在测试集上预测的正确率,shape[0]返回第一维的长度,即数据个数

[另:留一验证法]:–>每次取一条数据作为测试集,其余作为训练集

    from sklearn import datasets
    from sklearn.svm import SVC
    import numpy as np

    def data_svc_test(data,target,index):
        x_train = np.vstack((data[0:index],data[index+1:-1]))#除第index号之外的    数据为训练集
        x_test = data[index].reshape(1,-1)                    #第index号数据为测试集,reshape(1,-1)的作用是只有一条数据时,使用reshap    e(1,-1),否则有个过时方法的警告
        y_train = np.hstack((target[0:index],target[index+1:-1]))
        y_test = target[index]
        model = SVC().fit(x_train,y_train)    #建立SVC模型
        predict = model.predict(x_test)

        return predict == y_test        #返回结果是否预测正确

    #读取数据
    iris = datasets.load_iris()
    iris_data = iris.data
    iris_target = iris.target
    m = iris_target.shape[0]

    right = 0;
    for i in range(0,m):
        right += data_svc_test(iris_data,iris_target,i)
    print ("%f%%"%(right*100.0/m))

4、房价预测(SVR–>支持向量回归)

    from sklearn import datasets
    from sklearn.svm import SVR     #引入支持向量回归所需的SVR模型
    from sklearn.cross_validation import train_test_split
    from sklearn.preprocessing import StandardScaler
    import numpy as np

    #加载数据
    house_dataset = datasets.load_boston()
    house_data = house_dataset.data
    house_price = house_dataset.target
    #数据预处理-->归一化
    x_train,x_test,y_train,y_test =     train_test_split(house_data,house_price,test_size=0.2)  
    scaler = StandardScaler()
    scaler.fit(x_train)
    x_train = scaler.transform(x_train) #训练集
    x_test = scaler.transform(x_test)   #测试集

    #回归,预测
    model = SVR().fit(x_train,y_train)  #使用SVR回归拟合
    predict = model.predict(x_test)     #预测
    result = np.hstack((y_test.reshape(-1,1),predict.reshape(-1,1))) #reshape(-1,1)所有行转为1列向量
    print(result)




































































































以上是关于Python学习_科学计算的主要内容,如果未能解决你的问题,请参考以下文章

『python』科学计算专项_科学绘图库matplotlib学习(下)

『Python』Numpy学习指南第十章_高端科学计算库scipy入门(系列完结)

python 用于数据探索的Python代码片段(例如,在数据科学项目中)

『python』科学计算专项_科学绘图库matplotlib学习之绘制动画(待续)

python能做啥科学计算

Python 多版本切换工具- Pyenv/Virtualenv 及 Anaconda 科学计算环境的配置