请问大佬们，Python自定义的函数不可以循环调用吗o(╥﹏╥)o

Question

import numpy as np

X0 = np.arange(-1, 101, 1.0)  # 炮检距（中心点即目标点），-1-100
X = np.zeros(90)  # 射线经过的水平距离
ag = np.zeros((5, 101))  # 找到适合水平距离的粗始入射角变量，5行101列适用于4层100个炮检距
agi = np.arange(0, 90, 1.0)  # 设置入射角数组，1度为步长，0-89
a = np.zeros((5, 101))  # 反射点处的入射角，5行101列适用于4层100个炮检距
Vp = [0, 3700, 2400, 3000, 2000]  # 层状速度数组
H = [0, 60, 20, 40, 20]  # 层厚度数组


def angle_function(m, n):  # 定义子函数，计算层数为n、炮检距为m的入射角
    for j in range(90):
        for i in range(m + 1):
            P = np.sin(agi[j] * np.pi / 180) / Vp[1]
            # print(P*Vp[i], 1 - (P * Vp[i]) ** 2)
            X[j] += 2 * H[i] * P * Vp[i] / np.sqrt(1 - (P * Vp[i]) ** 2)
        if X[j - 1] < X0[n] < X[j]:  # 适合水平距离时停止增加入射角角度
            for l in range(50):  # 二分法精确化入射角
                ag[m][n] = (agi[j - 1] + agi[j]) / 2.0
                for k in range(m + 1):
                    P = np.sin(ag[m][1] * np.pi / 180) / Vp[1]
                    X[l] += 2 * H[k] * P * Vp[k] / np.sqrt(1 - (P * Vp[k]) ** 2)
                if abs(X[l] - X0[n]) > 0.5:
                    if X[l] > X0[n]:
                        agi[j - 1] = agi[j - 1]
                        agi[j] = ag[m][n]
                    if X[l] < X0[n]:
                        agi[j - 1] = ag[m][n]
                        agi[j] = agi[j]
                else:
                    break
            break

# 循环调用子函数
for p in range(5):
    for q in range(101):
        angle_function(p, q)
print(ag)

如上，循环调用子函数，结果大部分为零

import numpy as np

X0 = np.arange(-1, 101, 1.0)  # 炮检距（中心点即目标点），-1-100
X = np.zeros(90)  # 射线经过的水平距离
ag = np.zeros((5, 101))  # 找到适合水平距离的粗始入射角变量，5行101列适用于4层100个炮检距
agi = np.arange(0, 90, 1.0)  # 设置入射角数组，1度为步长，0-89
a = np.zeros((5, 101))  # 反射点处的入射角，5行101列适用于4层100个炮检距
Vp = [0, 3700, 2400, 3000, 2000]  # 层状速度数组
H = [0, 60, 20, 40, 20]  # 层厚度数组


def angle_function(m, n):  # 定义子函数，计算层数为n、炮检距为m的入射角
    for j in range(90):
        for i in range(m + 1):
            P = np.sin(agi[j] * np.pi / 180) / Vp[1]
            # print(P*Vp[i], 1 - (P * Vp[i]) ** 2)
            X[j] += 2 * H[i] * P * Vp[i] / np.sqrt(1 - (P * Vp[i]) ** 2)
        if X[j - 1] < X0[n] < X[j]:  # 适合水平距离时停止增加入射角角度
            for l in range(50):  # 二分法精确化入射角
                ag[m][n] = (agi[j - 1] + agi[j]) / 2.0
                for k in range(m + 1):
                    P = np.sin(ag[m][1] * np.pi / 180) / Vp[1]
                    X[l] += 2 * H[k] * P * Vp[k] / np.sqrt(1 - (P * Vp[k]) ** 2)
                if abs(X[l] - X0[n]) > 0.5:
                    if X[l] > X0[n]:
                        agi[j - 1] = agi[j - 1]
                        agi[j] = ag[m][n]
                    if X[l] < X0[n]:
                        agi[j - 1] = ag[m][n]
                        agi[j] = agi[j]
                else:
                    break
            break


angle_function(4, 100)
angle_function(4, 99)
angle_function(4, 98)
angle_function(4, 97)
angle_function(4, 96)
angle_function(4, 95)
angle_function(4, 94)
angle_function(4, 93)

print(ag)

这样一行一行调用，就能正常计算出ag。难道真的要一行一行的调用吗o(╥﹏╥)oo(╥﹏╥)o

Answer 1

import numpy as np
 
X0 = np.arange(-1, 101, 1.0)  # 炮检距（中心点即目标点），-1-100
X = np.zeros(90)  # 射线经过的水平距离
ag = np.zeros((5, 101))  # 找到适合水平距离的粗始入射角变量，5行101列适用于4层100个炮检距
agi = np.arange(0, 90, 1.0)  # 设置入射角数组，1度为步长，0-89
a = np.zeros((5, 101))  # 反射点处的入射角，5行101列适用于4层100个炮检距
Vp = [0, 3700, 2400, 3000, 2000]  # 层状速度数组
H = [0, 60, 20, 40, 20]  # 层厚度数组
 
def angle_function(m, n):  # 定义子函数，计算层数为n、炮检距为m的入射角
    for j in range(90):
        for i in range(m + 1):
            P = np.sin(agi[j] * np.pi / 180) / Vp[1]
            # print(P*Vp[i], 1 - (P * Vp[i]) ** 2)
            X[j] += 2 * H[i] * P * Vp[i] / np.sqrt(1 - (P * Vp[i]) ** 2)
        if X[j - 1] < X0[n] < X[j]:  # 适合水平距离时停止增加入射角角度
            for l in range(50):  # 二分法精确化入射角
                ag[m][n] = (agi[j - 1] + agi[j]) / 2.0
                for k in range(m + 1):
                    P = np.sin(ag[m][1] * np.pi / 180) / Vp[1]
                    X[l] += 2 * H[k] * P * Vp[k] / np.sqrt(1 - (P * Vp[k]) ** 2)
                if abs(X[l] - X0[n]) > 0.5:
                    if X[l] > X0[n]:
                        agi[j - 1] = agi[j - 1]
                        agi[j] = ag[m][n]
                    if X[l] < X0[n]:
                        agi[j - 1] = ag[m][n]
                        agi[j] = agi[j]
                else:
                    return ag
            return ag
        

# 循环调用子函数
for i in range(100,92,-1):
    ag = angle_function(4, i)
print(ag)

把你的break换成return ag，这样有返回值，就可以在上一步的基础上进行继续迭代运算，这里调用

for i in range(100,92,-1):
    ag = angle_function(4, i)
print(ag)

等同于你的

angle_function(4, 100)
angle_function(4, 99)
angle_function(4, 98)
angle_function(4, 97)
angle_function(4, 96)
angle_function(4, 95)
angle_function(4, 94)
angle_function(4, 93)

print(ag)

你可以换成你之前那个循环就可以实现了