Python：在函数内命名类型并在函数外分配变量

Question

I'd like to be able to easily create new types, plus (optionally) add some information about them (say some docs, and a set of variable names they often come under).

The straightforward way to do this would be:

from typing import Any, NewType, Union, List, Iterable, Optional

Key = NewType('Key', Any)
Key._aka = set(['key', 'k'])

Val = NewType('Val', Union[int, float, List[Union[int, float]]])
Val.__doc__ = "A number or list of numbers."

But there's two reasons I don't like this:

• I have to copy paste the name of the new type I'm making three times (not DRY and prone to mistakes)

• I don't like to "externalize" the assignment of optional additional information ( _aka and __doc__ )

So I came up with this:

from typing import Any, NewType, Union, List, Iterable, Optional

def new_type(name, tp, doc: Optional[str]=None, aka: Optional[Iterable]=None):
    """Make a new type with (optional) doc and (optional) aka, set of var names it often appears as"""
    new_tp = NewType(name, tp)
    if doc is not None: 
        setattr(new_tp, '__doc__', doc)
    if aka is not None: 
        setattr(new_tp, '_aka', set(aka))
    globals()[name] = new_tp  # is this dangerous? Does scope need to be considered more carefully?

which then gives me the interface I'd like:

new_type('Key', Any, aka=['key', 'k'])
new_type('Val', Union[int, float, List[Union[int, float]]], doc="A number or list of numbers.")

But I'm not sure of that globals()[name] = new_tp thing. It seems it would be benign if I'm defining my types in the top level of a module, but not sure how this would fair in some edge case nested scopes situation.

Answer 1

The normal way you create a new type is to just write a new class:

class Key:
    def __init__(self, key: object) -> None:
        self._key = key
        self._aka = set(['key', 'k'])

class SqlString(str):
    """A custom string which has been verified to be valid SQL."""

Note that this approach avoids the DRY and scoping concerns that you had.

You use NewType only for when you don't want to add any extra attributes or a docstring -- doing Foo = NewType('Foo', X) is basically like doing class Foo(X): pass except with slightly less runtime overhead.

(More precisely, type checkers will treat Foo = NewType('Foo', X) as if it were written like class Foo(X): pass , but at runtime what actually happens Foo = lambda x: x -- Foo is the identity function.)

---

We do run into a complication with your second Union example, however, since Unions are not subclassable (which makes that NewType illegal, as per PEP 484 ).

Instead, I would personally just do the following:

# A number or list of numbers
Val = Union[int, float, List[Union[int, float]]]

IMO since types are supposed to be invisible at runtime, I think it makes sense to just not bother attaching runtime-available documentation.