能否指定所有位置参数统一为int或str类型？

Great question! I totally get where you're coming from—typing has been a game-changer for readability and IDE support, and enforcing consistent argument types takes that to the next level.

To make sure all positional arguments are either entirely ints or entirely strs (no mixed types), you can use a constrained TypeVar from the typing module. Here's how it works:

Step 1: Define a Constrained Type Variable #

First, create a TypeVar that's restricted to only int and str. This tells the type checker that all arguments using this variable must resolve to the same type (either int or str, not both):

from typing import TypeVar

# Restrict T to be either int or str
T = TypeVar("T", int, str)

Step 2: Use the TypeVar in Your Function Signature #

Now apply this TypeVar to your positional arguments. Whether you're using variable-length *args or fixed positional arguments, this ensures consistency:

For Variable-Length Positional Arguments (*args) #

def process_args(*args: T) -> None:
    # Add runtime type check for safety (optional but recommended)
    if args:
        arg_type = type(args[0])
        if not all(isinstance(arg, arg_type) for arg in args):
            raise TypeError("All arguments must be the same type (int or str)")
    
    # Your core logic here
    print(f"Processed {len(args)} arguments of type {arg_type.__name__}")

For Fixed Positional Arguments #

def compare_values(a: T, b: T) -> bool:
    return a == b

How It Works #

• When you call process_args(1, 2, 3), the type checker infers T as int—any non-int argument will trigger a warning (PyCharm will flag this immediately!).
• When you call process_args("hello", "world"), T is inferred as str—again, mixing in an int will throw a type error.
• If you try process_args(1, "2"), the type checker can't resolve T to a single type (it can't be both int and str), so it will throw a static type error.

Bonus: Consistent Return Types #

You can also use the same TypeVar to enforce that your return type matches the input type. For example:

def combine_args(*args: T) -> T:
    if isinstance(args[0], int):
        return sum(args)  # Type checker knows this returns int
    else:
        return "".join(args)  # Type checker knows this returns str

Key Notes #

• Static vs. Runtime: The TypeVar handles static type checking (PyCharm, mypy, etc.), but adding a runtime check with isinstance ensures safety if your code is run without type checking.
• IDE Support: This plays perfectly with PyCharm—you'll get instant feedback if you mix types, which aligns with your goal of doubling PyCharm's utility!

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