python - 如何获得在另一个函数中调用的函数以返回值？ PYTHON

Question

我正在开发一个罗马数字转换器+罗马数字计算器项目。

我现在陷入了计算器部分，因为我无法让函数返回我需要继续的值。

我这样做的方式是定义了一堆函数。这是我调用它们的顺序。

romanCalculator(number,operator)

该函数接受输入数字，例如 x+v。将它们分成 2 个罗马数字，num1=x，num2=v。

然后这些号码将分别发送至 romanValidation(num1)

此函数检查输入的罗马数字是否是真正的罗马数字，然后将它们发送到第三个函数 romanTOarab(num1) 。这就是问题开始的地方。

romanTOarab(num1)将罗马数字转换为阿拉伯数字，因此 num1=x 将变为 10。我想要 romanTOarab(num1)将 num1 和 num2 的值返回给函数 romanCalculator(number,operator)这样我就在romanCalculator(number,operator)内可以写这样的东西:

num1Trans = romanValidation(num1)

num2Trans = romanValidation(num2)

并且应该使 num1Trans = 10 和 num2Trans = 5 的值。但是，当我运行代码并打印 num1Trans 或 num2Trans 时，我得到的只是无。

我该如何解决这个问题？

另外，请原谅我的英语! :)这是我为提到的所有功能编写的代码。

def romanCalculator(number,operator):

    number = number.replace(" ", "")                                
    num1,num2 = number.split(operator)                              


    num1Trans = romanValidation(num1)
    num2Trans = romanValidation(num2)

    print(num1, ":" ,num1Trans)
    print(num2, ":" ,num2Trans)
    print(operator)

def romanValidation(number):

    i = 0 

    while i < len(number):

        s = number[i]

        if i < (len(number)-1):                                     # Kollar så att det är fler än en bokstav.

            if letterMap[s] < letterMap[number[i+1]]:               # Kollar ifall bokstaven som ska analyseras är mindre än den efter.
                temp = letterMap[number[i+1]] - letterMap[s]        # Tar ut skillnaden mellan dem i värde.
                control = temp / 10**(len(str(temp))-1)             # Gör om skillnaden så att den alltid blir i storleksordning 10^0.

                if control == 9.0 or control == 4.0:                # Om kontrollen är ==9 eller ==4 så kommer bokstäverna i en giltig följd.
                    try:
                        temp = letterMap[number[i+2]]               # Testar om det finns en tredje boskav efter den andra.
                        print(temp)
                        if letterMap[s] <= temp:                    # Testar om denna tredje boskatav är störren än den första,
                            print(SPACE,number,WRONG)               # Om så är fallet är det inget giltigt tal.
                            print("Ett romerskt tal kan bara ha en mindre siffra följt av en större siffra.")
                            main()
                    except:                                         # Om allt är som det ska hoppar vi över den andra bosktaven eftersom den nu också är analyserad.
                        pass
                        #i += 1
                else:
                    print(SPACE,number,WRONG)
                    print("Skilladen mellan mellan en mindra siffra och en större siffrar får endast vara 4*10^x eller 9*10^x.")
                    main()

            elif letterMap[s] == letterMap[number[i+1]]:            # Testar om följaden bosktav är av samma storlek som den som analyseras.

                i += 1                                              # Hoppar en boskatav fram i talet.
                temp = letterMap[s]

                if temp == 5 or temp == 50 or temp == 500:
                    print(SPACE,number,WRONG)
                    print("Romerska tecknena V, L och D får inte komma som 2 likada i följd. (ex: VV eller DD.)")
                    main()

                try:
                    temp = letterMap[number[i+1]]                   # Testar om det är 3 likadan bokstäver i följd.
                    if letterMap[s] == letterMap[number[i+1]]:
                        i += 1

                    elif letterMap[s] < temp:                      # Testar om denna tredje boskatav är störren än den första,
                            print(SPACE,number,WRONG)               # Om så är fallet är det inget giltigt tal.
                            print("Ett romerskt tal kan bara ha en mindre siffra följt av en större siffra.")
                            main()
                except:
                    pass

                try:
                    temp = letterMap[number[i+1]]                   # Testar om det kommer 4 likadana boksträver i följd.
                    if letterMap[s] == letterMap[number[i+1]]:
                        print(SPACE,number,WRONG)
                        print("Ett romerskt tal kan max innehålla samma tecken 3 gånger på rad.")
                        main()

                    elif letterMap[s] < temp:                       # Testar om denna tredje boskatav är störren än den första,
                            print(SPACE,number,WRONG)               # Om så är fallet är det inget giltigt tal.
                            print("Ett romerskt tal kan bara ha en mindre siffra följt av en större siffra.")
                            main()

                except:
                    pass

        i += 1    

    romanTOarab(number)

def romanTOarab(number):

    total = 0
    i = 0


    while i < len(number):

        s = number[i]
        if i < (len(number)-1):                                     # För att kunna köra tal som bara innehåller ett tecken.

            if letterMap[s] < letterMap[number[i+1]]:               # Kollar när ett mindre tal är följt av ett större (IV = 5-1 = 4)
                total += (letterMap[number[i+1]] - letterMap[s])
                i += 1                                              # Eftersom att denna sats kollar 2 tecken på samma gång så hopper vi över det andra.

            else:
                total += letterMap[s]                               # Alla andra tecken är bara att rakt översätta och lägga på totalen.

        else:
            total += letterMap[s]                                   # När det bara är ett tal som ska översättas.


        i += 1


    print("Resultat:",total)

    return total   

Answer 1

非常简单的修复，您只需在 romanValidation 中省略 return 即可。该函数的最后一行应更改为

romanTOarab(number)

至

return romanTOarab(number)