Позиционные аргументы во вложенных функциях
Этот вопрос относится к этому видео: https://thewikihow.com/video_jXugs4B3lwU
Часть, которую мне не хватает, несколько проще, чем концепция, которую в целом раскрывает видео. В примере кода ниже: Почему внутренняя функция (inner()) получает значение аргумента, который передается при вызове функции f и g? (т.е. f("y arg"), g("other y arg"))
На мой неопытный взгляд, функция level_five имеет только один определенный параметр («n»), на который ссылается при назначении переменной «z» в определении функции level_five. Ни в коем случае параметр с именем 'y', определенный во внешнем определении функции (level_five), не должен передаваться в внутренний().... так как же внутренний() неявно выбирает переданное значение в качестве параметра y, когда внешняя функция звонят?
Мне кажется, это потому, что когда функция назначается f или g, был определен первый позиционный аргумент (т. е. это значение переходит в параметр 'n' level_five при вызове f или g), а затем аргумент, передаваемый в f или g. g при их вызове каким-то загадочным образом подхватывается в качестве второго позиционного параметра, как будто в определении level_five присутствует неявный *args, и таким образом направляется к внутренней()....Мне удалось запутать сам о том, как именно это происходит, может ли кто-нибудь это прояснить?
x = "global x"
def level_five(n):
z = f"outer z {n}"
def inner(y):
return x, y, z
return inner
def main():
f = level_five(0)
g = level_five(1)
print(f("y arg"), g("other y arg"))
main()
@larsks, окей, спасибо, эта терминология помогает мне найти способы ее понять. До сих пор не совсем понятно, как он определяет, какой аргумент в конечном итоге переходит к какому параметру в определении, я предполагаю, что он просто сортирует сверху вниз и слева направо для каждой строки, назначая в качестве позиционных аргументов, пока все не получит значение или не закончатся значения. и вызывает исключение?
Ах, спасибо, что это немного щелкнуло выключателем лампочки, если это рассуждение в некоторой степени верно. По сути, вызов level_five возвращает встроенную() как целую функцию, которая только что сохраняется в переменной, и когда эта возвращаемая функция (внутренняя) была определена, у нее уже определены другие переменные кортежа, который она возвращает (это часть замыкания) , и, следовательно, в его определении остается только один позиционный параметр (y), и поэтому он получает один аргумент, который передается при вызове f или g... это примерно так?
Хорошо, порцию чтения позже, для меня это имеет больше смысла. Не осознавал, что можно передать целую функцию, не говоря уже о «завернутой и частично подготовленной»! Спасибо всем.
Ответы 1
Когда вы запускаете level_five(0), он возвращает функцию и сохраняет ее в f. Поскольку функция еще не запускалась, не было необходимости передавать в функцию (внутреннюю) какой-либо аргумент (y). Функция, хранящаяся в f, ведет себя следующим образом:
def f(y):
return 0 , y , "outer z 0"
а затем вы можете просто запустить f, как вы это сделали в операторе печати.
Таким образом, вызов level_five приводит к возврату внутренней(), которая сохраняется в переменной (f и g), но когда она была возвращена, два значения для кортежа внутренней() уже определены (это часть замыкания), и следовательно, остался только один позиционный параметр согласно функции def внутреннего (а именно 'y'), и, следовательно, как/почему arg, который передается при вызове f или g, в конечном итоге передается позиционно параметру y внутреннего ( который в данном случае является единственным позиционным аргументом замыкания)... это верно?
Это называется замыканиями; на этот вопрос есть ответы, специфичные для Python, а эта статья в Википедии охватывает общую тему.