摘要：序言源起于開發(fā)者公眾號(hào)轉(zhuǎn)載的深刻理解中的元類一文回憶著自己看過(guò)的元編程一書參照寫個(gè)相應(yīng)的版和在很多方面都非常相像特別是的設(shè)計(jì)部分參考了但在很多方面它倆的很多概念并非一一對(duì)應(yīng)的在這里的元類在中并沒有相應(yīng)的概念如果理解為創(chuàng)建類的類最相近的應(yīng)該是
live with scope
序言
源起于Python開發(fā)者"公眾號(hào)轉(zhuǎn)載的深刻理解Python中的元類一文, 回憶著自己看過(guò)的 Ruby元編程 一書, 參照寫個(gè)相應(yīng)的Ruby版.
Python和Ruby在很多方面都非常相像, 特別是Ruby的設(shè)計(jì)部分參考了Python. 但在很多方面, 它倆的很多概念并非一一對(duì)應(yīng)的. 在這里的 元類 在Ruby 中并沒有相應(yīng)的概念, 如果理解為創(chuàng)建類的類, 最相近的應(yīng)該是Class .
這里不會(huì)將那篇文章的內(nèi)容都復(fù)制過(guò)來(lái), 只是挑選不一樣的地方寫一寫, 因此, 你最好已經(jīng)讀過(guò)那篇文章了. 讀這篇時(shí), 最好對(duì)照著讀.
類也是對(duì)象
相比Python, Ruby語(yǔ)言有著最純粹的面向?qū)ο缶幊痰脑O(shè)計(jì). 同樣的,Ruby的類的概念也是借鑒于Smalltalk. 關(guān)于什么是類, 我更傾向于理解為, 描述一個(gè)對(duì)象的狀態(tài)(實(shí)例變量)和操作(方法)的代碼段.
class ObjectCreator < Object; end #=> nil
my_object = ObjectCreator.new #=>#
print my_object #=>nil
說(shuō)明:
類默認(rèn)繼承自Object, 因此< Object非必要. 原文的Python代碼也是.
在Ruby 中, 在不引起歧義的前提下, 函數(shù)調(diào)用的()可以省略. 這里同原文的Python 代碼雖然看起來(lái)相同, 但原理完全不同.Python2.7中, print實(shí)現(xiàn)為語(yǔ)句, 但在Python 3.x中, 實(shí)現(xiàn)為全局函數(shù), 則必須加()表示調(diào)用.
這里的#=>表示輸出的結(jié)果, print無(wú)輸出, 即nil來(lái)表示無(wú)
同Python, Ruby的類同樣也是對(duì)象. 不同于Python, Ruby中的class實(shí)際是打開一個(gè)類, 如果類不存在則創(chuàng)建它. 換句話說(shuō), 在Python中重復(fù)class定義同一類, 后者會(huì)覆蓋前者, 而在Ruby中, 類是同一個(gè), 后者只是給這個(gè)類添加了新的方法或變量.
Python:
class N1:
def __init__(self, name):
self.name = name
def hello(self, s):
return self.name + s
N1("lzp").hello(" is good man") #=> "lzp is good man"
class N1:
def __init__(self, name):
self.name = name
def world(self, s):
return self.name + s
N1("lzp").hello(" is good man") #=> AttributeError, 無(wú)屬性
N1("lzp").world(" is good man") #=> "lzp is good man"
Ruby:
class N1
def initialize(name)
@name = name
end
def hello(s)
@name + s
end
end
N1.new("lzp").hello(" is good man") #=> "lzp is good man"
class N1
def initialize(name)
@name = name
end
def world(s) @name + s end
end
N1("lzp").hello(" is good man") #=> "lzp is good man"
N1("lzp").world(" is good man") #=> "lzp is good man"
Ruby少了無(wú)語(yǔ)的self, 但多了無(wú)語(yǔ)的end.
Ruby的函數(shù)默認(rèn)返回最后一個(gè)表達(dá)式的值, 但在Python中則必須顯示地return.
Ruby的方法定義可以寫成一行,Python來(lái)咬我啊
很多語(yǔ)言都聲稱 _xx語(yǔ)言中一切都是對(duì)象_, 包括Java. 很明顯, 不同語(yǔ)言中的對(duì)象概念應(yīng)該是有區(qū)別的, 那么如何來(lái)理解對(duì)象呢. 這里我基本同意原文中所說(shuō), 可賦值, 可拷貝, 可增加屬性, 可作參傳遞.
注意, 不要將對(duì)象和對(duì)象的引用混淆, 對(duì)象的引用往往表現(xiàn)為常見的各種標(biāo)識(shí)符.
Rb: ObjectCreator.to_s #=> "ObjectCreator"
Py: str(ObjectCreator) #=>
由于print函數(shù)實(shí)際是調(diào)用對(duì)象轉(zhuǎn)字符串后輸出, 并無(wú)特殊意義. 下面的例子更好地展示了, 作參傳遞.
Python:
def new(o): return o()
oc1 = new(ObjectCreator) #=><__main__.ObjectCreator at 0x...>, 新的實(shí)例對(duì)象
Ruby:
def new(o) o.new end
oc1 = new(ObjectCreator) #=>#, 新的實(shí)例對(duì)象
Python屬性操作
Python 中有3個(gè)全局函數(shù), 用于對(duì)象的屬性操作.
hasattr(obj, "attr_name")判斷對(duì)象是否有此屬性,
getattr(obj, "attr_name")獲取對(duì)象指定屬性,
setattr(obj, "attr_name", attr_value)則是設(shè)置指定屬性
obj.new_attr = attr_value設(shè)置屬性.
delattr(obj, "attr_name")刪除屬性.
Python中的屬性是一個(gè)寬泛的概念, 包括類變量, 實(shí)例變量, 類方法和實(shí)例方法. 這其中的區(qū)別是非常經(jīng)典的, 且在不同語(yǔ)言中有不同的名稱, 有不同的書面寫法.
類變量, 通常指依附于類本身而非類的實(shí)例的變量, 表述的是類的狀態(tài)
實(shí)例變量, 類的每個(gè)實(shí)例有獨(dú)立的變量, 來(lái)表述實(shí)例對(duì)象的狀態(tài)
類方法, 通過(guò)類名調(diào)用的方法
實(shí)例方法, 通過(guò)類的實(shí)例對(duì)象調(diào)用的方法
在Python中, 通過(guò)給self.var_name賦值創(chuàng)建實(shí)例變量, 類定義中方法外賦值的非self變量都是類變量. 定義方法時(shí), 傳遞有self參數(shù)的是實(shí)例方法, 否則為類方法.
Python:
class N2:
class_var = 3 # 類變量, 也能通過(guò)實(shí)例對(duì)象訪問(wèn)
def __init__(self, name):
self.name = name #實(shí)例變量
def hello(self, s):
return "hello " + self.name + s
def world(s):
return "world " + N2.c_var + s
n2 = N2("lzp")
n2.hello(" is good man") #=> "hello lzp is good man"
N2.hello(n2, " is good man") #=> "hello lzp is good man"
n2.world(" lzp") #=> 函數(shù)只要參數(shù), 但參數(shù)多余
N2.world(" lzp") #=> "world lzp"
Python在類的方法設(shè)計(jì)上很取巧. 就如之后所說(shuō), Python其實(shí)是沒有類方法一說(shuō)的, 全部都是函數(shù). 類的方法第一個(gè)參數(shù)是self, 像在world方法定義中, 沒有self, 方法內(nèi)是不能引用實(shí)例變量的. 且此處是不是self也無(wú)所謂, 任意標(biāo)識(shí)符都可以, 基于慣例使用self. 且在對(duì)象上調(diào)用方法, 本質(zhì)上只是將對(duì)象作為接收者, 作為第一參數(shù)傳遞給函數(shù). 若函數(shù)的第一參數(shù)不是self, 則在對(duì)象上調(diào)用方法會(huì)提示多余參數(shù).
在Python中, 函數(shù)是對(duì)象, 同其他所有對(duì)象一樣. 因此大一統(tǒng)的去理解Python的類概念就是: 類是對(duì)象, 對(duì)象有屬性, 屬性即變量名和其對(duì)應(yīng)的對(duì)象. 若對(duì)應(yīng)的對(duì)象是函數(shù)對(duì)象, 則對(duì)應(yīng)的變量是函數(shù)名, 其中第一參數(shù)為self的為類實(shí)例方法.
從屬性的角度重新定義N2, Python:
class N2: pass
N2.c_var = 3
def init(self, name): self.name = name
N2.__init__ = init
N2.hello = lambda self, s: "hello" + self.name + s
N2.world = lambda s: "world " + N2.c_var + s
這讓我想起了USB, 支持熱插拔, 即插即用, 想插就插,Python老爹真任性. 這里使用了lambda來(lái)定義匿名函數(shù).
Ruby屬性操作
Ruby沒有屬性一說(shuō), 但你也可以去寬泛地去理解. 相反的,Ruby的類變量, 實(shí)例變量, 類方法和實(shí)例方法是清晰地分開的, 畢竟是純粹地面向?qū)ο? 另一個(gè),Ruby其實(shí)沒有函數(shù)一說(shuō), 所有函數(shù)都有其所屬的類, 沒有多帶帶的函數(shù), 或者說(shuō)Ruby只有方法. 關(guān)于屬性, 另一個(gè)其他面向?qū)ο笳Z(yǔ)言中相似的概念是 _域_, 就是在類中占?jí)K地, 放變量還是函數(shù)都行.
Ruby:
class N2
@c_i_var = 1 #類的實(shí)例變量
@@c_var = 3 #類變量, 子類可繼承
def initialize(name)
@name = name
end
def hello(s)
"hello" + @name + s
end
def self.world(s) #類方法
"world " + @@c_var.to_s + s
end
end
N2.new("lzp").hello(" is good man") #=> "lzp is good man"
N2.world(" is good man") #=> "world 3 is good man"
在這里, 類的實(shí)例變量可以理解為類作為對(duì)象的實(shí)例變量. 實(shí)例變量是專屬于對(duì)象的. 而類變量則是屬于整個(gè)類體系的, 即它的所有子類都可以訪問(wèn).
回到原文, Python中的屬性對(duì)應(yīng)Ruby的多個(gè)概念. 因此對(duì)屬性的操作也是分不同的在進(jìn)行.
Ruby:
n1 = N1.new("lzp")
n1.instance_variables # 返回所有實(shí)例變量
n1.instance_variable_set("@age", 3) #=> 設(shè)置實(shí)例變量
n1.instance_variable_get("@age") #=>實(shí)例變量
n1.instance_variable_defined?("@age") #=> 判斷有無(wú)
n1.class_variables # 返回所有類變量
n1.class_variable_get/set/defined? #同上
N1.instance_methods(false) # 列出所有非繼承的實(shí)例方法
N1.singleton_methods # 列出所有非繼承的類方法
這里的singleton_methods可以理解為類方法. 但嚴(yán)格地說(shuō), 它是專屬于對(duì)象的方法. 若專屬于類, 則成為類方法. 換句話說(shuō),Ruby沒有類方法一說(shuō), 稱為單件方法.
Ruby中, 一切皆對(duì)象. 因此有必要來(lái)理解下Ruby的對(duì)象模型, 詳細(xì)地建議看 _Ruby元編程_一書.
對(duì)象由狀態(tài), 所屬類的引用和操作構(gòu)成. 狀態(tài)和操作都是專屬的, 只能由本對(duì)象進(jìn)行.運(yùn)算. 普通對(duì)象的狀態(tài)即實(shí)例變量, 操作即單件方法, 類對(duì)象的狀態(tài)即類的實(shí)例變量即類變量, 類對(duì)象的操作即類的單件方法即類方法, 其實(shí)本質(zhì)是相同的. 每個(gè)對(duì)象都存儲(chǔ)有對(duì)所屬類的引用, 以此來(lái)知曉可調(diào)用的實(shí)例方法.
所謂所屬類的引用, 很簡(jiǎn)單, 在對(duì)象上調(diào)用#class方法即可
1.class #=> Fixnum
"1".class #=> String
Fixnum.class #=> Class
String.class #=> Class
在后文會(huì)看到Python中相應(yīng)的概念type.
動(dòng)態(tài)地創(chuàng)建類
Ruby也能在函數(shù)中創(chuàng)建類.
def choose_class(name)
if (name=="foo")
Class.new {def hello "hello" end}
else
Class.new {def world "world" end}
end
end
MyClass = choose_class("foo")
MyClass.new.hello #=> "hello"
這里不能使用原文中相似的class, 會(huì)提示不能在def中定義類. 不得不提前使用大招Class.new.
之前寫到String.class為Class, 也就是說(shuō), 在Ruby中, 所有的類都是Class的對(duì)象. 注意大小寫. 自然, 創(chuàng)建新的類, 也就是創(chuàng)建Class的實(shí)例對(duì)象, 使用new操作, 同其他所有類一樣. 不過(guò)創(chuàng)建的是匿名類, 賦值給一個(gè)首字母大寫的常量名即可.
a = Class.new
a.name #=> nil
a.new.class #=> xxx
A = a
A.name #=> A
A.new.class #=> A
好了, 原文進(jìn)行到了Python的所有類的type都是type. 在本質(zhì)上, 一切類的生成都是通過(guò)調(diào)用type進(jìn)行的.
將上述Ruby代碼原樣翻譯過(guò)來(lái), 對(duì)應(yīng)的Python代碼為:
def choose_class(name):
if name=="foo":
return type("Foo", (), {"hello": lambda self:"hello"})
else:
return type("Bar", (), {"world": lambda self:"world"})
MyClass = choose_class("foo")
MyClass().hello() #=> "hello"
解釋下參數(shù), 第一個(gè)是類名字符串, 第二個(gè)基類的元組,Python支持多繼承, 可以有多個(gè)基類, 所謂的基類可以理解為超類, 父類等概念. 第三個(gè)是屬性, 由前所知, 類中的一切都是屬性. 如此即可定義一個(gè)新類.
但不同于Ruby, type的第一個(gè)參數(shù)即類名, 跟MyClass無(wú)關(guān), 即賦值不會(huì)改變類名. 但Ruby是在將類對(duì)象第一次賦值給常量時(shí)生成類名的, 之后賦值也不會(huì)改變.
在Ruby中, Class.new(superclass)來(lái)表示繼承類.Ruby中只支持單繼承, 通過(guò)模塊來(lái)添加不同的功能.
前文提到,Ruby的類有打開性質(zhì), 給類添加方法和變量是非常方便.
到底什么是元類
這里需要先普及幾個(gè)常用的操作:
Python:
a = 1
a.__class__ #=> int, 對(duì)象的類
type(1) #=> int
int.__base__ #=> object, 類的基類
int.__bases__ #=> (object,), 類的基類元組
Ruby:
1.class #=> Fixnum, 對(duì)象的類
Fixnum.superclass #=> Integer, 類的超類
Fixnum.ancestors #=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject], 類的祖先鏈
所謂祖先鏈, 即類, 類的超類, 類的超類的超類, ...一直到最初始的類, 即BasicObject. 其實(shí), 在1.9之前, 所有類都是繼承自Object, 后來(lái)又在前面加入了BasicObject, 個(gè)人猜測(cè)是為了所謂潔凈室技術(shù)吧.
原文提到, 不斷地調(diào)用.__class__屬性, 最終會(huì)到達(dá)type類型 ,Ruby中對(duì)應(yīng)的, 不斷調(diào)用.class方法, 最終會(huì)到達(dá)Class類型. 原文中可以從type繼承, 來(lái)創(chuàng)建元類. 但在Ruby中是不能創(chuàng)建Class的子類.
原文提到的__metaclass__屬性, 我思考了很久, 基本確認(rèn)Ruby中沒有相似的概念. 就舉的將屬性名大寫的例子而言, 應(yīng)該是在用class定義類時(shí), 會(huì)自動(dòng)調(diào)用這個(gè)屬性(所引用的函數(shù)對(duì)象). 初步看, 有種鉤子方法的感覺. 就是"定義類"這個(gè)事件發(fā)生時(shí), 會(huì)自動(dòng)觸發(fā)執(zhí)行__metaclass__屬性.
Ruby也有一些鉤子方法:
included表示模塊被包含時(shí)執(zhí)行,
extended表示模塊被后擴(kuò)展時(shí)執(zhí)行,
prepended表示模塊被前擴(kuò)展時(shí)執(zhí)行,
inherited表示類被繼承時(shí)執(zhí)行,
method_missing表示對(duì)象調(diào)用不存在的方法時(shí)執(zhí)行.
但目前沒找到當(dāng)定義類時(shí)被執(zhí)行的鉤子方法. 所以像原文的大寫屬性名的操作, 還真不知道如何進(jìn)行. 但事實(shí)上,Ruby的對(duì)應(yīng)屬性的標(biāo)識(shí)符有嚴(yán)格的規(guī)定, 不可能大寫首字母. 如類變量@@var, 實(shí)例變量@var, 方法名two_method.
但如果實(shí)現(xiàn)不了這個(gè), 總覺得Ruby有種被比下去的感覺, 雖然大寫所有屬性首字母的操作似乎沒有意義.
class N
def hello; "hello"; end
instance_methods(false).each {|x| alias_method x.capitalize, x; remove_method x}
end
N.new.Hello #=> "hello"
N.new.hello #=> 方法未定義
這是大寫所有實(shí)例方法名的首字母, 核心的思想是, 為原方法建立新的別名, 再刪掉原方法. 同Python一樣,Ruby的類是在執(zhí)行代碼.
class N; puts "hello"; end #=> "hello"
Ruby:
class N
def self.world; "world"; end
class << self
instance_methods(false).each {|x| alias_method x.capitalize, x; remove_method x}
end
end
N.World #=> "world"
N.world #=> 方法未定義
這是大寫所有的類方法名的首字母.
class N
@name = "lzp"
instance_variables.each {|x| instance_variable_set("@"+x.to_s[/w+/].capitalize, @name); @name = nil}
end
N.class_eval {@Name} #=> "lzp"
N.class_eval {@name} #=> nil
這是大寫所有的類的實(shí)例變量.
由于Ruby的實(shí)例變量默認(rèn)是不能從外部訪問(wèn)的, 不得不使用.class_eval來(lái)打開類的上下文.
不存在如何大寫所有實(shí)例變量的代碼, 因此在類實(shí)例化前, 實(shí)例對(duì)象的實(shí)例變量是不存在的.
好吧, 我承認(rèn), 這實(shí)現(xiàn)的很別扭. 在同一操作的表述上, 不同語(yǔ)言有不同的書面寫法, 也自然有簡(jiǎn)單有繁雜.
函數(shù)式特性
談點(diǎn)別的, 有關(guān)函數(shù)式特性, 使用map/filter/reduce.
Python:
a = ["he", "hk", "ok"]
list(map(lambda x: x*2, a)) #=>["hehe", "hkhk", "okok"]
list(filter(lambda x: x.startswith("h"), a)) #=> ["he", "hk"]
import functiontools.reduce
reduce(lambda x,y: x+":"+y, a) #=> "he:hk:ok"
用上述函數(shù)來(lái)替換原文中的語(yǔ)句:
dict(map(lambda i: (i[0].upper(), i[1]), filter(lambda i: not i[0].startswith("__"), future_class_attr.items())))
好吧, 我承認(rèn)我的Python技術(shù)真不高, 如果真寫成一行, 完全看不懂了, 原文作者那樣寫更清晰簡(jiǎn)潔易懂, 當(dāng)然更主要的是, 用map/filter會(huì)引入新的難點(diǎn), 容易偏離主題.
希望有高手能告訴我, 將一個(gè)類的所有非"__"的屬性的鍵變?yōu)榇髮懭绾我愿瘮?shù)式的方式表達(dá)出來(lái).
Ruby:
a = ["he", "hk", "ok"]
a.map {|x| x*2} #=> ["hehe", "hkhk", "okok"]
a.select {|x| x.start_with? "h"} #=> ["he", "hk"]
a.reject {|x| x.start_with? "h"} #=> ["ok"]
a.reduce {|sum, x| sum + ":" + x} #=> "he:hk:ok"
同樣的, 用上述來(lái)替換原文的代碼.
future_class_attr.reject {|k,v| k.start_with? "__"}.map {|k,v| k.upcase}
Python3.x刪除了reduce函數(shù), 推薦使用for循環(huán), 也可以使用funtools.reduce. 這跟Ruby完全不同,Ruby提倡使用each, map等迭代, 而for在底層也是在調(diào)用each.
一切皆對(duì)象.
Python和Ruby都號(hào)稱一切皆對(duì)象, 但很明顯兩個(gè)的對(duì)象概念并不完全對(duì)等.
Py: 1.__class__ #=> 語(yǔ)法錯(cuò)誤
Py: a = 1; a.__class__ #=> int
Rb: 1.class #=> Fixnum
Py: 1.real #=> 語(yǔ)法錯(cuò)誤
Py: b = 1; b.real #=> 1
Rb: 1.real #=> 1
Py: "lzp".upper() #=>"LZP", 但在ipython中不補(bǔ)全方法
Py: s = "lzp"; s.upper() #補(bǔ)全
Rb: "lzp".upcase #=> "LZP", 補(bǔ)全
以上說(shuō)明, 對(duì)對(duì)象和對(duì)象的引用調(diào)用方法是有區(qū)別的, 具體什么原理以及詳細(xì)的區(qū)別, 我說(shuō)明不了.
def hello(name): return "hello" + name
hello.__class__ #=> function
Ruby的方法不是對(duì)象, 不能賦值, 不能為參傳遞.
def hello(name); "hello" + name; end
hello.class #=> 參數(shù)錯(cuò)誤
new_hello = hello #=> 參數(shù)錯(cuò)誤
def echo(o); o(); end
echo(hello) #=> 參數(shù)錯(cuò)誤
你是不是覺得問(wèn)題挺大的, 這幾種對(duì)象的特征竟然都不滿足. 但這些其實(shí)是一個(gè)錯(cuò)誤, 前文有提到, 對(duì)于Ruby的方法調(diào)用, 在不引起歧義的情況下, ()是可以省略. 在這里, 所有出現(xiàn)hello的位置都默認(rèn)你在調(diào)用方法, 但方法定義有參數(shù), 你不傳遞參數(shù), 所以錯(cuò)誤是同一個(gè), 少參數(shù).
函數(shù)作為對(duì)象最終用處都是被調(diào)用, 因此, 只從表面來(lái)看, Ruby中通過(guò)def定義的方法不是對(duì)象. 但本質(zhì)上, 在Ruby中, 出現(xiàn)方法名的地方全被視為對(duì)方法的調(diào)用, 也就是說(shuō), hello是方法調(diào)用, 而不是方法引用, 并不表征方法本身. 那么如何獲取方法本身的對(duì)象呢?
new_hello = method :hello
new_hello.call("lzp") #=> "hellolzp"
new_hello.("lzp") #=> "hellolzp"
new_hello["lzp"] #=> "hellolzp"
new_hello.class #=> Method
new_2_hello = new_hello
注意, 在這里可以看出, 在絕大部分語(yǔ)言中, ()都是函數(shù)調(diào)用的標(biāo)志. 但在Ruby中, ()只是在有歧義情況下, 區(qū)分哪個(gè)參數(shù)是哪個(gè)函數(shù)的. 因此, 當(dāng)函數(shù)作為對(duì)象時(shí), 不得不創(chuàng)建新的表示調(diào)用的標(biāo)志, 在這里是.call, [], .().
函數(shù)并不是唯一的可調(diào)用對(duì)象.
hello = lambda {|name| "hello" + name}
hello = ->(name) {"hello" + name}
hello = proc {|name| "hello" + name}
hello = Proc.new {|name| "hello" + name}
后記
事實(shí)上, Class.new 屬于 Ruby 元編程的一部分, 但 Ruby 的元編程就像普通編程一樣, 沒有任何神秘復(fù)雜的語(yǔ)法. 這里真的只是冰山一角.
