ﻩ并啵了你一下ﻩsong宋
2021-04-20 15:12
采纳率: 100%
浏览 67
已采纳

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

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

  • 写回答
  • 好问题 提建议
  • 关注问题
  • 收藏
  • 邀请回答

7条回答 默认 最新

  • kaili_ya 2021-04-20 16:34
    已采纳
    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)

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

    已采纳该答案
    评论
    解决 1 无用
    打赏 举报
  • 肯定可以循环调用,建议调试一下,或者写打印语句测试一下。

    评论
    解决 无用
    打赏 举报
  • 循环调用结果如下:

    一行一行调用结果如下:

    评论
    解决 无用
    打赏 举报
  • 在函数里写过打印语句,没有打印输出

    评论
    解决 无用
    打赏 举报
  • 另外请问怎么调试呀

    评论
    解决 无用
    打赏 举报
  • 有问必答小助手 2021-04-20 18:07

    您好,我是有问必答小助手,你的问题已经有小伙伴为您解答了问题,您看下是否解决了您的问题,可以追评进行沟通哦~

    如果有您比较满意的答案 / 帮您提供解决思路的答案,可以点击【采纳】按钮,给回答的小伙伴一些鼓励哦~~

    ps:问答VIP仅需29元,即可享受5次/月 有问必答服务,了解详情>>>https://vip.csdn.net/askvip?utm_source=1146287632

    评论
    解决 无用
    打赏 举报
  • 有问必答小助手 2021-04-21 18:08

    非常感谢您使用有问必答服务,为了后续更快速的帮您解决问题,现诚邀您参与有问必答体验反馈。您的建议将会运用到我们的产品优化中,希望能得到您的支持与协助!

    速戳参与调研>>>https://t.csdnimg.cn/Kf0y

    评论
    解决 无用
    打赏 举报

相关推荐 更多相似问题