询问用户输入，直到他们给出有效的响应

Question

我正在编写一个接受用户输入的程序。

#note: Python 2.7 users should use `raw_input`, the equivalent of 3.X's `input`
age = int(input("Please enter your age: "))
if age >= 18: 
    print("You are able to vote in the United States!")
else:
    print("You are not able to vote in the United States.")

只要用户输入有意义的数据，程序就会按预期工作。

Please enter your age: 23
You are able to vote in the United States!

但如果用户输入无效数据，它就会失败：

Please enter your age: dickety six
Traceback (most recent call last):
  File "canyouvote.py", line 1, in <module>
    age = int(input("Please enter your age: "))
ValueError: invalid literal for int() with base 10: 'dickety six'

我希望程序再次请求输入，而不是崩溃。像这样：

Please enter your age: dickety six
Sorry, I didn't understand that.
Please enter your age: 26
You are able to vote in the United States!

我如何请求有效输入而不是崩溃或接受无效值（例如-1）？

Answer 1

尽管被接受的答案是惊人的。我还想分享解决此问题的快速技巧。 （这也解决了负年龄问题。）

f=lambda age: (age.isdigit() and ((int(age)>=18  and "Can vote" ) or "Cannot vote")) or \
f(input("invalid input. Try again\nPlease enter your age: "))
print(f(input("Please enter your age: ")))

PS 此代码适用于 python 3.x。

Answer 2

使用点击：

点击是一个命令行界面库，它提供了向用户询问有效响应的功能。

简单的例子：

import click

number = click.prompt('Please enter a number', type=float)
print(number)

Please enter a number: 
 a
Error: a is not a valid floating point value
Please enter a number: 
 10
10.0

注意它如何自动将字符串值转换为浮点数。

检查值是否在范围内：

有不同的自定义类型 提供。要获取特定范围内的数字，我们可以使用 IntRange：

age = click.prompt("What's your age?", type=click.IntRange(1, 120))
print(age)

What's your age?: 
 a
Error: a is not a valid integer
What's your age?: 
 0
Error: 0 is not in the valid range of 1 to 120.
What's your age?: 
 5
5

我们还可以仅指定限制之一，min 或 max：

age = click.prompt("What's your age?", type=click.IntRange(min=14))
print(age)

What's your age?: 
 0
Error: 0 is smaller than the minimum valid value 14.
What's your age?: 
 18
18

成员资格测试：

使用 click.Choice 类型。默认情况下，此检查区分大小写。

choices = {'apple', 'orange', 'peach'}
choice = click.prompt('Provide a fruit', type=click.Choice(choices, case_sensitive=False))
print(choice)

Provide a fruit (apple, peach, orange): 
 banana
Error: invalid choice: banana. (choose from apple, peach, orange)
Provide a fruit (apple, peach, orange): 
 OrAnGe
orange

使用路径和文件：

使用 click.Path 类型，我们可以检查现有路径并解析它们：

path = click.prompt('Provide path', type=click.Path(exists=True, resolve_path=True))
print(path)

Provide path: 
 nonexistent
Error: Path "nonexistent" does not exist.
Provide path: 
 existing_folder
'/path/to/existing_folder

可以通过 click.File 来读取和写入文件：

file = click.prompt('In which file to write data?', type=click.File('w'))
with file.open():
    file.write('Hello!')
# More info about `lazy=True` at:
# https://click.palletsprojects.com/en/7.x/arguments/#file-opening-safety
file = click.prompt('Which file you wanna read?', type=click.File(lazy=True))
with file.open():
    print(file.read())

In which file to write data?: 
         # <-- provided an empty string, which is an illegal name for a file
In which file to write data?: 
 some_file.txt
Which file you wanna read?: 
 nonexistent.txt
Error: Could not open file: nonexistent.txt: No such file or directory
Which file you wanna read?: 
 some_file.txt
Hello!

其他示例：

密码确认：

password = click.prompt('Enter password', hide_input=True, confirmation_prompt=True)
print(password)

Enter password: 
 ······
Repeat for confirmation: 
 ·
Error: the two entered values do not match
Enter password: 
 ······
Repeat for confirmation: 
 ······
qwerty

默认值：

在这种情况下，只需按 Enter （或您使用的任何键）而不输入值，将为您提供默认值：

number = click.prompt('Please enter a number', type=int, default=42)
print(number)

Please enter a number [42]: 
 a
Error: a is not a valid integer
Please enter a number [42]: 
 
42

Answer 3

我是 Unix 哲学“做一件事并把它做好”的忠实粉丝。捕获用户输入并验证它是两个独立的步骤：

• 使用 get_input 提示用户输入，直到输入正确 使用
• 可传递给 的 validator 函数进行验证get_input

它可以保持简单（Python 3.8+，带有海象运算符）：

def get_input(
    prompt="Enter a value: ",
    validator=lambda x: True,
    error_message="Invalid input. Please try again.",
):
    while not validator(value := input(prompt)):
        print(error_message)
    return value

def is_positive_int(value):
    try:
        return int(value) >= 0
    except ValueError:
        return False

if __name__ == "__main__":
    val = get_input("Give a positive number: ", is_positive_int)
    print(f"OK, thanks for {val}")

示例运行：

Give a positive number: -5
Invalid input. Please try again.
Give a positive number: asdf
Invalid input. Please try again.
Give a positive number:
Invalid input. Please try again.
Give a positive number: 42
OK, thanks for 42

---

在Python中< 3.8 您可以像这样使用 get_input：

def get_input(
    prompt="Enter a value: ",
    validator=lambda x: True,
    error_message="Invalid input. Please try again.",
):
    while True:
        value = input(prompt)
        if validator(value):
            return value
        print(error_message)

您还可以处理 KeyboardInterrupt 并在终止应用程序之前打印一条友好的退出消息。如果需要，可以使用计数器来限制允许的重试次数。

Answer 4

所以，我最近在搞类似的事情，我想出了以下解决方案，它使用一种获取拒绝垃圾输入的方法，甚至在以任何逻辑方式检查它之前。

read_single_keypress() 礼貌 https://stackoverflow.com/a/6599441/4532996

def read_single_keypress() -> str:
    """Waits for a single keypress on stdin.
    -- from :: https://stackoverflow.com/a/6599441/4532996
    """

    import termios, fcntl, sys, os
    fd = sys.stdin.fileno()
    # save old state
    flags_save = fcntl.fcntl(fd, fcntl.F_GETFL)
    attrs_save = termios.tcgetattr(fd)
    # make raw - the way to do this comes from the termios(3) man page.
    attrs = list(attrs_save) # copy the stored version to update
    # iflag
    attrs[0] &= ~(termios.IGNBRK | termios.BRKINT | termios.PARMRK
                  | termios.ISTRIP | termios.INLCR | termios. IGNCR
                  | termios.ICRNL | termios.IXON )
    # oflag
    attrs[1] &= ~termios.OPOST
    # cflag
    attrs[2] &= ~(termios.CSIZE | termios. PARENB)
    attrs[2] |= termios.CS8
    # lflag
    attrs[3] &= ~(termios.ECHONL | termios.ECHO | termios.ICANON
                  | termios.ISIG | termios.IEXTEN)
    termios.tcsetattr(fd, termios.TCSANOW, attrs)
    # turn off non-blocking
    fcntl.fcntl(fd, fcntl.F_SETFL, flags_save & ~os.O_NONBLOCK)
    # read a single keystroke
    try:
        ret = sys.stdin.read(1) # returns a single character
    except KeyboardInterrupt:
        ret = 0
    finally:
        # restore old state
        termios.tcsetattr(fd, termios.TCSAFLUSH, attrs_save)
        fcntl.fcntl(fd, fcntl.F_SETFL, flags_save)
    return ret

def until_not_multi(chars) -> str:
    """read stdin until !(chars)"""
    import sys
    chars = list(chars)
    y = ""
    sys.stdout.flush()
    while True:
        i = read_single_keypress()
        _ = sys.stdout.write(i)
        sys.stdout.flush()
        if i not in chars:
            break
        y += i
    return y

def _can_you_vote() -> str:
    """a practical example:
    test if a user can vote based purely on keypresses"""
    print("can you vote? age : ", end="")
    x = int("0" + until_not_multi("0123456789"))
    if not x:
        print("\nsorry, age can only consist of digits.")
        return
    print("your age is", x, "\nYou can vote!" if x >= 18 else "Sorry! you can't vote")

_can_you_vote()

您可以此处找到完整的模块。

示例：

$ ./input_constrain.py
can you vote? age : a
sorry, age can only consist of digits.
$ ./input_constrain.py 
can you vote? age : 23<RETURN>
your age is 23
You can vote!
$ _

请注意，此实现的本质是，一旦读取到非数字内容，它就会关闭标准输入。我没有在 a 之后按 Enter，但我需要在数字之后按 Enter。

您可以将其与同一模块中的 thismany() 函数合并，以仅允许三位数字。

Answer 5

使用 try-except 处理错误并再次重复：

while True:
    try:
        age = int(input("Please enter your age: "))
        if age >= 18:
            print("You are able to vote in the United States!")
        else:
            print("You are not able to vote in the United States.")
    except Exception as e:
        print("please enter number")

Answer 6

基于 Daniel Q 和 Patrick Artner 的出色建议，
这是一个更通用的解决方案。

# Assuming Python3
import sys

class ValidationError(ValueError):  # thanks Patrick Artner
    pass

def validate_input(prompt, cast=str, cond=(lambda x: True), onerror=None):
    if onerror==None: onerror = {}
    while True:
        try:
            data = cast(input(prompt))
            if not cond(data): raise ValidationError
            return data
        except tuple(onerror.keys()) as e:  # thanks Daniel Q
            print(onerror[type(e)], file=sys.stderr)

我选择显式的 if 和 raise 语句而不是 assert，
因为断言检查可能被关闭，
而验证应始终开启以提供稳健性。

这可用于获取不同类型的输入，
具有不同的验证条件。
例如：

# No validation, equivalent to simple input:
anystr = validate_input("Enter any string: ")

# Get a string containing only letters:
letters = validate_input("Enter letters: ",
    cond=str.isalpha,
    onerror={ValidationError: "Only letters, please!"})

# Get a float in [0, 100]:
percentage = validate_input("Percentage? ",
    cast=float, cond=lambda x: 0.0<=x<=100.0,
    onerror={ValidationError: "Must be between 0 and 100!",
             ValueError: "Not a number!"})

或者，回答原来的问题：

age = validate_input("Please enter your age: ",
        cast=int, cond=lambda a:0<=a<150,
        onerror={ValidationError: "Enter a plausible age, please!",
                 ValueError: "Enter an integer, please!"})
if age >= 18: 
    print("You are able to vote in the United States!")
else:
    print("You are not able to vote in the United States.")

Answer 7

def validate_age(age):
    if age >=0 :
        return True
    return False

while True:
    try:
        age = int(raw_input("Please enter your age:"))
        if validate_age(age): break
    except ValueError:
        print "Error: Invalid age."

Answer 8

好问题！您可以尝试以下代码。 =)

此代码使用 ast.literal_eval() 来查找输入的数据类型 (age)。然后它遵循以下算法：

1. 要求用户输入她/他的年龄。

   1.1。如果age是float或int数据类型：

   • 检查是否年龄>=18。如果 age>=18，则打印适当的输出并退出。

   • 检查是否0<年龄<18。如果0，则打印适当的输出并退出。

   • 如果age<=0，请用户再次输入有效的年龄数字，（即返回到步骤 1。）

   1.2。如果age不是float或int数据类型，则要求用户再次输入她/他的年龄（ie返回步骤 1。）







这是代码。

from ast import literal_eval

''' This function is used to identify the data type of input data.'''
def input_type(input_data):
    try:
        return type(literal_eval(input_data))
    except (ValueError, SyntaxError):
        return str

flag = True

while(flag):
    age = raw_input("Please enter your age: ")

    if input_type(age)==float or input_type(age)==int:
        if eval(age)>=18: 
            print("You are able to vote in the United States!") 
            flag = False 
        elif eval(age)>0 and eval(age)<18: 
            print("You are not able to vote in the United States.") 
            flag = False
        else: print("Please enter a valid number as your age.")

    else: print("Sorry, I didn't understand that.") 

Answer 9

试试这个：-

def takeInput(required):
  print 'ooo or OOO to exit'
  ans = raw_input('Enter: ')

  if not ans:
      print "You entered nothing...!"
      return takeInput(required) 

      ##  FOR Exit  ## 
  elif ans in ['ooo', 'OOO']:
    print "Closing instance."
    exit()

  else:
    if ans.isdigit():
      current = 'int'
    elif set('[~!@#$%^&*()_+{}":/\']+
).intersection(ans):
      current = 'other'
    elif isinstance(ans,basestring):
      current = 'str'        
    else:
      current = 'none'

  if required == current :
    return ans
  else:
    return takeInput(required)

## pass the value in which type you want [str/int/special character(as other )]
print "input: ", takeInput('str')

Answer 10

使用“while”语句直到用户输入一个真值，如果输入值不是数字或者是空值，则跳过它并尝试再次询问，依此类推。
例如，我试图真实地回答你的问题。如果我们假设我们的年龄在 1 到 150 之间，则接受输入值，否则它是错误的值。
要终止程序，用户可以使用 0 键并将其输入为值。

注意：阅读代码顶部的注释。

# If your input value is only a number then use "Value.isdigit() == False".
# If you need an input that is a text, you should remove "Value.isdigit() == False".
def Input(Message):
    Value = None
    while Value == None or Value.isdigit() == False:
        try:        
            Value = str(input(Message)).strip()
        except Exception:
            Value = None
    return Value

# Example:
age = 0
# If we suppose that our age is between 1 and 150 then input value accepted,
# else it's a wrong value.
while age <=0 or age >150:
    age = int(Input("Please enter your age: "))
    # For terminating program, the user can use 0 key and enter it as an a value.
    if age == 0:
        print("Terminating ...")
        exit(0)
        
if age >= 18 and age <=150: 
    print("You are able to vote in the United States!")
else:
    print("You are not able to vote in the United States.")

Answer 11

要通过验证和重试处理数字输入，请考虑使用 中的 int_input 函数typed-input¹ 库（其他函数，如 float_input、decimal_input 和还提供了datetime_input）。它简化了输入验证，确保类型安全，并为错误处理和自定义消息提供内置支持 - 所有这些都无需您自己编写重复的验证循环。

安装

通过 pip 安装 typed-input 库：

pip install typed-input

这是使用 int_input 的程序的更简洁版本：

from typed_input import int_input

age = int_input(
    prompt="Please enter your age: ", 
    min_value=1,  # Age must be a positive number
    type_error_message="Sorry, please enter a valid integer age."
)

if age >= 18:
    print("You are able to vote in the United States!")
else:
    print("You are not able to vote in the United States.")

示例用法：

Please enter your age: sixty six
Sorry, please enter a valid integer age.
Please enter your age: -5
Error: Value must be at least 1.
Please enter your age: 26
You are able to vote in the United States!

为什么使用 typed -输入？

1. 内置验证：自动重试，直到用户提供有效输入，确保用户友好的错误处理。
2. 可自定义提示：您可以指定界限（min_value、max_value）和自定义错误消息以获得更好的指导。
3. 更简洁的代码：避免重复的输入验证循环，从而节省开发时间。

---

¹ 披露：我是 typed-input。

Answer 12

您始终可以应用简单的 if-else 逻辑，并在代码中再添加一个 if 逻辑以及 for 循环。

while True:
     age = int(input("Please enter your age: "))
     if (age >= 18)  : 
         print("You are able to vote in the United States!")
     if (age < 18) & (age > 0):
         print("You are not able to vote in the United States.")
     else:
         print("Wrong characters, the input must be numeric")
         continue

这将是一个无限的厕所，你会被要求无限期地进入这个时代。

Answer 13

虽然 try/ except 块可以工作，但完成此任务的更快、更简洁的方法是使用 str.isdigit()。

while True:
    age = input("Please enter your age: ")
    if age.isdigit():
        age = int(age)
        break
    else:
        print("Invalid number '{age}'. Try again.".format(age=age))

if age >= 18: 
    print("You are able to vote in the United States!")
else:
    print("You are not able to vote in the United States.")

Answer 14

您可以编写更通用的逻辑，以允许用户仅输入特定次数，因为许多实际应用程序中都会出现相同的用例。

def getValidInt(iMaxAttemps = None):
  iCount = 0
  while True:
    # exit when maximum attempt limit has expired
    if iCount != None and iCount > iMaxAttemps:
       return 0     # return as default value

    i = raw_input("Enter no")
    try:
       i = int(i)
    except ValueError as e:
       print "Enter valid int value"
    else:
       break

    return i

age = getValidInt()
# do whatever you want to do.

Answer 15

您可以将输入语句设置为 while True 循环，以便它重复要求用户输入，然后在用户输入您想要的响应时中断该循环。您可以使用 try 和 except 块来处理无效响应。

while True:

    var = True

    try:
        age = int(input("Please enter your age: "))

    except ValueError:
        print("Invalid input.")
        var = False

    if var == True:
        if age >= 18:
                print("You are able to vote in the United States.")
                break
        else:
            print("You are not able to vote in the United States.")

var 变量的作用是，如果用户输入字符串而不是整数，程序将不会返回“您无法在美国投票”。

Answer 16

另一种使用输入验证的解决方案，使用自定义的 ValidationError 和整数输入的（可选）范围验证：

class ValidationError(ValueError): 
    """Special validation error - its message is supposed to be printed"""
    pass

def RangeValidator(text,num,r):
    """Generic validator - raises 'text' as ValidationError if 'num' not in range 'r'."""
    if num in r:
        return num
    raise ValidationError(text)

def ValidCol(c): 
    """Specialized column validator providing text and range."""
    return RangeValidator("Columns must be in the range of 0 to 3 (inclusive)", 
                          c, range(4))

def ValidRow(r): 
    """Specialized row validator providing text and range."""
    return RangeValidator("Rows must be in the range of 5 to 15(exclusive)",
                          r, range(5,15))

用法：

def GetInt(text, validator=None):
    """Aks user for integer input until a valid integer is given. If provided, 
    a 'validator' function takes the integer and either raises a 
    ValidationError to be printed or returns the valid number. 
    Non integers display a simple error message."""
    print()
    while True:
        n = input(text)
        try:
            n = int(n)

            return n if validator is None else validator(n)

        except ValueError as ve:
            # prints ValidationErrors directly - else generic message:
            if isinstance(ve, ValidationError):
                print(ve)
            else:
                print("Invalid input: ", n)


column = GetInt("Pleased enter column: ", ValidCol)
row = GetInt("Pleased enter row: ", ValidRow)
print( row, column)

输出：

Pleased enter column: 22
Columns must be in the range of 0 to 3 (inclusive)
Pleased enter column: -2
Columns must be in the range of 0 to 3 (inclusive)
Pleased enter column: 2
Pleased enter row: a
Invalid input:  a
Pleased enter row: 72
Rows must be in the range of 5 to 15(exclusive)
Pleased enter row: 9  

9, 2

Answer 17

使用递归函数持久用户输入：

字符串

def askName():
    return input("Write your name: ").strip() or askName()

name = askName()

整数

def askAge():
    try: return int(input("Enter your age: "))
    except ValueError: return askAge()

age = askAge()

，最后是问题要求：

def askAge():
    try: return int(input("Enter your age: "))
    except ValueError: return askAge()

age = askAge()

responseAge = [
    "You are able to vote in the United States!",
    "You are not able to vote in the United States.",
][int(age < 18)]

print(responseAge)

Answer 18

您可以尝试将其转换为整数，但如果不起作用，请要求用户重复。

while True:
    age = input('Please enter your age: ')
    try:
        age_int = int(age)
        if age_int >= 18:
            print('You can vote in the United States!')
        else:
            print('You cannot vote in the United States.')
        break
    except:
        print('Please enter a meaningful answer.')
        

只要用户没有输入有意义的答案，while 循环就会运行，但如果有意义则循环会中断。

Answer 19

使用 isdigit() 来检查字符串是否代表有效的整数。

您可以使用递归函数。

def ask():
    answer = input("Please enter amount to convert: ")
    if not answer.isdigit():
        print("Invalid")
        return ask()

    return int(answer)

Gdp = ask()

或者 while 循环

while True:
    answer = input("Please enter amount to convert: ")
    if not answer.isdigit():
        print("Invalid")
        continue

    Gbp = int(answer)

Answer 20

下面的代码可能会有所帮助。

age=(lambda i,f: f(i,f))(input("Please enter your age: "),lambda i,f: i if i.isdigit() else f(input("Please enter your age: "),f))
print("You are able to vote in the united states" if int(age)>=18 else "You are not able to vote in the united states",end='')

如果您想要最大尝试次数，例如 3 次，请使用下面的代码

age=(lambda i,n,f: f(i,n,f))(input("Please enter your age: "),1,lambda i,n,f: i if i.isdigit() else (None if n==3 else f(input("Please enter your age: "),n+1,f)))
print("You are able to vote in the united states" if age and int(age)>=18 else "You are not able to vote in the united states",end='')

注意：这使用递归。

Answer 21

实现此目的的最简单方法是将 input 方法放入 while 循环中。使用 继续，当你满意时break退出循环。

当您的输入可能引发异常时，

请使用 try 并 except 来检测用户何时输入无法解析的数据。

while True:
    try:
        # Note: Python 2.x users should use raw_input, the equivalent of 3.x's input
        age = int(input("Please enter your age: "))
    except ValueError:
        print("Sorry, I didn't understand that.")
        #better try again... Return to the start of the loop
        continue
    else:
        #age was successfully parsed!
        #we're ready to exit the loop.
        break
if age >= 18: 
    print("You are able to vote in the United States!")
else:
    print("You are not able to vote in the United States.")

实现您自己的验证规则

如果您想拒绝 Python 可以成功解析的值，您可以添加您自己的验证逻辑。

while True:
    data = input("Please enter a loud message (must be all caps): ")
    if not data.isupper():
        print("Sorry, your response was not loud enough.")
        continue
    else:
        #we're happy with the value given.
        #we're ready to exit the loop.
        break

while True:
    data = input("Pick an answer from A to D:")
    if data.lower() not in ('a', 'b', 'c', 'd'):
        print("Not an appropriate choice.")
    else:
        break

结合异常处理和自定义验证

上述两种技术都可以结合到一个循环中。

while True:
    try:
        age = int(input("Please enter your age: "))
    except ValueError:
        print("Sorry, I didn't understand that.")
        continue

    if age < 0:
        print("Sorry, your response must not be negative.")
        continue
    else:
        #age was successfully parsed, and we're happy with its value.
        #we're ready to exit the loop.
        break
if age >= 18: 
    print("You are able to vote in the United States!")
else:
    print("You are not able to vote in the United States.")

将其全部封装在一个函数中

如果您需要向用户询问许多不同的值，则将此代码放入一个函数中可能会很有用，这样您就不必每次都重新输入它。

def get_non_negative_int(prompt):
    while True:
        try:
            value = int(input(prompt))
        except ValueError:
            print("Sorry, I didn't understand that.")
            continue

        if value < 0:
            print("Sorry, your response must not be negative.")
            continue
        else:
            break
    return value

age = get_non_negative_int("Please enter your age: ")
kids = get_non_negative_int("Please enter the number of children you have: ")
salary = get_non_negative_int("Please enter your yearly earnings, in dollars: ")

将它们放在一起

您可以扩展这个想法来创建一个非常通用的输入函数：

def sanitised_input(prompt, type_=None, min_=None, max_=None, range_=None):
    if min_ is not None and max_ is not None and max_ < min_:
        raise ValueError("min_ must be less than or equal to max_.")
    while True:
        ui = input(prompt)
        if type_ is not None:
            try:
                ui = type_(ui)
            except ValueError:
                print("Input type must be {0}.".format(type_.__name__))
                continue
        if max_ is not None and ui > max_:
            print("Input must be less than or equal to {0}.".format(max_))
        elif min_ is not None and ui < min_:
            print("Input must be greater than or equal to {0}.".format(min_))
        elif range_ is not None and ui not in range_:
            if isinstance(range_, range):
                template = "Input must be between {0.start} and {0.stop}."
                print(template.format(range_))
            else:
                template = "Input must be {0}."
                if len(range_) == 1:
                    print(template.format(*range_))
                else:
                    expected = " or ".join((
                        ", ".join(str(x) for x in range_[:-1]),
                        str(range_[-1])
                    ))
                    print(template.format(expected))
        else:
            return ui

用法如下：

age = sanitised_input("Enter your age: ", int, 1, 101)
answer = sanitised_input("Enter your answer: ", str.lower, range_=('a', 'b', 'c', 'd'))

常见陷阱，以及为什么应该避免它们

冗余 input 语句的冗余使用

此方法有效，但通常被认为是糟糕的风格：

data = input("Please enter a loud message (must be all caps): ")
while not data.isupper():
    print("Sorry, your response was not loud enough.")
    data = input("Please enter a loud message (must be all caps): ")

它最初可能看起来很有吸引力，因为它比 while True 方法短，但它违反了 不要重复自己软件开发原则。这会增加系统出现错误的可能性。如果您想通过将 input 更改为 raw_input 来向后移植到 2.7，但不小心只更改了上面的第一个 input 该怎么办？这是一个正在等待发生的 SyntaxError 。

递归会让你的堆栈崩溃

如果您刚刚了解了递归，您可能会想在 get_non_negative_int 中使用它，这样您就可以处理 while 循环。

def get_non_negative_int(prompt):
    try:
        value = int(input(prompt))
    except ValueError:
        print("Sorry, I didn't understand that.")
        return get_non_negative_int(prompt)

    if value < 0:
        print("Sorry, your response must not be negative.")
        return get_non_negative_int(prompt)
    else:
        return value

这在大多数情况下似乎工作正常，但如果用户输入无效数据足够多次，脚本将终止并显示运行时错误：超出最大递归深度。你可能会认为“没有傻瓜会连续犯1000个错误”，但你低估了傻瓜的聪明才智！

Answer 22

为什么要执行 while True ，然后跳出这个循环，而您也可以将您的要求放入 while 语句中，因为您想要的只是在达到年龄后停止？

age = None
while age is None:
    input_value = input("Please enter your age: ")
    try:
        # try and convert the string input to a number
        age = int(input_value)
    except ValueError:
        # tell the user off
        print("{input} is not a number, please enter a number only".format(input=input_value))
if age >= 18:
    print("You are able to vote in the United States!")
else:
    print("You are not able to vote in the United States.")

这将导致以下结果：

Please enter your age: potato
potato is not a number, please enter a number only
Please enter your age: 5
You are not able to vote in the United States.

这将起作用，因为年龄永远不会有一个没有意义的值，并且代码遵循您的“业务流程”的逻辑

Answer 23

函数式方法或“看妈妈没有循环！”：

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

或如果您想像其他答案一样将“错误输入”消息与输入提示分开：

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

它是如何工作的？

1. prompts = chain(["输入数字："]，repeat("不是数字！再试一次："))
   

   itertools.chain 和 < 的组合a href="https://docs.python.org/library/itertools.html#itertools.repeat" rel="noreferrer">itertools.repeat 将创建一个迭代器
   这将产生字符串 "Enter a number: " 一次，以及 "Not a number! Try Again: " 无限次：

   提示中的提示：
       打印（提示）
   

   输入一个数字： 
   不是数字！再试一次： 
   不是数字！再试一次： 
   不是数字！再试一次： 
   ＃ ... 等等
   

2. 回复=地图（输入，提示） - 这里 map 会将上一步中的所有 prompts 字符串应用到 输入 函数。例如：

   用于回复中的回复：
       打印（回复）
   

   输入一个数字：a
   一个
   不是数字！再试一次：1
   1
   不是数字！再试一次：现在不在乎了
   现在不在乎了
   ＃ 等等...
   

3. 我们使用 filter 和 str.isdigit 过滤掉那些只包含数字的字符串：

   only_digits = filter(str.isdigit, 回复)
   仅回复：
       打印（回复）
   

   输入一个数字：a
   不是数字！再试一次：1
   1
   不是数字！再试一次：2
   2
   不是数字！再试一次：b
   不是数字！再试一次：#等等...
   

   为了仅获取第一个仅包含数字的字符串，我们使用 next< /a>.

其他验证规则：

1. 字符串方法： 当然，您可以使用其他字符串方法，例如 str.isalpha 仅获取字母字符串，或 str.isupper 仅获取大写字母。有关完整列表，请参阅文档。

2. 会员测试：
   有几种不同的方法来执行它。其中之一是使用 __contains__ 方法：

   来自 itertools 导入链，重复
   
   水果 = {'苹果', '橙子', '桃子'}
   提示=链（[“请输入一个水果：”]，repeat（“我不知道这个！再试一次：”））
   回复=地图（输入，提示）
   valid_response = next(过滤器(fruits.__contains__, 回复))
   打印（有效响应）
   

   输入水果：1
   我不认识这个！再试一次：foo
   我不认识这个！再试一次：苹果
   苹果
   

3. 数字比较：
   我们可以在这里使用一些有用的比较方法。例如，对于 __lt__ (<):

   来自 itertools 导入链，重复
   
   Tips = chain(["请输入一个正数："]，repeat("我需要一个正数！再试一次："))
   回复=地图（输入，提示）
   numeric_strings = 过滤器(str.isnumeric, 回复)
   数字 = 地图（浮点数，数字字符串）
   is_positive = (0.).__lt__
   valid_response = next(过滤器(is_positive, 数字))
   打印（有效响应）
   

   输入正数：a
   我需要一个正数！再试一次：-5
   我需要一个正数！再试一次：0
   我需要一个正数！再试一次：5
   5.0
   

   或者，如果您不喜欢使用 dunder 方法（dunder = 双下划线），您可以随时定义自己的函数，或使用 operator 模块。

4. 路径存在：
   这里可以使用 pathlib 库及其 Path.exists方法：

   来自 itertools 导入链，重复
   从 pathlib 导入路径
   
   提示 = chain(["请输入路径："],repeat("该路径不存在！请重试："))
   回复=地图（输入，提示）
   路径=地图（路径，回复）
   valid_response = next(过滤器(Path.exists, paths))
   打印（有效响应）
   

   输入路径：abc
   这条路不存在！再试一次：1
   这条路不存在！再试一次：existing_file.txt
   现有文件.txt
   

限制尝试次数：

如果您不想通过无限次询问用户某件事来折磨用户，您可以在 itertools.repeat。这可以与为 next 函数：

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!

预处理输入数据：

有时，如果用户不小心提供了大写字母或在字符串开头或结尾带有空格，我们不想拒绝输入。为了考虑到这些简单的错误，我们可以通过应用 str 来预处理输入数据.lower 和 str.strip 方法。例如，对于成员资格测试的情况，代码将如下所示：

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

如果您有许多函数可用于预处理，则使用执行 函数组合。例如，使用此处中的一个：

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

组合验证规则：

对于简单的情况，例如，当程序要求年龄在1到120之间时，可以添加另一个过滤器：

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)

但在规则很多的情况下，最好实现一个函数执行 逻辑合取。在下面的示例中，我将使用此处：

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

不幸的是，如果有人需要为每个失败的案例提供自定义消息，那么恐怕没有什么漂亮功能方法。或者，至少，我找不到一个。