强制在Python中使用函数参数类型? [英] Force a function parameter type in Python?

问题描述

我在Python类中有一个将接口添加到列表中的函数.

I have a function in a Python class that adds Interfaces to a list.

def RegisterAsListener(self, inListener):
    self.__TransitListeners.append(inListener)

这很好，因为一个类只需要从我的接口继承即可，获取该对象，然后为所有更新注册自己.

This is nice, because a class just needs to inherit from said my Interface, grab this object, and register itself for all updates.

class ITransit():
    def TransitUpdate(self, data):
        raise NotImplementedError("You must define this function.")

(假设我正确创建了一个界面)

(assuming I made an interface correctly)

由于我不是这个项目的唯一成员，所以我不希望有人用错误的数据类型调用RegisterAsListener函数.我可以在寄存器函数中放入代码来检查类型，但是如果编译器在试图推入错误的数据类型时只是对程序员大吼大叫，这将更加容易.

Since i'm not the only one on this project, I don't want somebody calling the RegisterAsListener function with an incorrect data type. I could put in code to check the type within the register function, but it would be easier all around if the compiler just yelled at the programmer when they try to shove in an incorrect data type.

def RegisterAsListener(self, IListener inListener):
    self.__TransitListeners.append(inListener)

有什么办法吗?

推荐答案

尽管我强烈建议您不要这样做，而只能使用Abstract Base Classes(

Although I would strongly recommend not doing this and only enforcing the implementation of certain methods using Abstract Base Classes (http://docs.python.org/2/library/abc.html), it is possible.

以下是有关如何执行此类操作的示例: http://www .artima.com/weblogs/viewpost.jsp?thread = 101605

Here's an example on how to do something like that: http://www.artima.com/weblogs/viewpost.jsp?thread=101605

# mm.py
registry = {}                                                                   

class MultiMethod(object):                                                      
    def __init__(self, name):                                                   
        self.name = name                                                        
        self.typemap = {}                                                       
    def __call__(self, *args):                                                  
        types = tuple(arg.__class__ for arg in args) # a generator expression!  
        function = self.typemap.get(types)                                      
        if function is None:                                                    
            raise TypeError("no match")                                         
        return function(*args)                                                  
    def register(self, types, function):                                        
        if types in self.typemap:                                               
            raise TypeError("duplicate registration")                           
        self.typemap[types] = function                                          

def multimethod(*types):                                                        
    def register(function):                                                     
        function = getattr(function, "__lastreg__", function)                   
        name = function.__name__                                                
        mm = registry.get(name)                                                 
        if mm is None:                                                          
            mm = registry[name] = MultiMethod(name)                             
        mm.register(types, function)                                            
        mm.__lastreg__ = function                                               
        return mm                                                               
    return register                                                             

    if hasattr(function, "__lastreg__"):                                        
        function = function.__lastreg__

以及使用它的代码:

import mm                                                                       

@mm.multimethod(int)                                                            
def spam(a):                                                                    
    print 'Calling the int method'                                              
    print '%s: %r' % (type(a), a)                                               

@mm.multimethod(float)                                                          
def spam(a):                                                                    
    print 'Calling the float method'                                            
    print '%s: %r' % (type(a), a)                                               

spam(5)                                                                         
spam(5.0)

示例输出:

Calling the int method
<type 'int'>: 5
Calling the float method
<type 'float'>: 5.0

这篇关于强制在Python中使用函数参数类型?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！