python閉包作用
① 什麼是閉包，我的理解
閉包是可以包含自由（未綁定到特定對象）變數的代碼塊；這些變數不是在這個代碼塊內或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義（局部變數）。「閉包」 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數被包含在代碼塊中，這些自由變數以及它們引用的對象沒有被釋放）和為自由變數提供綁定的計算環境（作用域）。在 Scala、Scheme、Common Lisp、Smalltalk、Groovy、javaScript、Ruby、 python、Lua、objective c 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。
中文名：閉包
外文名：closure
相關學科：離散數學
用途：編程邏輯
特點：未綁定到特定對象
分享
拓撲概念
集合A的閉包定義為所有包含A的閉集之交。A的閉包是包含A的最小閉集。
本質
集合 S 是閉集當且僅當 Cl(S)=S（這里的cl即closure，閉包）。特別的，空集的閉包是空集，X 的閉包是 X。集合的交集的閉包總是集合的閉包的交集的子集（不一定是真子集）。有限多個集合的並集的閉包和這些集合的閉包的並集相等；零個集合的並集為空集，所以這個命題包含了前面的空集的閉包的特殊情況。無限多個集合的並集的閉包不一定等於這些集合的閉包的並集，但前者一定是後者的父集。
若 A 為包含 S 的 X 的子空間，則 S 在 A 中計算得到的閉包等於 A 和 S 在 X 中計算得到的閉包（Cl_A(S) = A ∩ Cl_X(S））的交集。特別的，S在 A 中是稠密的，當且僅當 A 是 Cl_X(S) 的子集。
② python閉包到底有什麼作用
閉包——裝飾器的本質也是閉包
「閉包」的本質就是函數的嵌套定義，即在函數內部再定義函數，如下所示。
「閉包」有兩種不同的方式，第一種是在函數內部就「直接調用了」；第二種是「返回一個函數名稱」。
（1）第一種形式——直接調用
def Maker(name):
num=100
def func1(weight,height,age):
weight+=1
height+=1
age+=1
print(name,weight,height,age)
func1(100,200,300) #在內部就直接調用「內部函數」
Maker('feifei') #調用外部函數，輸出 feifei 101 201 301
（2）第二種形式——返回函數名稱
def Maker(name):
num=100
def func1(weight,height,age):
weight+=1
height+=1
age+=1
print(name,weight,height,age)
return func1 #此處不直接調用，而是返回函數名稱（Python中一切皆對象）
maker=Maker('feifei') #調用包裝器
maker(100,200,300) #調用內部函數
（3）「閉包」的作用——保存函數的狀態信息，使函數的局部變數信息依然可以保存下來，如下。
ef Maker(step): #包裝器
num=1
def fun1(): #內部函數
nonlocal num #nonlocal關鍵字的作用和前面的local是一樣的，如果不使用該關鍵字，則不能再內部函數改變「外部變數」的值
num=num+step #改變外部變數的值（如果只是訪問外部變數，則不需要適用nonlocal）
print(num)
return fun1
#=====================================#
j=1
func2=Maker(3) #調用外部包裝器
while(j<5):
func2() #調用內部函數4次 輸出的結果是 4、7、10、13
j+=1
從上面的例子可以看出，外部裝飾器函數的局部變數num=1、以及調用裝飾器Maker(3)時候傳入的參數step=3都被記憶了下來，所以才有1+3=4、4+3=7、7+3=10、10+3=13.
從這里可以看出，Maker函數雖然調用了，但是它的局部變數信息卻被保存了下來，這就是「閉包」的最大的作用——保存局部信息不被銷毀。
③ python閉包如何理解
首先會在g函數裡面找j，如果找不到，則會在外面一層找。如果在g函數裡面加一句j=4,則屏蔽了外面的j，會輸出三個16。另外，python3裡面可以運行
④ python函數的閉包怎麼理解
1. 閉包的概念
首先還得從基本概念說起，什麼是閉包呢？來看下維基上的解釋:
復制代碼代碼如下:
在計算機科學中，閉包（Closure）是詞法閉包（Lexical Closure）的簡稱，是引用了自由變數的函數。這個被引用的自由變數將和這個函數一同存在，即使已經離開了創造它的環境也不例外。所以，有另一種說法認為閉包是由函數和與其相關的引用環境組合而成的實體。閉包在運行時可以有多個實例，不同的引用環境和相同的函數組合可以產生不同的實例。
....
上面提到了兩個關鍵的地方： 自由變數 和 函數, 這兩個關鍵稍後再說。還是得在贅述下「閉包」的意思，望文知意，可以形象的把它理解為一個封閉的包裹，這個包裹就是一個函數，當然還有函數內部對應的邏輯，包裹裡面的東西就是自由變數，自由變數可以在隨著包裹到處游盪。當然還得有個前提，這個包裹是被創建出來的。
在通過Python的語言介紹一下，一個閉包就是你調用了一個函數A，這個函數A返回了一個函數B給你。這個返回的函數B就叫做閉包。你在調用函數A的時候傳遞的參數就是自由變數。
舉個例子：
復制代碼代碼如下:
def func(name):
def inner_func(age):
print 'name:', name, 'age:', age
return inner_func
bb = func('the5fire')
bb(26) # >>> name: the5fire age: 26
這裡面調用func的時候就產生了一個閉包——inner_func,並且該閉包持有自由變數——name，因此這也意味著，當函數func的生命周期結束之後，name這個變數依然存在，因為它被閉包引用了，所以不會被回收。
另外再說一點，閉包並不是Python中特有的概念，所有把函數做為一等公民的語言均有閉包的概念。不過像Java這樣以class為一等公民的語言中也可以使用閉包，只是它得用類或介面來實現。
更多概念上的東西可以參考最後的參考鏈接。
2. 為什麼使用閉包
基於上面的介紹，不知道讀者有沒有感覺這個東西和類有點相似，相似點在於他們都提供了對數據的封裝。不同的是閉包本身就是個方法。和類一樣，我們在編程時經常會把通用的東西抽象成類，（當然，還有對現實世界——業務的建模），以復用通用的功能。閉包也是一樣，當我們需要函數粒度的抽象時，閉包就是一個很好的選擇。
在這點上閉包可以被理解為一個只讀的對象，你可以給他傳遞一個屬性，但它只能提供給你一個執行的介面。因此在程序中我們經常需要這樣的一個函數對象——閉包，來幫我們完成一個通用的功能，比如後面會提到的——裝飾器。
3. 使用閉包
第一種場景 ，在python中很重要也很常見的一個使用場景就是裝飾器，Python為裝飾器提供了一個很友好的「語法糖」——@，讓我們可以很方便的使用裝飾器，裝飾的原理不做過多闡述，簡言之你在一個函數func上加上@decorator_func, 就相當於decorator_func(func):
復制代碼代碼如下:
def decorator_func(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@decorator_func
def func(name):
print 'my name is', name
# 等價於
decorator_func(func)
在裝飾器的這個例子中，閉包（wrapper）持有了外部的func這個參數，並且能夠接受外部傳過來的參數，接受過來的參數在原封不動的傳給func，並返回執行結果。
這是個簡單的例子，稍微復雜點可以有多個閉包，比如經常使用的那個LRUCache的裝飾器，裝飾器上可以接受參數@lru_cache(expire=500)這樣。實現起來就是兩個閉包的嵌套:
復制代碼代碼如下:
def lru_cache(expire=5):
# 默認5s超時
def func_wrapper(func):
def inner(*args, **kwargs):
# cache 處理 bala bala bala
return func(*args, **kwargs)
return inner
return func_wrapper
@lru_cache(expire=10*60)
def get(request, pk)
# 省略具體代碼
return response()
不太懂閉包的同學一定得能夠理解上述代碼，這是我們之前面試經常會問到的面試題。
第二個場景 ，就是基於閉包的一個特性——「惰性求值」。這個應用比較常見的是在資料庫訪問的時候，比如說：
復制代碼代碼如下:
# 偽代碼示意
class QuerySet(object):
def __init__(self, sql):
self.sql = sql
self.db = Mysql.connect().corsor() # 偽代碼
def __call__(self):
return db.execute(self.sql)
def query(sql):
return QuerySet(sql)
result = query("select name from user_app")
if time > now:
print result # 這時才執行資料庫訪問
上面這個不太恰當的例子展示了通過閉包完成惰性求值的功能，但是上面query返回的結果並不是函數，而是具有函數功能的類。有興趣的可以去看看Django的queryset的實現，原理類似。
第三種場景 ， 需要對某個函數的參數提前賦值的情況，當然在Python中已經有了很好的解決訪問 functools.parial,但是用閉包也能實現。
復制代碼代碼如下:
def partial(**outer_kwargs):
def wrapper(func):
def inner(*args, **kwargs):
for k, v in outer_kwargs.items():
kwargs[k] = v
return func(*args, **kwargs)
return inner
return wrapper
@partial(age=15)
def say(name=None, age=None):
print name, age
say(name="the5fire")
# 當然用functools比這個簡單多了
# 只需要： functools.partial(say, age=15)(name='the5fire')
看起來這又是一個牽強的例子，不過也算是實踐了閉包的應用。
⑤ 閉包的實質是什麼
閉包（closure）是計算機編程領域的專業名詞，指可以包含自由（未綁定到特定對象）變數的代碼塊，子函數可以使用父函數中的局部變數。閉包源於要執行的代碼塊和為自由變數提供綁定的計算環境（作用域）兩者的結合，Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Lua、objective c 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。
本質
集合 S 是閉集當且僅當 Cl(S)=S（這里的cl即closure，閉包）。特別的，空集的閉包是空集，X 的閉包是 X。集合的交集的閉包總是集合的閉包的交集的子集（不一定是真子集）。有限多個集合的並集的閉包和這些集合的閉包的並集相等；零個集合的並集為空集，所以這個命題包含了前面的空集的閉包的特殊情況。無限多個集合的並集的閉包不一定等於這些集合的閉包的並集，但前者一定是後者的父集。
若 A 為包含 S 的 X 的子空間，則 S 在 A 中計算得到的閉包等於 A 和 S 在 X 中計算得到的閉包（Cl_A(S) = A ∩ Cl_X(S））的交集。特別的，S在 A 中是稠密的，當且僅當 A 是 Cl_X(S) 的子集。
度量空間中的閉包
對歐幾里德空間的子集 S，x 是 S 的閉包點，若所有以 x 為中心的開球都包含 S 的點（這個點也可以是 x）。
這個定義可以推廣到度量空間 X 的任意子集 S。具體地說，對具有度量 d 的度量空間 X，x 是 S 的閉包點，若對所有 r>0，存在 y 屬於 S，使得距離 d(x,y)<r（同樣的，可以是 x = y）。另一種說法可以是，x 是 S 的閉包點，若距離 d(x,S) := inf{d(x,s) : s 屬於 S} = 0（這里 inf 表示下確界）。
這個定義也可以推廣到拓撲空間，只需要用鄰域替代「開球」。設 S 是拓撲空間 X 的子集，則 x 是 S 的閉包點，若所有 x 鄰域都包含 S 的點。注意，這個定義並不要求鄰域是開的。
⑥ 什麼是Python中的閉包
閉包
1.函數引用
運行結果：
圖解：
相關推薦：《Python視頻教程》
2.什麼是閉包
運行結果：
3.看一個閉包的實際例子：
運行結果：
這個例子中，函數line與變數a,b構成閉包。在創建閉包的時候，我們通過line_conf的參數a,b說明了這兩個變數的取值，這樣，我們就確定了函數的最終形式(y = x + 1和y = 4x + 5)。我們只需要變換參數a,b，就可以獲得不同的直線表達函數。由此，我們可以看到，閉包也具有提高代碼可復用性的作用。
如果沒有閉包，我們需要每次創建直線函數的時候同時說明a,b,x。這樣，我們就需要更多的參數傳遞，也減少了代碼的可移植性。
相關推薦：
Python中的迭代器是什麼
⑦ 閉包是什麼，有什麼特性，對頁面有什麼影響
閉包是可以包含自由（未綁定到特定對象）變數的代碼塊；這些變數不是在這個代碼塊內或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義（局部變數）。「閉包」 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數被包含在代碼塊中，這些自由變數以及它們引用的對象沒有被釋放）和為自由變數提供綁定的計算環境（作用域）。在 Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。
閉包 (closure）是個精確但又很難解釋的電腦名詞。在 Perl 裡面，閉包是以 匿名函數的形式來實現，具有持續參照位於該函數范圍之外的文字式變數值的能力。這些外部的文字變數會神奇地保留它們在閉包函數最初定義時的值 （深連結）。
如果一個程式語言容許函數遞回另一個函數的話 （像 Perl 就是），閉包便具有意義。要注意的是，有些語言雖提供匿名函數的功能，但卻無法正確處理閉包； Python 這個語言便是一例。如果要想多了解閉包的話，建議你去找本功能性程式 設計的教科書來看。Scheme這個語言不僅支持閉包，更鼓勵多加使用。
以下是個典型的產生函數的函數：
sub add_function_generator {
return sub { shift + shift };
}
$add_sub = add_function_generator();
$sum = &$add_sub(4,5)； # $sum是 9了
閉包用起來就像是個函數樣板，其中保留了一些可以在稍後再填入的空格。add_function_generator() 所遞回的匿名函數在技術上來講並不能算是一個閉包， 因為它沒有用到任何位在這個函數范圍之外的文字變數。
把上面這個例子和下面這個make_adder()函數對照一下，下面這個函數所遞回的匿名函數中使用了一個外部的文字變數。這種指明外部函數的作法需要由 Perl遞回一個適當的閉包，因此那個文字變數在匿名函數產生之時的值便永久地被鎖進閉包里。
sub make_adder {
my $addpiece = shift;
return sub { shift + $addpiece };
}
$f1 = make_adder(20)；
$f2 = make_adder(555)；
這樣一來&$f1($n) 永遠會是 20加上你傳進去的值$n ，而&$f2($n) 將 永遠會是 555加上你傳進去的值$n。$addpiece的值會在閉包中保留下來。
閉包在比較實際的場合中也常用得到，譬如當你想把一些程式碼傳入一個函數時：
my $line;
timeout（30,sub { $line = <STDIN> });
如果要執行的程式碼當初是以字串的形式傳入的話，即'$line = <STDIN>' ，那麼timeout() 這個假想的函數在回到該函數被呼叫時所在的范圍後便無法再擷取$line這個文字變數的值了。
語法結構編輯
Groovy的閉包
閉包（Closure）是Java所不具備的語法結構。閉包就是一個代碼塊，用「{ }」包起來。此時，程序代碼也就成了數據，可以被一個變數所引用（與C語言的函數指針比較類似）。閉包的最典型的應用是實現回調函數（callback）。Groovy的API大量使用閉包，以實現對外開放。閉包的創建過程很簡單，例如：
{ 參數 ->
代碼...
}
參考下面的例子代碼，定義了c1和c2兩個閉包，並對它們進行調用：
def c1 = { println it }
def c2 = { text -> println text }
c1.call("content1") //用call方法調用閉包
c2("content2") //直接調用閉包
「->；」之前的部分為閉包的參數，如果有多個參數，之間可用逗號分割；「->；」之後的部分為閉包內的程序代碼。如果省略了「->；」和它之前的部分，此時閉包中代碼，可以用名為「it」的變數訪問參數。
閉包的返回值和函數的返回值定義方式是一樣的：如果有return語句，則返回值是return語句後面的內容；如果沒有return語句，則閉包內的最後一行代碼就是它的返回值。[1]
環境表達編輯
在Javascript中閉包（Closure)
什麼是閉包
「官方」的解釋是：所謂「閉包」，指的是一個擁有許多變數和綁定了這些變數的環境的表達式（通常是一個函數），因而這些變數也是該表達式的一部分。
相信很少有人能直接看懂這句話，因為他描述的太學術。我想用如何在Javascript中創建一個閉包來告訴你什麼是閉包，因為跳過閉包的創建過程直接理解閉包的定義是非常困難的。看下面這段
代碼
1
2
3
4
5
6
7
8
9
function a(){
var i=0;
function b(){
alert(++i);
}
return b;
}
var c=a();
c();
特點
這段代碼有兩個特點：
1、函數b嵌套在函數a內部；
2、函數a返回函數b。
這樣在執行完var c=a( )後，變數c實際上是指向了函數b，再執行c( )後就會彈出一個窗口顯示i的值（第一次為1）。這段代碼其實就創建了一個閉包，為什麼？因為函數a外的變數c引用了函數a內的函數b，就是說：
當函數a的內部函數b被函數a外的一個變數引用的時候，就創建了一個閉包。
作用
簡而言之，閉包的作用就是在a執行完並返回後，閉包使得Javascript的垃圾回收機制GC不會收回a所佔用的資源，因為a的內部函數b的執行需要依賴a中的變數。這是對閉包作用的非常直白的描述，不專業也不嚴謹，但大概意思就是這樣，理解閉包需要循序漸進的過程。
在上面的例子中，由於閉包的存在使得函數a返回後，a中的i始終存在，這樣每次執行c（），i都是自加1後alert出i的值。
那 么我們來想像另一種情況，如果a返回的不是函數b，情況就完全不同了。因為a執行完後，b沒有被返回給a的外界，只是被a所引用，而此時a也只會被b引 用，因此函數a和b互相引用但又不被外界打擾（被外界引用），函數a和b就會被GC回收。（關於Javascript的垃圾回收機制將在後面詳細介紹）
另一個例子
模擬私有變數
function Counter(start){
var count = start;
return{
increment:function(){
count++;
},
get:function(){
return count;
}
}
}
var foo =Counter(4);
foo.increment();
foo.get();// 5
結果
這里，Counter 函數返回兩個閉包，函數 increment 和函數 get。 這兩個函數都維持著 對外部作用域 Counter 的引用，因此總可以訪問此作用域內定義的變數 count.
文法
objective c的閉包（block）
objective c 中的的閉包，是通過block實現的。Apple在C，Objective-C和C++中擴充了Block這種文法的，並且在GCC4.2中進行了支持。你可以把它理解為函數指針，匿名函數，閉包，lambda表達式，這里暫且用塊對象來表述，因為它們之間還是有些許不同的。
聲明一個塊
如果以內聯方式使用塊對象，則無需聲明。塊對象聲明語法與函數指針聲明語法相似，但是塊對象應使用脫字元(^)而非星號指針 (*)。下面的代碼聲明一個aBlock變數，它標識一個需傳入三個參數並具有float返回值的塊。
float (^aBlock)(const int*, int, float);
l 創建一個塊
塊使用脫字元(^)作為起始標志，使用分號作為結束標志。下面的例子聲明一個簡單塊，並且將其賦給之前聲明的block變數（oneFrom）。
int (^oneFrom)(int);
oneFrom = ^(int anInt) {
return anInt - 1;
};
微觀世界
如 果要更加深入的了解閉包以及函數a和嵌套函數b的關系，我們需要引入另外幾個概念：函數的執行環境（execution context）、活動對象（call object）、作用域（scope）、作用域鏈（scope chain）。以函數a從定義到執行的過程為例闡述這幾個概念。
1、當定義函數a的時候，js解釋器會將函數a的作用域鏈（scope chain）設置為定義a時a所在的「環境」，如果a是一個全局函數，則scope chain中只有window對象。
2、當函數a執行的時候，a會進入相應的執行環境（execution context）。
3、在創建執行環境的過程中，首先會為a添加一個scope屬性，即a的作用域，其值就為第1步中的scope chain。即a.scope=a的作用域鏈。
4、然後執行環境會創建一個活動對象（call object）。活動對象也是一個擁有屬性的對象，但它不具有原型而且不能通過JavaScript代碼直接訪問。創建完活動對象後，把活動對象添加到a的作用域鏈的最頂端。此時a的作用域鏈包含了兩個對象：a的活動對象和window對象。
5、下一步是在活動對象上添加一個arguments屬性，它保存著調用函數a時所傳遞的參數。
6、最後把所有函數a的形參和內部的函數b的引用也添加到a的活動對象上。在這一步中，完成了函數b的的定義，因此如同第3步，函數b的作用域鏈被設置為b所被定義的環境，即a的作用域。
到此，整個函數a從定義到執行的步驟就完成了。此時a返回函數b的引用給c，又函數b的作用域鏈包含了對函數a的活動對象的引用，也就是說b可以訪問到a中定義的所有變數和函數。函數b被c引用，函數b又依賴函數a，因此函數a在返回後不會被GC回收。
當函數b執行的時候亦會像以上步驟一樣。因此，執行時b的作用域鏈包含了3個對象：b的活動對象、a的活動對象和window對象，如下圖所示：
如圖所示，當在函數b中訪問一個變數的時候，搜索順序是先搜索自身的活動對象，如果存在則返回，如果不存在將繼續搜索函數a的活動對象，依 次查找，直到找到為止。如果整個作用域鏈上都無法找到，則返回undefined。如果函數b存在prototype原型對象，則在查找完自身的活動對象 後先查找自身的原型對象，再繼續查找。這就是Javascript中的變數查找機制。
應用場景
1、保護函數內的變數安全。以最開始的例子為例，函數a中i只有函數b才能訪問，而無法通過其他途徑訪問到，因此保護了i的安全性。
2、在內存中維持一個變數。依然如前例，由於閉包，函數a中i的一直存在於內存中，因此每次執行c（），都會給i自加1。
以上兩點是閉包最基本的應用場景，很多經典案例都源於此。
回收機制
在Javascript中，如果一個對象不再被引用，那麼這個對象就會被GC回收。如果兩個對象互相引用，而不再被第3者所引用，那麼這兩個互相引用的對象也會被回收。因為函數a被b引用，b又被a外的c引用，這就是為什麼函數a執行後不會被回收的原因。
匿名內部
在Python中的閉包（Closure)
學過Java GUI編程的人都知道定義匿名內部類是注冊監聽等處理的簡潔有效手段，閉包的定義方式有點類似於這種匿名內部類，
但是閉包的作用威力遠遠超過匿名內部類，這也是很多流行動態語言選擇閉包的原因，相信你在JavaScript中已經了解它的神奇功效了。
定義
如果在一個內部函數里，對在外部作用域（但不是在全局作用域）的變數進行引用，那麼內部函數就被認為是閉包（closure）。
簡單閉包的例子：
下面是一個使用閉包簡單的例子，模擬一個計數器，通過將整型包裹為一個列表的單一元素來模擬使看起來更易變：
函數counter（）所作的唯一一件事就是接受一個初始化的值來計數，並將該值賦給列表count成員，然後定義一個內部函數incr（）。通過內部函數使用變數count，就創建了一個閉包。最魔法的地方是counter（）函數返回一個incr（），一個可以調用的函數對象。
運行：
>>> c = counter⑸
>>> type(c)
<type 'function'>
>>> print c()6
>>> print c()
7
代碼格式較重要
>>> c2 = counter（99）
100
>>> print c()
8
⑧ python 閉包可以修改嗎
在python3.0之前的版本中, 閉包只能夠訪問而不能修改外部變數(非全局), 所以, 通常為了方便修改, 我們就使用可變對象來通過修改對象內部的一些引用來達到間接修改的目的, 因此, 通常的數字類型, 字元串類型等不可變類型不可以作為用於修改的自由變數(閉包中引用的外部變數)
在python3.0及以後版本中, 通過nonlocal關鍵字解決了這個問題, 並增強了閉包. 在之前的版本中, 外部變數實際上是會放入內部函數(閉包)的local這個名稱空間中的, 所以, 在之前版本中, 我們在閉包內試圖修改一個外部變數的時候, 往往會得到一個"在引用之前沒有賦值"的一個錯誤. 3.0之後, 給要在閉包內修改的變數加上(在閉包內修改之前)nonlocal的聲明, 然後, 在下面的代碼中修改就可以了....
這個用法和global關鍵字解決函數內修改全局變數有異曲同工之妙...
⑨ 閉包的實質是什麼
閉包就是能夠讀取其他函數內部變數的函數。例如在javascript中，只有函數內部的子函數才能讀取局部變數，所以閉包可以理解成「定義在一個函數內部的函數「。在本質上，閉包是將函數內部和函數外部連接起來的橋梁。
集合 S 是閉集當且僅當 Cl(S)=S（這里的cl即closure，閉包）。特別的，空集的閉包是空集，X 的閉包是 X。集合的交集的閉包總是集合的閉包的交集的子集（不一定是真子集）。有限多個集合的並集的閉包和這些集合的閉包的並集相等；零個集合的並集為空集，所以這個命題包含了前面的空集的閉包的特殊情況。無限多個集合的並集的閉包不一定等於這些集合的閉包的並集，但前者一定是後者的父集。
若 A 為包含 S 的 X 的子空間，則 S 在 A 中計算得到的閉包等於 A 和 S 在 X 中計算得到的閉包（Cl_A(S) = A ∩ Cl_X(S））的交集。特別的，S在 A 中是稠密的，當且僅當 A 是 Cl_X(S) 的子集。
⑩ 什麼是閉包，閉包寫多了會出現什麼問題
閉包是指可以包含自由（未綁定到特定對象）變數的代碼塊；這些變數不是在這個代碼塊內或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義（局部變數）。「閉包」 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數被包含在代碼塊中，這些自由變數以及它們引用的對象沒有被釋放）和為自由變數提供綁定的計算環境（作用域）。在PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。