How do i use input again and again in python?

Functional approach or "look mum no loops!":

from itertools import chain, repeat

prompts = chain(["Enter a number: "], repeat("Not a number! Try again: "))
replies = map(input, prompts)
valid_response = next(filter(str.isdigit, replies))
print(valid_response)

Enter a number:  a
Not a number! Try again:  b
Not a number! Try again:  1
1

or if you want to have a "bad input" message separated from an input prompt as in other answers:

prompt_msg = "Enter a number: "
bad_input_msg = "Sorry, I didn't understand that."
prompts = chain([prompt_msg], repeat('\n'.join([bad_input_msg, prompt_msg])))
replies = map(input, prompts)
valid_response = next(filter(str.isdigit, replies))
print(valid_response)

Enter a number:  a
Sorry, I didn't understand that.
Enter a number:  b
Sorry, I didn't understand that.
Enter a number:  1
1

How does it work?

1. prompts = chain(["Enter a number: "], repeat("Not a number! Try again: "))
   

   This combination of itertools.chain and itertools.repeat will create an iterator which will yield strings "Enter a number: " once, and "Not a number! Try again: " an infinite number of times:

   for prompt in prompts:
       print(prompt)
   

   Enter a number: 
   Not a number! Try again: 
   Not a number! Try again: 
   Not a number! Try again: 
   # ... and so on
   

2. replies = map(input, prompts) - here map will apply all the prompts strings from the previous step to the input function. E.g.:

   for reply in replies:
       print(reply)
   

   Enter a number:  a
   a
   Not a number! Try again:  1
   1
   Not a number! Try again:  it doesn't care now
   it doesn't care now
   # and so on...
   

3. We use filter and str.isdigit to filter out those strings that contain only digits:

   only_digits = filter(str.isdigit, replies)
   for reply in only_digits:
       print(reply)
   

   Enter a number:  a
   Not a number! Try again:  1
   1
   Not a number! Try again:  2
   2
   Not a number! Try again:  b
   Not a number! Try again: # and so on...
   

   And to get only the first digits-only string we use next.

Other validation rules:

1. String methods: Of course you can use other string methods like str.isalpha to get only alphabetic strings, or str.isupper to get only uppercase. See docs for the full list.

2. Membership testing:
   There are several different ways to perform it. One of them is by using __contains__ method:

   from itertools import chain, repeat
   
   fruits = {'apple', 'orange', 'peach'}
   prompts = chain(["Enter a fruit: "], repeat("I don't know this one! Try again: "))
   replies = map(input, prompts)
   valid_response = next(filter(fruits.__contains__, replies))
   print(valid_response)
   

   Enter a fruit:  1
   I don't know this one! Try again:  foo
   I don't know this one! Try again:  apple
   apple
   

3. Numbers comparison:
   There are useful comparison methods which we can use here. For example, for __lt__ (<):

   from itertools import chain, repeat
   
   prompts = chain(["Enter a positive number:"], repeat("I need a positive number! Try again:"))
   replies = map(input, prompts)
   numeric_strings = filter(str.isnumeric, replies)
   numbers = map(float, numeric_strings)
   is_positive = (0.).__lt__
   valid_response = next(filter(is_positive, numbers))
   print(valid_response)
   

   Enter a positive number: a
   I need a positive number! Try again: -5
   I need a positive number! Try again: 0
   I need a positive number! Try again: 5
   5.0
   

   Or, if you don't like using dunder methods (dunder = double-underscore), you can always define your own function, or use the ones from the operator module.

4. Path existance:
   Here one can use pathlib library and its Path.exists method:

   from itertools import chain, repeat
   from pathlib import Path
   
   prompts = chain(["Enter a path: "], repeat("This path doesn't exist! Try again: "))
   replies = map(input, prompts)
   paths = map(Path, replies)
   valid_response = next(filter(Path.exists, paths))
   print(valid_response)
   

   Enter a path:  a b c
   This path doesn't exist! Try again:  1
   This path doesn't exist! Try again:  existing_file.txt
   existing_file.txt
   

Limiting number of tries:

If you don't want to torture a user by asking him something an infinite number of times, you can specify a limit in a call of itertools.repeat. This can be combined with providing a default value to the next function:

from itertools import chain, repeat

prompts = chain(["Enter a number:"], repeat("Not a number! Try again:", 2))
replies = map(input, prompts)
valid_response = next(filter(str.isdigit, replies), None)
print("You've failed miserably!" if valid_response is None else 'Well done!')

Enter a number: a
Not a number! Try again: b
Not a number! Try again: c
You've failed miserably!

Preprocessing input data:

Sometimes we don't want to reject an input if the user accidentally supplied it IN CAPS or with a space in the beginning or an end of the string. To take these simple mistakes into account we can preprocess the input data by applying str.lower and str.strip methods. For example, for the case of membership testing the code will look like this:

from itertools import chain, repeat

fruits = {'apple', 'orange', 'peach'}
prompts = chain(["Enter a fruit: "], repeat("I don't know this one! Try again: "))
replies = map(input, prompts)
lowercased_replies = map(str.lower, replies)
stripped_replies = map(str.strip, lowercased_replies)
valid_response = next(filter(fruits.__contains__, stripped_replies))
print(valid_response)

Enter a fruit:  duck
I don't know this one! Try again:     Orange
orange

In the case when you have many functions to use for preprocessing, it might be easier to use a function performing a function composition. For example, using the one from here:

from itertools import chain, repeat

from lz.functional import compose

fruits = {'apple', 'orange', 'peach'}
prompts = chain(["Enter a fruit: "], repeat("I don't know this one! Try again: "))
replies = map(input, prompts)
process = compose(str.strip, str.lower)  # you can add more functions here
processed_replies = map(process, replies)
valid_response = next(filter(fruits.__contains__, processed_replies))
print(valid_response)

Enter a fruit:  potato
I don't know this one! Try again:   PEACH
peach

Combining validation rules:

For a simple case, for example, when the program asks for age between 1 and 120, one can just add another filter:

from itertools import chain, repeat

prompt_msg = "Enter your age (1-120): "
bad_input_msg = "Wrong input."
prompts = chain([prompt_msg], repeat('\n'.join([bad_input_msg, prompt_msg])))
replies = map(input, prompts)
numeric_replies = filter(str.isdigit, replies)
ages = map(int, numeric_replies)
positive_ages = filter((0).__lt__, ages)
not_too_big_ages = filter((120).__ge__, positive_ages)
valid_response = next(not_too_big_ages)
print(valid_response)

But in the case when there are many rules, it's better to implement a function performing a logical conjunction. In the following example I will use a ready one from here:

from functools import partial
from itertools import chain, repeat

from lz.logical import conjoin


def is_one_letter(string: str) -> bool:
    return len(string) == 1


rules = [str.isalpha, str.isupper, is_one_letter, 'C'.__le__, 'P'.__ge__]

prompt_msg = "Enter a letter (C-P): "
bad_input_msg = "Wrong input."
prompts = chain([prompt_msg], repeat('\n'.join([bad_input_msg, prompt_msg])))
replies = map(input, prompts)
valid_response = next(filter(conjoin(*rules), replies))
print(valid_response)

Enter a letter (C-P):  5
Wrong input.
Enter a letter (C-P):  f
Wrong input.
Enter a letter (C-P):  CDE
Wrong input.
Enter a letter (C-P):  Q
Wrong input.
Enter a letter (C-P):  N
N

Unfortunately, if someone needs a custom message for each failed case, then, I'm afraid, there is no pretty functional way. Or, at least, I couldn't find one.

How do I take user input again and again in Python?

How do you get a repeated input in Python?

How does Python handle multiple inputs?

How do you input a while loop in Python?