Question

在我的情况下，我有很多冗余代码，我想转移到单个函数。但关键是当我调用我的内部函数时，我想在我的父函数上调用return。

def foo(x):
    def inner_foo(x):
        print "COOL it's %s" % x
        return
    if x == 1:
        inner_foo(x)
    else:
        print "x is not 1"
    print "THIS LINE SHOULD NOT BE PRINTED"

>>> foo(2)
x is not 1
THIS LINE SHOULD NOT BE PRINTED
>>> foo(1)
COOL it's 1
THIS LINE SHOULD NOT BE PRINTED
>>>

所以当我拨打foo(1)时，我想不打印最后一行。

为了更清楚，我会给你一段我的代码（不要注意对你没有任何意义的变量和函数）。在这里，我实际上想要创建一个类似于此的函数：

def ack(tup):
    storm.ack(tup)
    return

这是代码

 def process(self, tup):                                                     
     """                                                                     
     Process single row, do a comparison with Redis                      
     """                                                                     
     if "__tick" in tup.stream:                                              
         LOG.info("tick")                                                    
         while len(self.failed_tups) > 0:                                    
             storm.ack(self.failed_tups.pop())                               
             return                                                          

     metadata = {}                                                           
     _fields = ['path_folder', 'hash']                                       
     req = self.extract_and_convert(tup)                                     
     if req is None or not isinstance(req, dict):                            
         LOG.error("This is not a valid dictionary >>> %s", req)             
         storm.ack(tup)                                                      
         return                                                              
     if not all(field in req.keys() for field in _fields):                   
         LOG.error("Not all fields are present in %s", req)                  
         storm.ack(tup)                                                      
         return                                                              
     status = self.compare_hashes(req)                                       
     if status == PROCESSED:                                                 
         LOG.warn("Message %s was already processed in the folder %s",          
                  req['message'],                                            
                  req['path_folder'])                                        
         storm.ack(tup)                                                      
         return                                                              
     elif status == NOT_FOUND:                                               
         self.not_found_hashes.append(tup)
         return                                   
     else:                                                                   
         # status == UNPROCESSED                                             
         storm.emit([req], anchors=[tup])                                    
         storm.ack(tup)

Answer 1

我相信您只想让函数返回实际值，然后在一个地方打印外部函数的结果：

def foo(x):
    def inner_foo(x):
        return "COOL it's %s" % x
    if x == 1:
        return inner_foo(x)
    else:
        return "x is not 1"

    # This line will *never* be reached
    print "THIS LINE SHOULD NOT BE PRINTED"

print foo(2)
print foo(1)

输出：

x is not 1
COOL it's 1

永远不会达到有问题的行，因为if语句的每一面最终都会return。您的inner_foo是否在我们的外部foo内定义无关紧要，这只是范围问题。

Answer 2

我知道的唯一方法是抛出一个异常，并在外部函数或该函数的调用者中捕获它。这类似于生成器抛出StopIteration异常以停止生成任何其他值，尽管函数的任意嵌套。然而，这种非本地控制流程通常是不受欢迎的。

例如：

def inner(i):
    if i < 0:
        raise MyException


def outer():
    try:
        inner(2)
        inner(3)
        inner(-1)
    except:
        pass

Answer 3

我认为你不能这样做。内部函数的return语句只会终止内部函数并返回一个值。它不应该影响封闭函数的执行。封闭函数需要自己的返回，或者封闭函数的调用将一直运行到函数体的末尾，并返回None。为了教育目的，在内部函数中引发异常然后在封闭函数中拦截它应该可以解决问题。

Answer 4

当然，只需在x == 1之后返回。

def foo(x):
    def inner_foo(x):
        print "COOL it's %s" % x
        return
    if x == 1:
        inner_foo(x)
        return
    else:
        print "x is not 1"
    print "THIS LINE SHOULD NOT BE PRINTED"

是否可以将“返回”从内部函数应用到输出函数

4 个答案: