如何将输入传递给函数，然后让它跨5个相互链接的内部函数使用该输入？

Question

我认为这基本上是两个问题。你知道吗

1. 如何使所有内部函数使用相同的原始输入？你知道吗
2. 如何用该输入链接函数？你知道吗

我一直在尝试用用户输入的任何字符制作一个圆形。（这是一个“为了好玩”的活动，我想出了帮助我习惯的功能。我只自学Python两周了）
到目前为止，我的代码是：

def circle(symbol):

    def lines1(aa):
        print(symbol * 20)
        aa()
        print(symbol * 20)
    return(lines1)

    def lines2(bb):
        print(symbol * 7 + ' ' * 6 + symbol * 7)
        bb()
        print(symbol * 7 + ' ' * 6 + symbol * 7)
    return(lines2)

    def lines3(cc):
        print(symbol * 4 + ' ' * 12 + symbol * 4)
        cc()
        print(symbol * 4 + ' ' * 12 + symbol * 4)
    return(lines3)

    def lines4(dd):
        print(symbol * 2 + ' ' * 16 + symbol * 2)
        dd()
        print(symbol * 2 + ' ' * 16 + symbol * 2)
    return(lines4)

    def lines5():
        print(symbol + ' ' * 18 + symbol)
        print(symbol + ' ' * 18 + symbol)
    return(lines5)

    lines1(lines2(lines3(lines4(lines5()))))

circle(raw_input())

示例：如果用户输入一个#，则应该输出：

####################
#######      #######
####            ####
##                ##
#                  #
#                  #
##                ##
####            ####
#######      #######
####################

问题是它没有输出任何东西。你知道吗

Answer 1

重复太多了，下面是我的功能风格解决方案：

def cycle(s):
    def lines1(symbol):
        print(symbol * 20)

    def lines2(symbol):
        print(symbol * 7 + ' ' * 6 + symbol * 7)

    def lines3(symbol):
        print(symbol * 4 + ' ' * 12 + symbol * 4)

    def lines4(symbol):
        print(symbol * 2 + ' ' * 16 + symbol * 2)

    def lines5(symbol):
        print(symbol + ' ' * 18 + symbol)

    def combine(F, *FS):
        if not FS: return F
        fn, rest = FS[0], FS[1:]
        def wrapper(s):
            fn(s)
            F(s)
            fn(s)
        return combine(wrapper, *rest)

    return combine(lines5, lines4, lines3, lines2, lines1)(s)

cycle(raw_input())

Answer 2

你不使用装饰器

要使代码按原样工作：

class circle(object):

    def __init__(self, symbol):    
        self.symbol = symbol

    def lines1(self):
        print(self.symbol * 20)
        print(self.symbol * 20)

    def lines2(self):
        print(self.symbol * 7 + ' ' * 6 + self.symbol * 7)
        print(self.symbol * 7 + ' ' * 6 + self.symbol * 7)


    def lines3(self):
        print(self.symbol * 4 + ' ' * 12 + self.symbol * 4)
        print(self.symbol * 4 + ' ' * 12 + self.symbol * 4)

    def lines4(self):
        print(self.symbol * 2 + ' ' * 16 + self.symbol * 2)
        print(self.symbol * 2 + ' ' * 16 + self.symbol * 2)

    def lines5(self):
        print(self.symbol + ' ' * 18 + self.symbol)
        print(self.symbol + ' ' * 18 + self.symbol)

    def print_circle(self):
        self.lines1()
        self.lines2()
        self.lines3()
        self.lines4()
        self.lines5()
        self.lines4()
        self.lines3()
        self.lines2()
        self.lines1()

x = circle(raw_input())
x.print_circle()

看看这个关于装饰师的问题，我发现它在过去也非常有用： How to make a chain of function decorators?

Answer 3

cicles函数提前返回：

def circle(symbol):

    def lines1(aa):
        print(symbol * 20)
        aa()
        print(symbol * 20)
    return(lines1)

剩下的函数是而不是执行的。你知道吗

接下来，使用希望调用其他函数的函数，但从不传入参数。aa()没有任何对lines2()函数的引用。你知道吗

相反，您调用lines5()，它返回None，然后将其传递给lines4()，后者不能调用lines4()。你知道吗

您将需要内包装，使这项工作的方式，你想：

def circle(symbol):

    def lines1(inner):
        def wrapper():
            print(symbol * 20)
            inner()
            print(symbol * 20)
        return wrapper

    def lines2(inner):
        def wrapper():
            print(symbol * 7 + ' ' * 6 + symbol * 7)
            inner()
            print(symbol * 7 + ' ' * 6 + symbol * 7)
        return wrapper

    def lines3(inner):
        def wrapper():
            print(symbol * 4 + ' ' * 12 + symbol * 4)
            inner()
            print(symbol * 4 + ' ' * 12 + symbol * 4)
        return wrapper

    def lines4(inner):
        def wrapper():
            print(symbol * 2 + ' ' * 16 + symbol * 2)
            inner()
            print(symbol * 2 + ' ' * 16 + symbol * 2)
        return wrapper

    def lines5():
        print(symbol + ' ' * 18 + symbol)
        print(symbol + ' ' * 18 + symbol)

    lines1(lines2(lines3(lines4(lines5))))()

现在函数lines1到lines4都返回一个包装器函数，传递给下一个函数，有效地使它们成为装饰器。我们从lines5（作为函数引用，而不是调用它开始，然后调用嵌套包装器的结果。你知道吗

lines5的定义现在也可以使用@decorator语法：

    @lines1
    @lines2
    @lines3
    @lines4
    def lines5():
        print(symbol + ' ' * 18 + symbol)
        print(symbol + ' ' * 18 + symbol)

    line5()