#三维点插值#在三维空间中，利用实际点的值推算出网格点的值import numpy as np 

point_grid =np.array([[0.0,0.0,0.0],[0.4,0.4,0.4],[0.8,0.8,0.8],[1.0,1.0,1.0]])#网格点坐标

def func(x, y, z):
    return x*(1-x)*np.cos(4*np.pi*x) * (np.sin(4*np.pi*y**2)**2)*z

points = np.random.rand(10, 3)#实际点坐标
values = func(points[:,0], points[:,1],points[:,2])#实际点的值

from scipy.interpolate import griddata
grid_z0 = griddata(points, values, point_grid, method='nearest')#插值计算，计算出网格点的值

使用idw插值法对站点观测数据进行面插值。
使用方法
1、gdal_grid.exe

2、gdal.grid()

opts = gdal.GridOptions(algorithm="invdistnn:power=2.0:smothing=0.0:radius=1.0:max_points=12:min_points=0:nodata=0.0",
							format="GTiff",outputType=gdal

简介

在编写Python中的自定义函数或算法时，减低时间复杂度和空间复杂度，会大大提升Python自定义函数或算法的整体性能，提升性能的几个书写好习惯：

• 尽量不要写循环，最好是一次就输出结果
• 如果写循环，尽量写一层循环就能有结果
• 避免嵌套

时间复杂度

时间复杂度是用来估计自定义函数或算法运行时间的一个式子（单位）,时间复杂度常用“O”表述，而且时间复杂度可被称为是渐近的，它考察当输入值大小趋近 $\infty$ 时的情况

时间复杂度为 O(1)的例子

print('Hello!')
print(1)

时间复杂度为 O(n)的例子

# 其中range(n) 换成range(length(n))或者直接换成n，其时间复杂度都为 O(n)
for i in range(n): 
    print('Hello!')

时间复杂度为O(n^2)的例子

# 其中range(n) 换成range(length(n))或者直接换成n，其时间复杂度都为 O(n^2)
for i in range(n):
    for j in range(n):
        print('Hello!')

for i in range(n): 
    print('Hello!')
    for j in range(n):
        print('Hello!')

for i in range(n): 
    for j in range(i):
        print('Hello!')

时间复杂度为O(n^3)的例子

# 其中range(n) 换成range(length(n))或者直接换成n，其时间复杂度都为 O(n^3)
for i in range(n):
    for j in range(n):
        for k in range(n):
            print('Hello!') 

由上述时间复杂度O(n)的变化可以得出这样的结论：O(n)中n的几次方取决于自定义函数或算法中存在几个循环。

时间复杂度为O(n^n)的例子

# 其中range(n) 换成range(length(n))或者直接换成n，其时间复杂度都为 O(n^n)
for i in range(n):
    for j in range(n):
        for k in range(n):
        	for l in range(n):
        	.
        	.
        	.
        		for o in range(n):
            		print('Hello!') 

时间复杂度为O($lo{g}_{2}n$)的例子

n = 128
while n > 1:
    print(n)
    n = n // 2 # //表示整除法

计算上述问题的时间复杂度步骤：

1. $2^7=128$
2. $lo{g}_{2}128=7$
3. 循环减半的时间复杂度为O($lo{g}_{2}128$)，即O($lo{g}_{n}128$) = O(7)

复杂度为O($lo{g}_{2}n$)

n = n
while n > 1:
    print(n)
    n = n // 2 # //表示整除法

常见的时间复杂度高低排序：O(1)<O($lo{g}_n$)<O(n)<O($nlo{g}_n$)<O($n^2$)<O($n^{2}lo{g}_n$)<O($n^3$)

空间复杂度

空间复杂度：用来评估自定义函数或算法内存占用大小

空间复杂度为 1的例子

p = 'Python'
l = 'like'
m = 'me'

空间复杂度为 n

p = [1,2,3,....,n]

空间复杂度为 n*n

p_n = [[1,2,3,....,n],[1,2,3,....,n],.....,[1,2,3,....,n]]

空间复杂度为 n * n * n

p_n = [[[1,2,3,....,n],[1,2,3,....,n],.....,[1,2,3,....,n]],
[[1,2,3,....,n],[1,2,3,....,n],.....,[1,2,3,....,n]],
....,
[[1,2,3,....,n],[1,2,3,....,n],.....,[1,2,3,....,n]]

空间复杂度却决于：

• 变量的长度
• 变量的个数
• 变量的复杂程度

示例展示

自定义方差（variance）函数简化，以及计算其对应的时间复杂度和空间复杂度

def variance (*args): # *args不限定输入的可变量，这里输入的数量为n
    total = 0 #时间复杂度为 1；空间复杂度为 1
    average = float(sum(args))/len(args) 
    # 时间复杂度为 n+1 其中sum（args）为n，len(args)为 1
    # 空间复杂度为 1
    for val in args:
        total +=(val-average)**2
    # 时间复杂度为 n，即进行了n次循环
    # 空间复杂度为 n，即存储了n次total
    return total/len(args) # 时间复杂度为 1；空间复杂度为 1

时间复杂度：1+n+1+n+1 = 2n+1
空间复杂度：1+1+n+1 = n+3