Ständig auffordert Benutzer für die Eingabe in Python

Können Sie knock out alle drei Funktion Anforderungen durch die Kapselung jeder Schritt des Programms. Anstatt der Schleife innerhalb einer Funktion, werden wir main control loop, und wir Steuern den Fluss durch die übergabe von Daten in die und aus der Funktionsaufrufe.

Lassen Sie uns Bearbeiten Sie Ihre input_numbers() - Funktion ein bisschen.

def get_input_number():
    num = int(raw_input("Enter a positive integer no greater than 42 "))
    if num <= 0 or num > 42:
        print "Invalid input.  Try again "
        get_input_number()
    else: 
        return num

So, anstatt input_numbers die Schleife Steuern, sowie die Verarbeitung von Eingaben und Validierung, müssen wir es tun nur das, was sein name impliziert: Es fragt für die Eingabe, überprüft Sie, und dann, wenn es gut ist, es gibt den Wert an den Aufrufer, aber wenn es schlecht ist, schreibt er eine Nachricht und ruft sich selbst erneut auf die Benutzer eingeben können, gute Eingabe.

Die nächste Funktion werden wir gerade aus der Liste der Anforderungen. Aus all den zahlen, die der Benutzer eingibt, wir müssen finden der größte. Aus der Sprache allein, können wir feststellen, dass wir durch eine Reihe von zahlen, und somit ist dies ein guter Ort, um zu brechen eine Liste. Angenommen, wir speichern alle Benutzer-Eingabe in einer Liste an, wir können dann passieren, dass die Liste auf eine Funktion, und führen Sie Operationen auf Sie, wie so.

def get_greatest_number(input_list):
    highest = input_list[0]
    for i in input_list:
        if i > highest:
            highest = i
    return highest

Setzen wir das erste element der Liste in eine variable highest und überprüfen Sie dann alle anderen Elemente in der Liste vor, der Ausgangswert. Wenn wir einen finden, der ist größer, wir weisen die highest variable zu dem element, das grösser war. Wenn wir das tun dies für jedes element in der Liste, die Nummer im inneren des höchsten wird jetzt sein, nur dass die höchste Zahl, und so werden wir es zurück an das Hauptprogramm.

Ähnlich, wir können das gleiche tun für die Suche nach dem kleinsten.

def get_smallest_number(input_list):
    smallest = input_list[0]
    for i in input_list:
        if i < smallest:
            smallest = i
    return smallest

Schließlich kommen wir zu unserem main-loop. Hier deklarieren wir eine leere Liste number_list zu speichern, werden alle zahlen. Und verwenden wir die Summe, die als unsere Schleifenbedingung.

if __name__ == '__main__':
    number_list = []
    while sum(number_list) < 179:
        number_list.append(get_input_number())

In den Körper der Schleife rufen wir unsere get_input_number() und fügen Sie das Ergebnis mit der Liste die wir gemacht haben. Sobald die Summe der zahlen in der Liste überschreiten, 179, die while-Schleife beendet, und wir können endlich zeigen Sie dem Benutzer die Ergebnisse.

    print 
    print '-------------------------'
    print 'total of numbers entered: %d' % sum(number_list)
    print 'greatest number entered: %d' % get_greatest_number(number_list)
    print 'smallest number entered: %d' % get_smallest_number(number_list)

Hier können wir die get_greatest_number und get_smallest_number wir gemacht, und wir geben Ihnen die Liste von zahlen als argument. Sie werden loop-obwohl die Listen, und dann wieder die entsprechenden Werte für die print-Anweisungen.

def get_int(prompt=''):
    while True:
        try:
            return int(raw_input(prompt))
        except ValueError:
            pass

def get_values():
    values = []
    total  = 0
    while total <= 179:
        val = get_int('Enter a positive integer <= 42: ')
        if 0 <= val <= 42:
            values.append(val)
            total += val
    return values

def print_info(values):
    print 'Sum is {}'.format(sum(values))
    print 'Largest value is {}'.format(max(values))
    print 'Smallest value is {}'.format(min(values))

def main():
    values = get_values()
    print_info(values)

if __name__=="__main__":
    main()

hier einige bekannte tricks:

    def min_and_max(your_num_list)
        min=your_num_list[0]
        max=your_num_list[0]
        for num in your_num_list:
            if num < min:
                min=num
            if max > num
                max=num
        return min,max

Danke an alle die antworteten. Ich habe geschrieben, die folgenden code und es funktioniert fast perfekt, außer dem letzten Modul. Wenn Sie das Programm beenden, nachdem der erste ausgeführt (durch drücken von 0), wird Sie verlassen, aber wenn man es ein zweites mal drücken 0 wird es nicht beenden. Werde es einfach zurück an den Anfang des Programms. Ich weiß nicht, warum.

Hinweis: Die Belegung hat verschiedene Anforderungen, die ich hatte einbauen in meinen code. Daher die unnötige Module, Globale Variablen und Kommentare.

maxNum = 42  # declares global variable maxNum
target = 179  # declares global variable target

def user_input():  # prompts user to input a number 42 or less until all add up to 179
    x = 0
    nums = []    
    while sum(nums) <= target:
        nums.append(int(raw_input("Enter a number: ")))
        if int(nums[x]) > int(maxNum):
            print "Number cannot exceed 42."
            user_input()
        else:
            x += 1
    print_nums(nums,x)

def print_nums(nums,x):  # prints the sum of the numbers, the smallest, and the largest 
    print "Sum of all numbers is", sum(nums)
    nums.sort()
    x -= 1
    print "Largest number entered is", nums[x]
    print "Smallest number entered is", nums[0]
    decide()

def decide():  # allows user to continue the program or exit 
    exit = raw_input("<9 to enter a new set of number.  0 to exit.> ")
    while True:
        if int(exit) == 0:
            return
        elif int(exit) == 9:
            user_input()

user_input()