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

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

python function input

Python 如何将输入传递给函数，然后让它跨5个相互链接的内部函数使用该输入？,python,function,input,arguments,chaining,Python,Function,Input,Arguments,Chaining,我认为这基本上是两个问题如何使所有内部函数使用相同的原始输入如何使用该输入链接函数我一直在尝试用用户输入的任何字符制作一个圆形。（这是一个“为了好玩”的活动，我想出了这个活动来帮助我习惯函数。我现在只自学Python两周了）到目前为止，我的代码是： def circle(symbol): def lines1(aa): print(symbol * 20) aa() print(symbol * 20) return(li

我认为这基本上是两个问题

如何使所有内部函数使用相同的原始输入

如何使用该输入链接函数

我一直在尝试用用户输入的任何字符制作一个圆形。（这是一个“为了好玩”的活动，我想出了这个活动来帮助我习惯函数。我现在只自学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())

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

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

问题是它没有输出任何内容。

您的

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

都返回一个包装函数，传递给下一个函数，有效地使它们成为装饰器。我们从

行5

开始（作为函数引用，而不是调用它，然后调用嵌套包装的结果）

lines5

的定义现在也可以使用

@decorator

语法：

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

    line5()

您的

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()

你没有使用装饰器
要使代码按原样工作，请执行以下操作：
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()

看看这个关于装饰师的问题，我发现它在过去也非常有用：
您不使用装饰器
要使代码按原样工作，请执行以下操作：
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()

看看这个关于装饰师的问题，我发现它在过去也非常有用：
这里有很多重复，下面是我的功能型解决方案：
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())

有这么多重复，下面是我的功能型解决方案：
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())

你的return
语句在你的函数之外。你的return
语句在你的函数之外。我以为lines1（lines2（lines3（lines4（lines5（）））作为参数传入了下一个decorator，从而创建了一个到lines5的链？@JosephWebber：最里面的函数首先执行，所以lines5（）执行
，然后它的返回值被传递给执行的lines4（）
。约瑟夫·韦伯：在我的版本中，lines5
不执行。lines4（）
然后执行，这次以lines5
作为参数。它返回另一个函数wrapper
。这传递给lines3（）
等，直到行1（）
返回一个包装器函数。然后我们调用最后一个返回值。@JosephWebber:fromlines1
的包装器
然后执行，打印一行并调用lines2
返回的包装器
；它打印一行，从lines3
调用他wrapper
，一直到lines5
>调用并返回。然后以相反的顺序执行其他print
行。非常感谢，但我还有一个问题。在哪里调用装饰器合适/不合适？我认为lines1（lines2（lines3（lines4（lines5（）））是否将下一个decorator作为其参数传入，从而创建一个向下到lines5的链？@JosephWebber:首先执行最内部的函数，因此执行lines5（）
，然后将其返回值传递给lines4（）
，然后执行该函数。JosephWebber:在我的版本中，lines5
未执行。lines4（）
然后执行，这次使用lines5
作为参数。它返回另一个函数wrapper
。该函数传递给lines3（）
，等等，直到lines1（）
返回一个包装器函数。然后我们调用最后一个返回值。@JosephWebber:fromlines1
的包装器
然后执行，打印一行并调用lines2
返回的包装器
；它打印一行，从lines3
调用他wrapper
，一直到lines5
>调用并返回。然后以相反的顺序执行其他print
行。非常感谢，但我还有一个问题。在哪里调用装饰程序合适/不合适？我自己一直在查看该页，但它没有说明在所有这些行中使用原始输入。如果您希望我们添加一些，没问题对答案有更多的意见只需给我们留下一条评论raw_输入只需给我们留下一条评论，它本身与装饰器无关。我自己也看过那页，但它没有提到在所有页面中使用raw_输入。没问题，如果你想让我们在答案中添加更多内容，只需给我们留下一条评论raw_输入只需给我们留下一条评论，它就可以了当然，它本身与装饰师无关。