python嵌套函数作用域怎么解释

Question

直接上代码

def l(list):
    def d():
        return list
    return d
    
 #运行
l = l([1,2,3,4])
print l()

这个情况是正常的。

问题在于d函数为什么不能传入list,然后我现在尝试了一下这个代码：

def l(list):
    def d(list):
        return list
    return d
 
#运行
l = l([1,2,3,4])
#提示错误
print l()

#正常
print l([1,3,5,7,9])

请问这个怎么解释呢？
我个人理解的是，类似于“继承”的情况，当d函数没有参数传入的情况上，基于父函数的参数，当他需要传参了，就覆盖了？？？

Answer 1

Lihat prinsip LEGB dan anda akan faham apa yang sedang berlaku.
https://zhuanlan.zhihu.com/p/...

Lari

l = l([1,2,3,4])

Ralat segera

print l() Ralat ini ialah anda tidak melepasi parameter.

Answer 2

Dalam kod asal:

def l(list):
    def d(list):
        return list
    return d  # <-- 这里是返回的一个要传入一个参数的函数
 
#运行
l = l([1,2,3,4])
#提示错误
print l() # <-- 这里没有传入参数报错，这里的 l 是 返回的闭包 d

#正常
print l([1,3,5,7,9]) # <-- 这里的 l 已经不是你最初定义的 l 而是 最初 l 中返回的 d

---

Yang berikut digunakan untuk menggambarkan: l dalam kod asal anda menghala ke titik yang berbeza:

def l(list):
    def d(list):
        return list
    return d
 
#运行
print 'id(l) is {}'.format(id(l))
l = l([1,2,3,4])
#提示错误
# print l()

#正常
print 'id(l) is {}'.format(id(l))
print l([1,3,5,7,9])

Anda mungkin faham jika kod ditulis seperti ini:

def l(_list):
    def d(_l):
        return _list + _l
    return d
 
a = l([1,2,3,4])
print a([1])

Dua mata akhir:

1. Jangan gunakan kata kunci seperti list sebagai nama pembolehubah

2. Jangan tulis ganti nama pembolehubah anda (melainkan benar-benar perlu)

Answer 3

Apa yang perlu difahami oleh poster ialah: Skop

Kes 1: Fungsi l mengembalikan alamat fungsi d, yang hanya digunakan sebagai nilai pulangan dan belum dipanggil untuk pelaksanaan.

In [3]: print(l([1,2,3,4]))
<function l.<locals>.d at 0x7f49243ece18>

Senarai parameter dihantar ke l, skop berada dalam fungsi l, dan boleh diakses oleh d (perhatikan bahawa parameter dihantar ke l, bukan d).
　
　　Jika anda ingin mengakses senarai, hubungi seperti berikut:
　　
　　`

    In [2]: print(l([1,2,3,4])())
    [1, 2, 3, 4]

    
相当于:
    

    In [5]: d = l([1,2,3,4])    # 返回ｄ的地址
    
    In [6]: d()　　　　　　　　　　＃调用ｄ,d没有参数，不需要传参
    Out[6]: [1, 2, 3, 4]

case 2:　同样l返回ｄ的地址，但此时返回的函数d需要传参（注意l的参数list和d的参数list是不一样的）．
　　　

    In [8]: d = l([1,2,3,4])　　#　返回函数ｄ的地址，参数list此时并没有用到
    
    In [9]: d([5,6,7,8])　　　　# 需要参数的函数ｄ
    Out[9]: [5, 6, 7, 8]