插值函数python

‘壹’ 谁有拉格朗日插值法的python代码啊！急用啊！谢谢啦！

您好，#include<stdio.h>
#include<stdlib.h>
#include<iostream.h>
typedef struct data
{
float x;
float y;
}Data;//变量x和函数值y的结构
Data d[20];//最多二十组数据
float f(int s,int t)//牛顿插值法，用以返回插商
{
if(t==s+1)
return (d[t].y-d[s].y)/(d[t].x-d[s].x);
else
return (f(s+1,t)-f(s,t-1))/(d[t].x-d[s].x);
}
float Newton(float x,int count)
{
int n;
while(1)
{
cout<<"请输入n值(即n次插值):";//获得插值次数
cin>>n;
if(n<=count-1)// 插值次数不得大于count－1次
break;
else
system("cls");
}
//初始化t，y，yt。
float t=1.0;
float y=d[0].y;
float yt=0.0;
//计算y值
for(int j=1;j<=n;j++)
{
t=(x-d[j-1].x)*t;
yt=f(0,j)*t;
//cout<<f(0,j)<<endl;
y=y+yt;
}
return y;
}
float lagrange(float x,int count)
{
float y=0.0;
for(int k=0;k<count;k++)//这儿默认为count－1次插值
{
float p=1.0;//初始化p
for(int j=0;j<count;j++)
{//计算p的值
if(k==j)continue;//判断是否为同一个数
p=p*(x-d[j].x)/(d[k].x-d[j].x);
}
y=y+p*d[k].y;//求和
}
return y;//返回y的值
}
void main()
{
float x,y;
int count;
while(1)
{
cout<<"请输入x[i],y[i]的组数，不得超过20组:";//要求用户输入数据组数
cin>>count;
if(count<=20)
break;//检查输入的是否合法
system("cls");
}
//获得各组数据
for(int i=0;i<count;i++)
{
cout<<"请输入第"<<i+1<<"组x的值:";
cin>>d[i].x;
cout<<"请输入第"<<i+1<<"组y的值:";
cin>>d[i].y;
system("cls");
}
cout<<"请输入x的值:";//获得变量x的值
cin>>x;
while(1)
{
int choice=3;
cout<<"请您选择使用哪种插值法计算："<<endl;
cout<<" (0):退出"<<endl;
cout<<" (1):Lagrange"<<endl;
cout<<" (2):Newton"<<endl;
cout<<"输入你的选择：";
cin>>choice;//取得用户的选择项
if(choice==2)
{
cout<<"你选择了牛顿插值计算方法，其结果为：";
y=Newton(x,count);break;//调用相应的处理函数
}
if(choice==1)
{
cout<<"你选择了拉格朗日插值计算方法，其结果为：";
y=lagrange(x,count);break;//调用相应的处理函数
}
if(choice==0)
break;
system("cls");
cout<<"输入错误!!!!"<<endl;
}
cout<<x<<" , "<<y<<endl;//输出最终结果

}

‘贰’ python可否用自定义函数对数据进行插值

直接定义a=True/False就行，示例代码：
#定义布尔值类型参数a,b，值分别为True,False
a=True
b=False
print a,b
print type(a),type(b)
>>>
True False
<type 'bool'> <type 'bool'>
Python中的布尔类型：
Python的布尔类型有两个值：True和False（注意大小写要区分）

‘叁’ python 怎么画与其他方法进行比较的ROC曲线

使用sklearn的一系列方法后可以很方便的绘制处ROC曲线，这里简单实现以下。
主要是利用混淆矩阵中的知识作为绘制的数据（如果不是很懂可以先看看这里的基础）：

tpr(Ture Positive Rate)：真阳率 图像的纵坐标

fpr(False Positive Rate)：阳率（伪阳率） 图像的横坐标

mean_tpr：累计真阳率求平均值

mean_fpr：累计阳率求平均值

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import StratifiedKFold

iris = datasets.load_iris()
X = iris.data
y = iris.target
X, y = X[y != 2], y[y != 2] # 去掉了label为2，label只能二分，才可以。
n_samples, n_features = X.shape
# 增加噪声特征
random_state = np.random.RandomState(0)
X = np.c_[X, random_state.randn(n_samples, 200 * n_features)]

cv = StratifiedKFold(n_splits=6) #导入该模型，后面将数据划分6份
classifier = svm.SVC(kernel='linear', probability=True,random_state=random_state) # SVC模型 可以换作AdaBoost模型试试

# 画平均ROC曲线的两个参数
mean_tpr = 0.0 # 用来记录画平均ROC曲线的信息
mean_fpr = np.linspace(0, 1, 100)
cnt = 0
for i, (train, test) in enumerate(cv.split(X,y)): #利用模型划分数据集和目标变量 为一一对应的下标
cnt +=1
probas_ = classifier.fit(X[train], y[train]).predict_proba(X[test]) # 训练模型后预测每条样本得到两种结果的概率
fpr, tpr, thresholds = roc_curve(y[test], probas_[:, 1]) # 该函数得到伪正例、真正例、阈值，这里只使用前两个

mean_tpr += np.interp(mean_fpr, fpr, tpr) # 插值函数 interp(x坐标,每次x增加距离,y坐标) 累计每次循环的总值后面求平均值
mean_tpr[0] = 0.0 # 将第一个真正例=0 以0为起点

roc_auc = auc(fpr, tpr) # 求auc面积
plt.plot(fpr, tpr, lw=1, label='ROC fold {0:.2f} (area = {1:.2f})'.format(i, roc_auc)) # 画出当前分割数据的ROC曲线

plt.plot([0, 1], [0, 1], '--', color=(0.6, 0.6, 0.6), label='Luck') # 画对角线

mean_tpr /= cnt # 求数组的平均值
mean_tpr[-1] = 1.0 # 坐标最后一个点为（1,1） 以1为终点
mean_auc = auc(mean_fpr, mean_tpr)

plt.plot(mean_fpr, mean_tpr, 'k--',label='Mean ROC (area = {0:.2f})'.format(mean_auc), lw=2)

plt.xlim([-0.05, 1.05]) # 设置x、y轴的上下限，设置宽一点，以免和边缘重合，可以更好的观察图像的整体
plt.ylim([-0.05, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate') # 可以使用中文，但需要导入一些库即字体
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()

‘肆’ 如何通过python实现三次样条插值

spline函数可以实现三次样条插值 x = 0:10; y = sin(x); xx = 0:.25:10; yy = spline(x,y,xx); plot(x,y,'o',xx,yy) 另外fnplt csapi这两个函数也是三次样条插值函数，具体你可以help一下！

‘伍’ python怎样对矩阵进行插值

首先需要创建数组才能对其进行其它操作。
我们可以通过给array函数传递Python的序列对象创建数组，如果传递的是多层嵌套的序列，将创建多维数组(下例中的变量c):
>>> a = np.array([1, 2, 3, 4])
>>> b = np.array((5, 6, 7, 8))
>>> c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
>>> b
array([5, 6, 7, 8])
>>> c
array([[1, 2, 3, 4],
[4, 5, 6, 7],
[7, 8, 9, 10]])
>>> c.dtype
dtype('int32')

数组的大小可以通过其shape属性获得：
>>> a.shape
(4,)
>>> c.shape

‘陆’ python 线性插值

不知道有没有，可能python数学相关的库里会有吧

不过你写的也不对啊，取3个值，应该是4均分。

>>>defjunfen(start,end,num):
	k=(end-start)/(num+1)
	returnset([start+item*kforiteminrange(1,num+1)])

‘柒’ 双线性插值法原理 python实现

码字不易，如果此文对你有所帮助，请帮忙点赞，感谢！

一. 双线性插值法原理：

        ① 何为线性插值？

        插值就是在两个数之间插入一个数，线性插值原理图如下：

        ② 各种插值法：

        插值法的第一步都是相同的，计算目标图（dstImage）的坐标点对应原图（srcImage）中哪个坐标点来填充，计算公式为：

        srcX = dstX * (srcWidth/dstWidth)

        srcY = dstY * (srcHeight/dstHeight)

        (dstX,dstY)表示目标图像的某个坐标点，(srcX,srcY)表示与之对应的原图像的坐标点。srcWidth/dstWidth 和 srcHeight/dstHeight 分别表示宽和高的放缩比。

        那么问题来了，通过这个公式算出来的 srcX, scrY 有可能是小数，但是原图像坐标点是不存在小数的，都是整数，得想办法把它转换成整数才行。

        不同插值法的区别就体现在 srcX, scrY 是小数时，怎么将其变成整数去取原图像中的像素值。

        最近邻插值（Nearest-neighborInterpolation）：看名字就很直白，四舍五入选取最接近的整数。这样的做法会导致像素变化不连续，在目标图像中产生锯齿边缘。

        双线性插值（Bilinear Interpolation）：双线性就是利用与坐标轴平行的两条直线去把小数坐标分解到相邻的四个整数坐标点。权重与距离成反比。

        双三次插值（Bicubic Interpolation）：与双线性插值类似，只不过用了相邻的16个点。但是需要注意的是，前面两种方法能保证两个方向的坐标权重和为1，但是双三次插值不能保证这点，所以可能出现像素值越界的情况，需要截断。

        ③ 双线性插值算法原理

        假如我们想得到未知函数 f 在点 P = (x, y) 的值，假设我们已知函数 f 在 Q11 = (x1, y1)、Q12 = (x1, y2), Q21 = (x2, y1) 以及 Q22 = (x2, y2) 四个点的值。最常见的情况，f就是一个像素点的像素值。首先在 x 方向进行线性插值，然后再在 y 方向上进行线性插值，最终得到双线性插值的结果。

    ④ 举例说明

二. python实现灰度图像双线性插值算法：

灰度图像双线性插值放大缩小

import numpy as np

import math

import cv2

def double_linear(input_signal, zoom_multiples):

    '''

    双线性插值

    :param input_signal: 输入图像

    :param zoom_multiples: 放大倍数

    :return: 双线性插值后的图像

    '''

    input_signal_cp = np.(input_signal)  # 输入图像的副本

    input_row, input_col = input_signal_cp.shape # 输入图像的尺寸（行、列）

    # 输出图像的尺寸

    output_row = int(input_row * zoom_multiples)

    output_col = int(input_col * zoom_multiples)

    output_signal = np.zeros((output_row, output_col)) # 输出图片

    for i in range(output_row):

        for j in range(output_col):

            # 输出图片中坐标 （i，j）对应至输入图片中的最近的四个点点（x1，y1）（x2, y2），（x3， y3），(x4，y4)的均值

            temp_x = i / output_row * input_row

            temp_y = j / output_col * input_col

            x1 = int(temp_x)

            y1 = int(temp_y)

            x2 = x1

            y2 = y1 + 1

            x3 = x1 + 1

            y3 = y1

            x4 = x1 + 1

            y4 = y1 + 1

            u = temp_x - x1

            v = temp_y - y1

            # 防止越界

            if x4 >= input_row:

                x4 = input_row - 1

                x2 = x4

                x1 = x4 - 1

                x3 = x4 - 1

            if y4 >= input_col:

                y4 = input_col - 1

                y3 = y4

                y1 = y4 - 1

                y2 = y4 - 1

            # 插值

            output_signal[i, j] = (1-u)*(1-v)*int(input_signal_cp[x1, y1]) + (1-u)*v*int(input_signal_cp[x2, y2]) + u*(1-v)*int(input_signal_cp[x3, y3]) + u*v*int(input_signal_cp[x4, y4])

    return output_signal

# Read image

img = cv2.imread("../paojie_g.jpg",0).astype(np.float)

out = double_linear(img,2).astype(np.uint8)

# Save result

cv2.imshow("result", out)

cv2.imwrite("out.jpg", out)

cv2.waitKey(0)

cv2.destroyAllWindows()

三. 灰度图像双线性插值实验结果：

四. 彩色图像双线性插值python实现

def BiLinear_interpolation(img,dstH,dstW):

    scrH,scrW,_=img.shape

    img=np.pad(img,((0,1),(0,1),(0,0)),'constant')

    retimg=np.zeros((dstH,dstW,3),dtype=np.uint8)

    for i in range(dstH-1):

        for j in range(dstW-1):

            scrx=(i+1)*(scrH/dstH)

            scry=(j+1)*(scrW/dstW)

            x=math.floor(scrx)

            y=math.floor(scry)

            u=scrx-x

            v=scry-y

            retimg[i,j]=(1-u)*(1-v)*img[x,y]+u*(1-v)*img[x+1,y]+(1-u)*v*img[x,y+1]+u*v*img[x+1,y+1]

    return retimg

im_path='../paojie.jpg'

image=np.array(Image.open(im_path))

image2=BiLinear_interpolation(image,image.shape[0]*2,image.shape[1]*2)

image2=Image.fromarray(image2.astype('uint8')).convert('RGB')

image2.save('3.png')

五. 彩色图像双线性插值实验结果：

六. 最近邻插值算法和双三次插值算法可参考：

        ① 最近邻插值算法： https://www.cnblogs.com/wojianxin/p/12515061.html

         https://blog.csdn.net/Ibelievesunshine/article/details/104936006

        ② 双三次插值算法： https://www.cnblogs.com/wojianxin/p/12516762.html

        https://blog.csdn.net/Ibelievesunshine/article/details/104942406

七. 参考内容：

         https://www.cnblogs.com/wojianxin/p/12515061.html

         https://blog.csdn.net/Ibelievesunshine/article/details/104939936

‘捌’ python 拉格朗日插值 不能超过多少个值

拉格朗日插值Python代码实现

1. 数学原理

对某个多项式函数有已知的k+1个点，假设任意两个不同的都互不相同，那么应用拉格朗日插值公式所得到的拉格朗日插值多项式为：

直接编写程序，可以直接插值，并且得到对应的函数值。但是不能得到系数，也不能对其进行各项运算。

上述代码中，h(x,y,a)就是插值函数，直接调用就行。参数说明如下：

• x,y分别是对应点的x值和y值。具体详解下解释。

• a为想要取得的函数的值。

事实上，最简单的拉格朗日插值就是两点式得到的一条直线。

例如：

p点(1,0)q点(0,2)

这两个点决定了一条直线，所以当x=2的时候，y应该是-2

该代码就是利用这两个点插值，然后a作为x=2调用函数验证的。

3. 引用库

3.1 库的安装

主要依赖与 scipy。官方网站见：https://www.scipy.org/install.html

安装的方法很简单，就是使用pip install scipy 如果失败，则将whl文件下载到本地再利用命令进行安装。

可能如果没有安装numpy

3.2 库的使用

from scipy.interplotate import lagrange

直接调用lagrange(x,y)这个函数即可，返回 一个对象。

参数x,y分别是对应各个点的x值和y值。

例如：(1,2) (3,5) (5,9)这三个点，作为函数输入应该这么写：

x＝[1,3,5]

y =[2, 5, 9]

a=lagrange(x,y)

直接输出该对象，就能看到插值的函数。

利用该对象，能得到很多特性。具体参见：https://docs.scipy.org/doc/numpy-1.12.0/reference/generated/numpy.poly1d.html

• a.order得到阶

• a[]得到系数

• a()得到对应函数值

• 此外可以对其进行加减乘除运算

3.3 代码实现

1234567
fromscipy.interpolateimportlagrangex=[1,2,3,4,7]y=[5,7,10,3,9]a=lagrange(x,y)print(a)print(a(1),a(2),a(3))print(a[0],a[2],a[3])

结果是：

<class 'numpy.lib.polynomial.poly1d'> 4
4 3 2
0.5472 x - 7.306 x + 30.65 x - 47.03 x + 28.13
5.0 7.0 10.0
28.1333333333 30.6527777778 -7.30555555556

解释：

<class 'numpy.lib.polynomial.poly1d'> 4

这一行是输出a的类型，以及最高次幂。

4 3 2
0.5472 x - 7.306 x + 30.65 x - 47.03 x + 28.13

第二行和第三行就是插值的结果，显示出的函数。

第二行的数字是对应下午的x的幂，如果对应不齐，则是排版问题。

5.0 7.0 10.0

第四行是代入的x值，得到的结果。

也就是说，用小括号f(x)的这种形式，可以直接得到计算结果。

28.1333333333 30.6527777778 -7.30555555556

‘玖’ 想用python来求解牛顿插值问题，编了一段程序，其中有些错误看不出来，恳请大佬指出错误，代码如下

importmatplotlib.pyplotasplt
frompylabimportmpl
importmath
"""
牛顿插值法
插值的函数表为
xi-28.9,-12.2,4.4,21.1,37.8
f(xi)2.2,3.9,6.6,10.3,15.4
"""
x=[-28.9,-12.2,4.4,21.1,37.8]
y=[2.2,3.9,6.6,10.3,15.4]

"""计算4次差商的值"""
defFour_time_difference_quotient(x,y):
i=0#i记录计算差商的次数
quotient=[0,0,0,0,0,]
whilei<4:
j=4
whilej>i:
ifi==0:
quotient[j]=((y[j]-y[j-1])/(x[j]-x[j-1]))
else:
quotient[j]=(quotient[j]-quotient[j-1])/(x[j]-x[j-1-i])
j-=1
i+=1
returnquotient;

deffunction(data):
returnx[0]+parameters[1]*(data-0.4)+parameters[2]*(data-0.4)*(data-0.55)+
parameters[3]*(data-0.4)*(data-0.55)*(data-0.65)
+parameters[4]*(data-0.4)*(data-0.55)*(data-0.80)

"""计算插值多项式的值和相应的误差"""
defcalculate_data(x,parameters):
returnData=[];
fordatainx:
returnData.append(function(data))
returnreturnData

"""画函数的图像
newData为曲线拟合后的曲线
"""

defdraw(newData):
plt.scatter(x,y,label="离散数据",color="red")
plt.plot(x,newData,label="牛顿插值拟合曲线",color="black")
plt.scatter(0.596,function(0.596),label="预测函数点",color="blue")
plt.title("牛顿插值法")
mpl.rcParams['font.sans-serif']=['SimHei']
mpl.rcParams['axes.unicode_minus']=False
plt.legend(loc="upperleft")
plt.show()

parameters=Four_time_difference_quotient(x,y)
yuanzu=calculate_data(x,parameters)
draw(yuanzu)

‘拾’ python线性插值解析

在缺失值填补上如果用前后的均值填补中间的均值， 比如，0，空，1， 我们希望中间填充0.5；或者0，空，空，1，我们希望中间填充0.33，0.67这样。

可以用pandas的函数进行填充，因为这个就是线性插值法

df..interpolate()

dd=pd.DataFrame(data=[0,np.nan,np.nan,1])

dd.interpolate()

补充知识：线性插值公式简单推导

以上这篇python线性插值解析就是我分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。