Boring_Python_Chapter_8.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 8: Input Validation\n",
    "\n",
    "Adapted from Automate the Boring Stuff Chapter 8: https://automatetheboringstuff.com/2e/chapter8/ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Input validation code checks that values entered by the user, such as text from the input() function, are formatted correctly. For example, if you want users to enter their ages, your code shouldn’t accept nonsensical answers such as negative numbers (which are outside the range of acceptable integers) or words (which are the wrong data type). Input validation can also prevent bugs or security vulnerabilities. If you implement a withdrawFromAccount() function that takes an argument for the amount to subtract from an account, you need to ensure the amount is a positive number. If the withdrawFromAccount() function subtracts a negative number from the account, the “withdrawal” will end up adding money!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typically, we perform input validation by repeatedly asking the user for input until they enter valid text, as in the following example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your age:\n",
      "one\n",
      "Please use numeric digits.\n",
      "Enter your age:\n",
      "5\n",
      "Your age is 5.\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    print('Enter your age:')\n",
    "    age = input()\n",
    "    try:\n",
    "        age = int(age)\n",
    "    except:\n",
    "        print('Please use numeric digits.')\n",
    "        continue\n",
    "    if age < 1:\n",
    "        print('Please enter a positive number.')\n",
    "        continue\n",
    "    break\n",
    "\n",
    "print(f'Your age is {age}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***When you run this program, the output could look like this:***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enter your age:  \n",
    "**five**  \n",
    "Please use numeric digits.  \n",
    "Enter your age:  \n",
    "**-2**    \n",
    "Please enter a positive number.    \n",
    "Enter your age:  \n",
    "**30**   \n",
    "Your age is 30."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you run this code, you’ll be prompted for your age until you enter a valid one. This ensures that by the time the execution leaves the while loop, the age variable will contain a valid value that won’t crash the program later on.\n",
    "\n",
    "However, writing input validation code for every input() call in your program quickly becomes tedious. Also, you may miss certain cases and allow invalid input to pass through your checks. In this chapter, you’ll learn how to use the third-party PyInputPlus module for input validation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The PyInputPlus Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyInputPlus contains functions similar to input() for several kinds of data: numbers, dates, email addresses, and more. If the user ever enters invalid input, such as a badly formatted date or a number that is outside of an intended range, PyInputPlus will reprompt them for input just like our code in the previous section did. PyInputPlus also has other useful features like a limit for the number of times it reprompts users and a timeout if users are required to respond within a time limit.\n",
    "\n",
    "PyInputPlus is not a part of the Python Standard Library, so you must install it separately using Pip. To install PyInputPlus, run pip install --user pyinputplus from the command line. Appendix A has complete instructions for installing third-party modules. \n",
    "\n",
    "***To check if PyInputPlus installed correctly, import it in the interactive shell:***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import pyinputplus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If no errors appear when you import the module, it has been successfully installed.\n",
    "\n",
    "PyInputPlus has several functions for different kinds of input:\n",
    "\n",
    "**inputStr()** Is like the built-in input() function but has the general PyInputPlus features. You can also pass a custom validation function to it\n",
    "\n",
    "**inputNum()** Ensures the user enters a number and returns an int or float, depending on if the number has a decimal point in it\n",
    "\n",
    "**inputChoice()** Ensures the user enters one of the provided choices\n",
    "\n",
    "**inputMenu()** Is similar to inputChoice(), but provides a menu with numbered or lettered options\n",
    "\n",
    "**inputDatetime()** Ensures the user enters a date and time\n",
    "\n",
    "**inputYesNo()** Ensures the user enters a “yes” or “no” response\n",
    "\n",
    "**inputBool()** Is similar to inputYesNo(), but takes a “True” or “False” response and returns a Boolean value\n",
    "\n",
    "**inputEmail()** Ensures the user enters a valid email address\n",
    "\n",
    "**inputFilepath()** Ensures the user enters a valid file path and filename, and can optionally check that a file with that name exists\n",
    "\n",
    "**inputPassword()** Is like the built-in input(), but displays * characters as the user types so that passwords, or other sensitive information, aren’t displayed on the screen\n",
    "\n",
    "***These functions will automatically reprompt the user for as long as they enter invalid input:***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "five\n",
      "'five' is not a number.\n",
      "42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> import pyinputplus as pyip\n",
    ">>> response = pyip.inputNum()\n",
    "#if you enter: five\n",
    "#output should be:'five' is not a number.\n",
    "#then try entering: 42\n",
    ">>> response\n",
    "#output should be: 42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The as pyip code in the import statement saves us from typing pyinputplus each time we want to call a PyInputPlus function. Instead we can use the shorter pyip name. If you take a look at the example, you see that unlike input(), these functions return an int or float value: 42 and 3.14 instead of the strings '42' and '3.14'.\n",
    "\n",
    "Just as you can pass a string to input() to provide a prompt, you can pass a string to a PyInputPlus function’s prompt keyword argument to display a prompt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 42\n",
      "Enter a number: 42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> response = input('Enter a number: ')\n",
    "#Enter a number: 42\n",
    ">>> response\n",
    "#output should be:'42'\n",
    ">>> import pyinputplus as pyip\n",
    ">>> response = pyip.inputInt(prompt='Enter a number: ')\n",
    "#Try entering 'cat'\n",
    "#ouput should be: 'cat' is not an integer.\n",
    "#Then enter 42\n",
    ">>> response"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use Python’s help() function to find out more about each of these functions. For example, help(pyip.inputChoice) displays help information for the inputChoice() function. Complete documentation can be found at https://pyinputplus.readthedocs.io/.\n",
    "\n",
    "Unlike Python’s built-in input(), PyInputPlus functions have several additional features for input validation, as shown in the next section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The min, max, greaterThan, and lessThan Keyword Arguments "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The inputNum(), inputInt(), and inputFloat() functions, which accept int and float numbers, also have min, max, greaterThan, and lessThan keyword arguments for specifying a range of valid values. For example, enter the following into the interactive shell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter num: 4\n",
      "Enter num: 5\n",
      ">6\n",
      "Number must be less than 6.\n",
      ">4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> import pyinputplus as pyip\n",
    ">>> response = pyip.inputNum('Enter num: ', min=4)\n",
    "#Enter num:3\n",
    "#Input must be at minimum 4.\n",
    "#Enter num:4\n",
    ">>> response\n",
    "#4\n",
    ">>> response = pyip.inputNum('Enter num: ', greaterThan=4)\n",
    "#Enter num: 4\n",
    "#Input must be greater than 4.\n",
    "#Enter num: 5\n",
    ">>> response\n",
    "#5\n",
    ">>> response = pyip.inputNum('>', min=4, lessThan=6)\n",
    "#Enter num: 6\n",
    "#Input must be less than 6.\n",
    "#Enter num: 3\n",
    "#Input must be at minimum 4.\n",
    "#Enter num: 4\n",
    ">>> response\n",
    "#4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These keyword arguments are optional, but if supplied, the input cannot be less than the min argument or greater than the max argument (though the input can be equal to them). Also, the input must be greater than the greaterThan and less than the lessThan arguments (that is, the input cannot be equal to them)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The blank Keyword Argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, blank input isn’t allowed unless the blank keyword argument is set to True:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter num:  \n",
      "Blank values are not allowed.\n",
      "Enter num: 42\n",
      "42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> import pyinputplus as pyip\n",
    ">>> response = pyip.inputNum('Enter num: ')\n",
    "#Enter num:(blank input entered here)\n",
    "#Blank values are not allowed.\n",
    "#Enter num: 42\n",
    ">>> response\n",
    "#42\n",
    ">>> response = pyip.inputNum(blank=True)\n",
    "#(blank input entered here)\n",
    ">>> response\n",
    "#''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Use blank=True if you’d like to make input optional so that the user doesn’t need to enter anything.***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The limit, timeout, and default Keyword Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, the PyInputPlus functions will continue to ask the user for valid input forever (or for as long as the program runs). If you’d like a function to stop asking the user for input after a certain number of tries or a certain amount of time, you can use the limit and timeout keyword arguments. Pass an integer for the limit keyword argument to determine how many attempts a PyInputPlus function will make to receive valid input before giving up, and pass an integer for the timeout keyword argument to determine how many seconds the user has to enter valid input before the PyInputPlus function gives up.\n",
    "\n",
    "If the user fails to enter valid input, these keyword arguments will cause the function to raise a RetryLimitException or TimeoutException, respectively. For example, enter the following into the interactive shell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blah\n",
      "'blah' is not a number.\n"
     ]
    }
   ],
   "source": [
    ">>> import pyinputplus as pyip\n",
    ">>> response = pyip.inputNum(limit=2)\n",
    "#blah\n",
    "#'blah' is not a number.\n",
    "#Enter num: number\n",
    "#'number' is not a number.\n",
    "#Traceback (most recent call last):\n",
    "#    --snip--\n",
    "#pyinputplus.RetryLimitException\n",
    ">>> response = pyip.inputNum(timeout=10)\n",
    "#42 (entered after 10 seconds of waiting)\n",
    "#Traceback (most recent call last):\n",
    "#    --snip--\n",
    "#pyinputplus.TimeoutException"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you use these keyword arguments and also pass a default keyword argument, the function returns the default value instead of raising an exception. Enter the following into the interactive shell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> response = pyip.inputNum(limit=2, default='N/A')\n",
    "#hello\n",
    "#'hello' is not a number.\n",
    "#world\n",
    "#'world' is not a number.\n",
    ">>> response\n",
    "#'N/A'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Instead of raising RetryLimitException, the inputNum() function simply returns the string 'N/A'.***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The allowRegexes and blockRegexes Keyword Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use regular expressions to specify whether an input is allowed or not. The allowRegexes and blockRegexes keyword arguments take a list of regular expression strings to determine what the PyInputPlus function will accept or reject as valid input. For example, enter the following code into the interactive shell so that inputNum() will accept Roman numerals in addition to the usual numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import pyinputplus as pyip\n",
    ">>> response = pyip.inputNum(allowRegexes=[r'(I|V|X|L|C|D|M)+', r'zero'])\n",
    "#XLII\n",
    ">>> response\n",
    "#'XLII'\n",
    ">>> response = pyip.inputNum(allowRegexes=[r'(i|v|x|l|c|d|m)+', r'zero'])\n",
    "#xlii\n",
    ">>> response\n",
    "#'xlii'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, this regex affects only what letters the inputNum() function will accept from the user; the function will still accept Roman numerals with invalid ordering such as 'XVX' or 'MILLI' because the r'(I|V|X|L|C|D|M)+' regular expression accepts those strings.\n",
    "\n",
    "You can also specify a list of regular expression strings that a PyInputPlus function won’t accept by using the blockRegexes keyword argument. Enter the following into the interactive shell so that inputNum() won’t accept even numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import pyinputplus as pyip\n",
    ">>> response = pyip.inputNum(blockRegexes=[r'[02468]$'])\n",
    "#42\n",
    "#This response is invalid.\n",
    "#44\n",
    "#This response is invalid.\n",
    "#43\n",
    ">>> response\n",
    "#43"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you specify both an allowRegexes and blockRegexes argument, the allow list overrides the block list. For example, enter the following into the interactive shell, which allows 'caterpillar' and 'category' but blocks anything else that has the word 'cat' in it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import pyinputplus as pyip\n",
    ">>> response = pyip.inputStr(allowRegexes=[r'caterpillar', 'category'], blockRegexes=[r'cat'])\n",
    "#cat\n",
    "#This response is invalid.\n",
    "#catastrophe\n",
    "#This response is invalid.\n",
    "#category\n",
    ">>> response\n",
    "#'category'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The PyInputPlus module’s functions can save you from writing tedious input validation code yourself. But there’s more to the PyInputPlus module than what has been detailed here. You can examine its full documentation online at https://pyinputplus.readthedocs.io/.\n",
    "\n",
    "## Passing a Custom Validation Function to inputCustom()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can write a function to perform your own custom validation logic by passing the function to inputCustom(). For example, say you want the user to enter a series of digits that adds up to 10. There is no pyinputplus.inputAddsUpToTen() function, but you can create your own function that:\n",
    "\n",
    "• Accepts a single string argument of what the user entered  \n",
    "• Raises an exception if the string fails validation  \n",
    "• Returns None (or has no return statement) if inputCustom() should return the string unchanged  \n",
    "• Returns a non-None value if inputCustom() should return a different string from the one the user entered  \n",
    "• Is passed as the first argument to inputCustom()  \n",
    "\n",
    "For example, we can create our own addsUpToTen() function, and then pass it to inputCustom(). Note that the function call looks like inputCustom(addsUpToTen) and not inputCustom(addsUpToTen()) because we are passing the addsUpToTen() function itself to inputCustom(), not calling addsUpToTen() and passing its return value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> import pyinputplus as pyip\n",
    ">>> def addsUpToTen(numbers):\n",
    "...   numbersList = list(numbers)\n",
    "...   for i, digit in enumerate(numbersList):\n",
    "...     numbersList[i] = int(digit)\n",
    "...   if sum(numbersList) != 10:\n",
    "...     raise Exception('The digits must add up to 10, not %s.' %\n",
    "(sum(numbersList)))\n",
    "...   return int(numbers) # Return an int form of numbers.\n",
    "...\n",
    ">>> response = pyip.inputCustom(addsUpToTen) # No parentheses after addsUpToTen here.\n",
    "#123\n",
    "#The digits must add up to 10, not 6.\n",
    "#1235\n",
    "#The digits must add up to 10, not 11.\n",
    "#1234\n",
    ">>> response # inputStr() returned an int, not a string.\n",
    "#1234\n",
    ">>> response = pyip.inputCustom(addsUpToTen)\n",
    "#hello\n",
    "#invalid literal for int() with base 10: 'h'\n",
    "#55\n",
    ">>> response"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The inputCustom() function also supports the general PyInputPlus features, such as the blank, limit, timeout, default, allowRegexes, and blockRegexes keyword arguments. Writing your own custom validation function is useful when it’s otherwise difficult or impossible to write a regular expression for valid input, as in the “adds up to 10” example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project: How to Keep an Idiot Busy for Hours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s use PyInputPlus to create a simple program that does the following:\n",
    "\n",
    "1. Ask the user if they’d like to know how to keep an idiot busy for hours.  \n",
    "2. If the user answers no, quit.  \n",
    "3. If the user answers yes, go to Step 1.  \n",
    "\n",
    "Of course, we don’t know if the user will enter something besides “yes” or “no,” so we need to perform input validation. It would also be convenient for the user to be able to enter “y” or “n” instead of the full words. PyInputPlus’s inputYesNo() function will handle this for us and, no matter what case the user enters, return a lowercase 'yes' or 'no' string value.\n",
    "\n",
    "When you run this program, it should look like the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Want to know how to keep an idiot busy for hours?\n",
    "**sure**\n",
    "'sure' is not a valid yes/no response.\n",
    "Want to know how to keep an idiot busy for hours?\n",
    "**yes**\n",
    "Want to know how to keep an idiot busy for hours?\n",
    "**y**\n",
    "Want to know how to keep an idiot busy for hours?\n",
    "**Yes**\n",
    "Want to know how to keep an idiot busy for hours?\n",
    "**YES**\n",
    "Want to know how to keep an idiot busy for hours?\n",
    "**YES!!!!!!**\n",
    "'YES!!!!!!' is not a valid yes/no response.\n",
    "Want to know how to keep an idiot busy for hours?\n",
    "**TELL ME HOW TO KEEP AN IDIOT BUSY FOR HOURS.**\n",
    "'TELL ME HOW TO KEEP AN IDIOT BUSY FOR HOURS.' is not a valid yes/no response.\n",
    "Want to know how to keep an idiot busy for hours?\n",
    "**no**\n",
    "Thank you. Have a nice day."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Open a new file editor tab and save it as idiot.py. Then enter the following code:***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyinputplus as pyip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This imports the PyInputPlus module. Since pyinputplus is a bit much to type, we’ll use the name pyip for short."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    prompt = 'Want to know how to keep an idiot busy for hours?\\n'\n",
    "    response = pyip.inputYesNo(prompt)\n",
    "#Next, while True: creates an infinite loop that continues to run \n",
    "#until it encounters a break statement. In this loop, we call pyip.inputYesNo() \n",
    "#to ensure that this function call won’t return until the user enters a valid answer.\n",
    "    if response == 'no':\n",
    "        break\n",
    "#The pyip.inputYesNo() call is guaranteed to only return either \n",
    "#the string yes or the string no. If it returned no, then our program \n",
    "#breaks out of the infinite loop and continues to the last line, which thanks the user:\n",
    "print('Thank you. Have a nice day.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otherwise, the loop iterates once again.\n",
    "\n",
    "You can also make use of the inputYesNo() function in non-English languages by passing yesVal and noVal keyword arguments. For example, the Spanish version of this program would have these two lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prompt = '¿Quieres saber cómo mantener ocupado a un idiota durante horas?\\n'\n",
    "    response = pyip.inputYesNo(prompt, yesVal='sí', noVal='no')\n",
    "    if response == 'sí':"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the user can enter either sí or s (in lower- or uppercase) instead of yes or y for an affirmative answer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project: Multiplication Quiz\n",
    "\n",
    "PyInputPlus’s features can be useful for creating a timed multiplication quiz. By setting the allowRegexes, blockRegexes, timeout, and limit keyword argument to pyip.inputStr(), you can leave most of the implementation to PyInputPlus. The less code you need to write, the faster you can write your programs. Let’s create a program that poses 10 multiplication problems to the user, where the valid input is the problem’s correct answer. Open a new file editor tab and save the file as multiplicationQuiz.py.\n",
    "\n",
    "First, we’ll import pyinputplus, random, and time. We’ll keep track of how many questions the program asks and how many correct answers the user gives with the variables numberOfQuestions and correctAnswers. A for loop will repeatedly pose a random multiplication problem 10 times:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "import pyinputplus as pyip\n",
    "import random, time\n",
    "\n",
    "numberOfQuestions = 10\n",
    "correctAnswers = 0\n",
    "for questionNumber in range(numberOfQuestions):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inside the for loop, the program will pick two single-digit numbers to multiply. We’ll use these numbers to create a #Q: N × N = prompt for the user, where Q is the question number (1 to 10) and N are the two numbers to multiply."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    # Pick two random numbers:\n",
    "    num1 = random.randint(0, 9)\n",
    "    num2 = random.randint(0, 9)\n",
    "\n",
    "    prompt = '#%s: %s x %s = ' % (questionNumber, num1, num2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The pyip.inputStr() function will handle most of the features of this quiz program. The argument we pass for allowRegexes is a list with the regex string '^%s$', where %s is replaced with the correct answer. The ^ and % characters ensure that the answer begins and ends with the correct number, though PyInputPlus trims any whitespace from the start and end of the user’s response first just in case they inadvertently pressed the spacebar before or after their answer. The argument we pass for blocklistRegexes is a list with ('.*', 'Incorrect!'). The first string in the tuple is a regex that matches every possible string. Therefore, if the user response doesn’t match the correct answer, the program will reject any other answer they provide. In that case, the 'Incorrect!' string is displayed and the user is prompted to answer again. Additionally, passing 8 for timeout and 3 for limit will ensure that the user only has 8 seconds and 3 tries to provide a correct answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    try:\n",
    "        # Right answers are handled by allowRegexes.\n",
    "        # Wrong answers are handled by blockRegexes, with a custom message.\n",
    "        pyip.inputStr(prompt, allowRegexes=['^%s$' % (num1 * num2)],\n",
    "                              blockRegexes=[('.*', 'Incorrect!')],\n",
    "                              timeout=8, limit=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the user answers after the 8-second timeout has expired, even if they answer correctly, pyip.inputStr() raises a TimeoutException exception. If the user answers incorrectly more than 3 times, it raises a RetryLimitException exception. Both of these exception types are in the PyInputPlus module, so pyip. needs to prepend them:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    except pyip.TimeoutException:\n",
    "        print('Out of time!')\n",
    "    except pyip.RetryLimitException:\n",
    "        print('Out of tries!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that, just like how else blocks can follow an if or elif block, they can optionally follow the last except block. The code inside the following else block will run if no exception was raised in the try block. In our case, that means the code runs if the user entered the correct answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    else:\n",
    "        # This block runs if no exceptions were raised in the try block.\n",
    "        print('Correct!')\n",
    "        correctAnswers += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No matter which of the three messages, “Out of time!”, “Out of tries!”, or “Correct!”, displays, let’s place a 1-second pause at the end of the for loop to give the user time to read it. After the program has asked 10 questions and the for loop continues, let’s show the user how many correct answers they made:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    time.sleep(1) # Brief pause to let user see the result.\n",
    "print('Score: %s / %s' % (correctAnswers, numberOfQuestions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyInputPlus is flexible enough that you can use it in a wide variety of programs that take keyboard input from the user, as demonstrated by the programs in this chapter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "It’s easy to forget to write input validation code, but without it, your programs will almost certainly have bugs. The values you expect users to enter and the values they actually enter can be completely different, and your programs need to be robust enough to handle these exceptional cases. You can use regular expressions to create your own input validation code, but for common cases, it’s easier to use an existing module, such as PyInputPlus. You can import the module with import pyinputplus as pyip so that you can enter a shorter name when calling the module’s functions.\n",
    "\n",
    "PyInputPlus has functions for entering a variety of input, including strings, numbers, dates, yes/no, True/False, emails, and files. While input() always returns a string, these functions return the value in an appropriate data type. The inputChoice() function allow you to select one of several pre-selected options, while inputMenu() also adds numbers or letters for quick selection.\n",
    "\n",
    "All of these functions have the following standard features: stripping whitespace from the sides, setting timeout and retry limits with the timeout and limit keyword arguments, and passing lists of regular expression strings to allowRegexes or blockRegexes to include or exclude particular responses. You'll no longer need to write your own tedious while loops that check for valid input and reprompt the user.\n",
    "\n",
    "If none of the PyInputPlus module’s, functions fit your needs, but you’d still like the other features that PyInputPlus provides, you can call inputCustom() and pass your own custom validation function for PyInputPlus to use. The documentation at https://pyinputplus.readthedocs.io/en/latest/ has a complete listing of PyInputPlus’s functions and additional features. There’s far more in the PyInputPlus online documentation than what was described in this chapter. There’s no use in reinventing the wheel, and learning to use this module will save you from having to write and debug code for yourself.\n",
    "\n",
    "Now that you have expertise manipulating and validating text, it’s time to learn how to read from and write to files on your computer’s hard drive.\n",
    "\n",
    "## Practice Questions\n",
    "1. Does PyInputPlus come with the Python Standard Library?\n",
    "\n",
    "2. Why is PyInputPlus commonly imported with import pyinputplus as pyip?\n",
    "\n",
    "3. What is the difference between inputInt() and inputFloat()?\n",
    "\n",
    "4. How can you ensure that the user enters a whole number between 0 and 99 using PyInputPlus?\n",
    "\n",
    "5. What is passed to the allowRegexes and blockRegexes keyword arguments?\n",
    "\n",
    "6. What does inputStr(limit=3) do if blank input is entered three times?\n",
    "\n",
    "7. What does inputStr(limit=3, default='hello') do if blank input is entered three times?\n",
    "\n",
    "## Practice Projects\n",
    "For practice, write programs to do the following tasks.\n",
    "\n",
    "### *Sandwich Maker*\n",
    "Write a program that asks users for their sandwich preferences. The program should use PyInputPlus to ensure that they enter valid input, such as:\n",
    "\n",
    "• Using inputMenu() for a bread type: wheat, white, or sourdough.  \n",
    "• Using inputMenu() for a protein type: chicken, turkey, ham, or tofu.  \n",
    "• Using inputYesNo() to ask if they want cheese.  \n",
    "• If so, using inputMenu() to ask for a cheese type: cheddar, Swiss, or mozzarella.   \n",
    "• Using inputYesNo() to ask if they want mayo, mustard, lettuce, or tomato.  \n",
    "• Using inputInt() to ask how many sandwiches they want. Make sure this number is 1 or more.  \n",
    "Come up with prices for each of these options, and have your program display a total cost after the user enters their selection.\n",
    "\n",
    "### *Write Your Own Multiplication Quiz*\n",
    "To see how much PyInputPlus is doing for you, try re-creating the multiplication quiz project on your own without importing it. This program will prompt the user with 10 multiplication questions, ranging from 0 × 0 to 9 × 9. You’ll need to implement the following features:\n",
    "\n",
    "• If the user enters the correct answer, the program displays “Correct!” for 1 second and moves on to the next question.  \n",
    "• The user gets three tries to enter the correct answer before the program moves on to the next question.  \n",
    "• Eight seconds after first displaying the question, the question is marked as incorrect even if the user enters the correct answer after the 8-second limit.  \n",
    "\n",
    "Compare your code to the code using PyInputPlus in “Project: Multiplication Quiz” on page 196."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}