如何为含2个必填、1个可选参数的函数优雅处理异常？

Great question—let’s clear up the confusion first, then walk through a solid solution.

First off: your current if TypeError: and if NameError: checks don’t work at all. Those are just references to Python’s exception classes, so those conditions will always evaluate to True (since the classes exist). Exceptions like NameError and the "missing arguments" TypeError are thrown before your function even starts running—you can’t catch them with if statements inside the function.

Let’s break down how to handle all your required error cases properly:

Step 1: Fix Internal Parameter Validation #

First, add checks inside your function for the things you can validate before executing logic (like file existence and valid argument values):

import os

def main(textfile1, arg2, normalize=False):
    # Validate textfile1 is a string and exists
    if not isinstance(textfile1, str):
        print("Error: textfile1 must be a string filename.")
        return None
    if not os.path.isfile(textfile1):
        print("Filename is invalid.")
        return None

    # Validate arg2 is either 'listing' or a valid file
    if not isinstance(arg2, str):
        print("Error: arg2 must be either 'listing' or a string filename.")
        return None
    if arg2 != 'listing' and not os.path.isfile(arg2):
        print("Second filename is invalid.")
        return None

    # If we get here, all parameters are valid—run your logic
    if arg2 == 'listing':
        print(f"Processing listing mode with file: {textfile1}")
        # Add your actual file processing code here
    else:
        print(f"Processing files: {textfile1} and {arg2}")
        # Add your two-file processing code here

Step 2: Handle Call-Time Exceptions #

The NameError (undefined variable) and "missing arguments" TypeError happen when someone calls your function incorrectly—before the function runs. The only way to catch these is with a try-except block around the function call (or pre-process inputs to avoid them entirely).

Option A: Catch Exceptions at Call Time #

If you’re calling the function directly (e.g., in a script or interactive shell), wrap the call in try-except:

if __name__ == "__main__":
    try:
        # Example valid call
        main("myfile.txt", "listing")
        
        # Uncomment these to test error cases:
        # main()  # Triggers missing args TypeError
        # main(undefined_var, "test")  # Triggers NameError
    except TypeError as e:
        # Handle missing required arguments
        if "missing" in str(e):
            num_missing = str(e).split("missing ")[1].split(" required")[0]
            print(f"Error: Missing {num_missing} required argument(s). You need to pass both textfile1 and arg2.")
        else:
            print(f"Error: Invalid argument type - {str(e)}")
    except NameError as e:
        # Handle undefined variables passed as arguments
        var_name = str(e).split("name '")[1].split("' is not defined")[0]
        print(f"Error: The variable '{var_name}' isn't defined. Use quotes around string filenames (e.g., 'myfile.txt').")

Option B: Pre-Process Inputs (Avoid Exceptions Altogether) #

If you’re getting inputs from the command line, you can pre-validate them before calling the function, which avoids these exceptions entirely:

import sys
import os

def main(textfile1, arg2, normalize=False):
    # Same internal validation as above
    ...

if __name__ == "__main__":
    # Check for enough command line arguments
    if len(sys.argv) < 3:
        print("Usage: python your_script.py <textfile1> <arg2> [--normalize]")
        print("Example: python your_script.py file1.txt listing")
        sys.exit(1)

    # Extract arguments (all are strings from sys.argv, no NameError risk)
    textfile1 = sys.argv[1]
    arg2 = sys.argv[2]
    normalize = len(sys.argv) > 3 and sys.argv[3] == "--normalize"

    # Call the function with pre-validated inputs
    main(textfile1, arg2, normalize)

Key Takeaways #

• Don’t use if to check for exception classes: Exceptions are runtime errors, not boolean conditions. Use try-except to catch them when they occur.
• Validate inside the function for things you can control: file existence, argument types, and allowed values (like arg2 being "listing").
• Handle call-time errors outside the function: Either catch them with try-except or pre-process inputs (like command line args) to avoid the exceptions in the first place.

内容的提问来源于stack exchange，提问作者Hagoromo Otsutski