如何在动态类型语言（即Python）中指定参数类型？

发布于 2024-09-24 08:09:34 字数 120 浏览 3 评论 0原文

有 Java 的等价物吗

String myMethod (MyClass argument) {...}

Python 中

？谢谢你，托马斯

原文

Is there any such equivalent of Java

String myMethod (MyClass argument) {...}

in Python?

Thank you, Tomas

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

淡忘如思 2024-10-01 08:09:34

否。（还有更多内容将其四舍五入到 15 个字符......）

回复收藏 0 原文

很酷不放纵 2024-10-01 08:09:34

不，没有。

事实上，检查类型被认为是“非Pythonic”，因为任何看起来足够像预期类型的类型的对象都应该被同等对待。

回复收藏 0 原文

不知在何时 2024-10-01 08:09:34

Python 3.x 有函数注释，您可以在其中声明参数和返回类型：

def myMethod(argument: MyClass) -> str:
   ...

但目前 Python 对它们不执行任何操作，它们仅用作文档。

Python 3.x has function annotations where you can declare argument and return types:

def myMethod(argument: MyClass) -> str:
   ...

But currently Python does nothing with them, they serve as documentation only.

回复收藏 0 原文

仅一夜美梦 2024-10-01 08:09:34

我只是想说，我完全同意类型检查是邪恶的。但 python 也非常灵活，我很想变得邪恶。这段代码将在运行时生效，而不是在编译时生效。您可以对返回类型执行类似的操作。像这样的东西对于调试可能很有用，而且因为它是一个装饰器，所以很容易删除。

为了使其对调试有用，您必须遇到两种类型具有正在访问的所有相同属性但具有不同语义的情况。所以这是一个相当有限的案例。除此之外，当此代码运行时，您无论如何都会遇到打字错误。好消息是这几乎从来都不是问题。我真的不知道为什么静态类型语言的人们对此如此重视。

def types(*args, **kwargs):
    arg_types = args
    kwarg_types = kwargs
    def decorator(f):
        def func(*args, **kwargs):
            for arg, arg_type in zip(args, arg_types):
                if not isinstance(arg, arg_type):
                    raise TypeError("Wrong type suckah")
            for kw, arg in kwargs.items():
                if not isinstance(arg, kwarg_types[kw]):
                    raise TypeError("this is a bad error message")
            return f(*args, **kwargs)
        return func
    return decorator

@types(int, str, bool, flag=bool)
def demo(i, strng, flag=False):
    print i, strng, flag

demo(1, "foo", True)

try:
    demo("foo", "bar", flag="foobar")
except TypeError:
    print "busted on posargs"

try:
    demo(1, "foo", flag=2)
except TypeError:
    print "busted on keyargs"

try:
    demo(1, "foo", 3)
except TypeError:
    print "no use sneaking it through"

I just want to say that I'm in full agreement that type checking is evil. But python is also incredibly flexible and I'm in the mood to be evil. This code will take effect at runtime and not compile time. You could do something similar for return type. Something like this could be useful for debugging and, because it's a decorator, it's easy enough to remove.

For it to be useful for debugging you would have to have a situation where two types had all the same attributes that were getting accessed but with different semantics. So that's a pretty limited case. Other than that, you're about to get a typerror anyways when this code runs. The good news is that this is almost never a problem. I really don't know why people from statically typed languages make such a big deal over it.

def types(*args, **kwargs):
    arg_types = args
    kwarg_types = kwargs
    def decorator(f):
        def func(*args, **kwargs):
            for arg, arg_type in zip(args, arg_types):
                if not isinstance(arg, arg_type):
                    raise TypeError("Wrong type suckah")
            for kw, arg in kwargs.items():
                if not isinstance(arg, kwarg_types[kw]):
                    raise TypeError("this is a bad error message")
            return f(*args, **kwargs)
        return func
    return decorator

@types(int, str, bool, flag=bool)
def demo(i, strng, flag=False):
    print i, strng, flag

demo(1, "foo", True)

try:
    demo("foo", "bar", flag="foobar")
except TypeError:
    print "busted on posargs"

try:
    demo(1, "foo", flag=2)
except TypeError:
    print "busted on keyargs"

try:
    demo(1, "foo", 3)
except TypeError:
    print "no use sneaking it through"

回复收藏 0 原文