Empêcher Python d'aller à la toute dernière déclaration

Question

J'écris actuellement un programme qui résoudra le théorème de Pythagore. Cependant, j'ai un bug dans le programme. Chaque fois que je mets un nombre négatif pour la longueur A ou B, il imprime "A ne peut pas être inférieur à zéro" mais va de l'avant et résout de toute façon pour C et imprime la longueur de C même si l'utilisateur n'a pas encore saisi B. Comment puis-je le faire lorsque l'utilisateur saisit un nombre négatif, il imprime l'instruction "A ne peut pas être inférieur à zéro", puis boucle à nouveau pour saisir une longueur pour le côté, au lieu de la façon dont il est maintenant là où il imprime le Déclaration qu'il redirige vers la fin?

Voici mon code:

 import math
    print"This program will solve the pythagorean theorem for you"
    unit=raw_input('Enter the unit you will be using')
    a=float(raw_input('Enter the length of side a'))
    if a<=0:
      print"A cannot be less than zero"
    else:
        b=float(raw_input('Enter the length of side b'))
    if b<=0:
      print"B cannot be less than zero"
    else:
        c2=(a**2)+(b**2)
        c=math.sqrt(c2)
        c=str(c)
        print "The length of side C is: "+ c + " " + unit + "."

Answer 1

Eh bien, pour commencer, si vous souhaitez constamment vérifier vos entrées, vous devrez utiliser une boucle. Comme dans, le PSUedocode pour l'algorithme doit être:

Loop Begin
Check the value of a and b
If a or b is less than 0 then ask for input again
Otherwise, continue

Veuillez noter que l'algorithme a courir au moins une fois que.

C'est essentiellement ainsi que le pseusecode devrait ressembler. Donc, c'est un cas où vous pouvez utiliser un do-while Construction de boucle. Dans Python, il n'y a pas quelque chose comme ça, donc nous imiter ce:

import math


def take_in():
    a = raw_input("Enter the value of side a -> ")
    b = raw_input("Enter the value of side b -> ")

    # Trying to convert to a float
    try:
        a, b = float(a), float(b)
        # If successfully converted, then we return
        if a > 0 and b > 0:
            return a, b
    except ValueError:
        pass
    # If we cannot return, then we return false, with a nice comment

    print "Invalid input"
    return False


def main():
    # Calling the function at least once
    valid = take_in()

    # While we are not getting valid input, we keep calling the function
    while not valid:
        # Assigning the value to valid
        valid = take_in()

    # Breaking the return tuple into a and b
    a, b = valid
    print math.sqrt(a ** 2 + b ** 2)


if __name__ == '__main__':
    main()

Answer 2

Vous avez manqué un niveau de fondation. Essayez-le comme ceci:

if a<0:
  print"A cannot be less than zero"
else:
    b=raw_input('Enter the length of side b')
    b=float(b)
    if b<0:
        print"B cannot be less than zero"
    else:
        c2=(a**2)+(b**2)
        c=math.sqrt(c2)
        c=str(c)
        print "The length of side C is: "+ c + " " + unit + "."

Answer 3

Essayez d'éviter d'utiliser Nested if Lors de la conception du flux du programme. Cela conduit à ce type de bug (manquant un niveau d'indentation). Gros morceaux de code à l'intérieur if blocs et plusieurs imbriqués if Les blocs rendent le programme plus difficile à suivre et raisonne.

Au lieu de cela, vous pouvez demander à nouveau jusqu'à ce que l'entrée soit valide:

a = -1
while a < 0:
    try:
        a=float(raw_input('Enter the length of side a'))
    except ValueError:
        pass
    if a<0:
        print "A cannot be less than zero"

Les conseils de Fred sont bons, enveloppez-le dans une fonction de réutilisation:

def validate(initial, prompt, test, message, typecast=str):
    value = initial
    while not test(value):
        try:
            value = typecast(raw_input(prompt))
        except ValueError:
            print "Invalid value"
            continue

        if not test(value):
            print message
            continue

        return value

Puis utilisez:

a = validate(
    initial = -1, 
    prompt = 'Enter the length of side A', 
    test = lambda x: x >= 0,
    message = "A cannot be less than zero",
    typecast = float
)
b = validate(
    initial = -1, 
    prompt = 'Enter the length of side B', 
    test = lambda x: x >= 0,
    message = "B cannot be less than zero",
    typecast = float,
)

Answer 4

Avertissement: j'utilise une version différente de Python pour que le kilométrage puisse varier

import math

a = 0
b = 0

def py_theorem(a, b):
    return(a**2 + b**2)


unit = raw_input('Enter the unit you will be using: ')

while a <= 0:
a = float(raw_input('Enter the length of side A: '))
if a <= 0:
    print('A cannot be less than 0.')

while b <= 0:
b = float(raw_input('Enter the length of side B: '))
if b <= 0:
    print('B cannot be less than 0.')

print('The length of the 3rd side C is %d %s') % (py_theorem(a,b), unit)

Maintenant, si vous regardez mon code A, B est 0 initialement afin que vous puissiez exécuter les boucles WHOR (sinon vous obtenez une erreur, l'interprète ne connaît pas un, B jusqu'à ce point). Ensuite, il répète les instructions demandant un, B respectivement jusqu'à ce que vous obteniez une entrée valide (valide dans un sens générique, nous ne vérifions pas d'erreur, que se passe-t-il si vous utilisez une chaîne ??>. <) Maintenant, l'impression est un peu funky, Je examinerais certainement les documents Python et voir ce que sont les% d% s, etc. Ensuite, nous passons le retour de la méthode (voir le def py_theorem en haut) sur la chaîne avec une unité. Notez que la fonction prend respectivement deux arguments A, B.