Python修饰器的函数式编程
轉(zhuǎn)載自:https://coolshell.cn/articles/11265.html
加了一些自己的注釋。
Python的修飾器的英文名叫Decorator,當你看到這個英文名的時候,你可能會把其跟Design Pattern里的Decorator搞混了,其實這是完全不同的兩個東西。雖然好像,他們要干的事都很相似——都是想要對一個已有的模塊做一些“修飾工作”,所謂修飾工作就是想給現(xiàn)有的模塊加上一些小裝飾(一些小功能,這些小功能可能好多模塊都會用到),但又不讓這個小裝飾(小功能)侵入到原有的模塊中的代碼里去。但是OO的Decorator簡直就是一場惡夢,不信你就去看看wikipedia上的詞條(Decorator Pattern)里的UML圖和那些代碼,這就是我在《?從面向?qū)ο蟮脑O計模式看軟件設計》“餐后甜點”一節(jié)中說的,OO鼓勵了——“厚重地膠合和復雜層次”,也是《?如此理解面向?qū)ο缶幊獭分兴f的“OO的狂熱者們非常害怕處理數(shù)據(jù)”,Decorator Pattern搞出來的代碼簡直就是OO的反面教程。
Python 的 Decorator在使用上和Java/C#的Annotation很相似,就是在方法名前面加一個@XXX注解來為這個方法裝飾一些東西。但是,Java/C#的Annotation也很讓人望而卻步,太TMD的復雜了,你要玩它,你需要了解一堆Annotation的類庫文檔,讓人感覺就是在學另外一門語言。
而Python使用了一種相對于Decorator Pattern和Annotation來說非常優(yōu)雅的方法,這種方法不需要你去掌握什么復雜的OO模型或是Annotation的各種類庫規(guī)定,完全就是語言層面的玩法:一種函數(shù)式編程的技巧。如果你看過本站的《函數(shù)式編程》,你一定會為函數(shù)式編程的那種“描述你想干什么,而不是描述你要怎么去實現(xiàn)”的編程方式感到暢快。(如果你不了解函數(shù)式編程,那在讀本文之前,還請你移步去看看《函數(shù)式編程》) 好了,我們先來點感性認識,看一個Python修飾器的Hello World的代碼。
Hello World
下面是代碼:
| 123456789101112 | def hello(fn):????def wrapper():????????print "hello, %s" % fn.__name__????????fn()????????print "goodby, %s" % fn.__name__????return wrapper@hellodef foo():????print "i am foo"foo() |
當你運行代碼,你會看到如下輸出:
| 1234 | [chenaho@chenhao-air]$ python hello.pyhello, fooi am foogoodby, foo |
你可以看到如下的東西:
1)函數(shù)foo前面有個@hello的“注解”,hello就是我們前面定義的函數(shù)hello
2)在hello函數(shù)中,其需要一個fn的參數(shù)(這就用來做回調(diào)的函數(shù))
3)hello函數(shù)中返回了一個inner函數(shù)wrapper,這個wrapper函數(shù)回調(diào)了傳進來的fn,并在回調(diào)前后加了兩條語句。
Decorator 的本質(zhì)
對于Python的這個@注解語法糖- Syntactic Sugar 來說,當你在用某個@decorator來修飾某個函數(shù)func時,如下所示:
| 123 | @decoratordef func():????pass |
其解釋器會解釋成下面這樣的語句:
| 1 | func = decorator(func) |
尼瑪,這不就是把一個函數(shù)當參數(shù)傳到另一個函數(shù)中,然后再回調(diào)嗎?是的,但是,我們需要注意,那里還有一個賦值語句,把decorator這個函數(shù)的返回值賦值回了原來的func。 根據(jù)《函數(shù)式編程》中的first class functions中的定義的,你可以把函數(shù)當成變量來使用,所以,decorator必需得返回了一個函數(shù)出來給func,這就是所謂的higher order function?高階函數(shù),不然,后面當func()調(diào)用的時候就會出錯。 就我們上面那個hello.py里的例子來說,
| 123 | @hellodef foo():????print "i am foo" |
被解釋成了:
| 1 | foo = hello(foo) |
是的,這是一條語句,而且還被執(zhí)行了。你如果不信的話,你可以寫這樣的程序來試試看:
| 123456 | def fuck(fn):????print "fuck %s!" % fn.__name__[::-1].upper()@fuckdef wfg():????pass |
沒了,就上面這段代碼,沒有調(diào)用wfg()的語句,你會發(fā)現(xiàn), fuck函數(shù)被調(diào)用了,而且還很NB地輸出了我們每個人的心聲!
再回到我們hello.py的那個例子,我們可以看到,hello(foo)返回了wrapper()函數(shù),所以,foo其實變成了wrapper的一個變量,而后面的foo()執(zhí)行其實變成了wrapper()。
知道這點本質(zhì),當你看到有多個decorator或是帶參數(shù)的decorator,你也就不會害怕了。
比如:多個decorator
| 1234 | @decorator_one@decorator_twodef func():????pass |
相當于:
| 1 | func = decorator_one(decorator_two(func)) |
比如:帶參數(shù)的decorator:
| 123 | @decorator(arg1, arg2)def func():????pass |
相當于:
| 1 | func = decorator(arg1,arg2)(func) |
這意味著decorator(arg1, arg2)這個函數(shù)需要返回一個“真正的decorator”。
帶參數(shù)及多個Decrorator
我們來看一個有點意義的例子:
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8')def makeHtmlTag(tag, *args, **kwds):print"執(zhí)行makeHtmlTag"print"makeHtmlTag_args=",argsprint"makeHtmlTag_kwds=",kwdsdef real_decorator(fn):print"real_decorator_args=",argsprint"real_decorator_kwds=",kwdsprint"執(zhí)行real_decorator"css_class = " class='{0}'".format(kwds["css_class"]) if "css_class" in kwds else ""def wrapped(*args, **kwds):#這里的*args和**kwds和上面的*args和**kwds是兩碼事print"wrapped_args=",argsprint"wrapped_kwds=",kwdsreturn "<"+tag+css_class+">\n" + fn(*args, **kwds) + "</"+tag+">"return wrappedreturn real_decorator #這兩個makeHtmlTag,先執(zhí)行第一個,再執(zhí)行下面一個 @makeHtmlTag(tag="b", css_class="bold_css")#css_class傳遞給kwds,因為**是接受字典數(shù)據(jù)的 @makeHtmlTag(tag="i", css_class="italic_css") def hello(a,b):#這里的參數(shù)傳遞給wrapped(*args, **kwds)print"a+b=",a+breturn "hello world:"+str(a+b)print"-----------------------------" print hello(3,4) #假定:這里被裝飾的函數(shù)是fn #①那么在裝飾的時候(也就是@),“fn所在的最外面一層函數(shù)”以及“fn所在的最外面一層函數(shù)的外面”都會被先執(zhí)行。 #②在最終運行被裝飾的函數(shù)的時候,會繼續(xù)運行fn所在最外面一層函數(shù)的里面的函數(shù)。#代碼來源:https://coolshell.cn/articles/11265.html ------------“帶參數(shù)及多個Decrorator”部分在上面這個例子中,我們可以看到:makeHtmlTag有兩個參數(shù)。所以,為了讓?hello = makeHtmlTag(arg1, arg2)(hello)?成功,makeHtmlTag 必需返回一個decorator(這就是為什么我們在makeHtmlTag中加入了real_decorator()的原因),這樣一來,我們就可以進入到 decorator 的邏輯中去了—— decorator得返回一個wrapper,wrapper里回調(diào)hello。看似那個makeHtmlTag() 寫得層層疊疊,但是,已經(jīng)了解了本質(zhì)的我們覺得寫得很自然。
你看,Python的Decorator就是這么簡單,沒有什么復雜的東西,你也不需要了解過多的東西,使用起來就是那么自然、體貼、干爽、透氣,獨有的速效凹道和完美的吸收軌跡,讓你再也不用為每個月的那幾天感到焦慮和不安,再加上貼心的護翼設計,量多也不用當心。對不起,我調(diào)皮了。
什么,你覺得上面那個帶參數(shù)的Decorator的函數(shù)嵌套太多了,你受不了。好吧,沒事,我們看看下面的方法。
class式的 Decorator
首先,先得說一下,decorator的class方式,還是看個示例:
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8') class myDecorator(object):def __init__(self, fn):print "inside myDecorator.__init__()"self.fn = fndef __call__(self):self.fn()print "inside myDecorator.__call__()"@myDecorator#裝飾的時候執(zhí)行構(gòu)造函數(shù)__init__(self, fn) def aFunction():print "inside aFunction()"print"-"*100 aFunction()#總結(jié),對于這種被class修飾的函數(shù) # ①修飾的時候,先執(zhí)行__init__() # ②運行被修飾函數(shù)aFunction的時候,先運行aFunction里面的內(nèi)容,再運行裝飾器類中其他的成員函數(shù) #https://coolshell.cn/articles/11265.html -----class式的 Decorator-第一種上面這個示例展示了,用類的方式聲明一個decorator。我們可以看到這個類中有兩個成員:
1)一個是__init__(),這個方法是在我們給某個函數(shù)decorator時被調(diào)用,所以,需要有一個fn的參數(shù),也就是被decorator的函數(shù)。
2)一個是__call__(),這個方法是在我們調(diào)用被decorator函數(shù)時被調(diào)用的。
上面輸出可以看到整個程序的執(zhí)行順序。
這看上去要比“函數(shù)式”的方式更易讀一些。
下面,我們來看看用類的方式來重寫上面的html.py的代碼:
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding("utf-8") class makeHtmlTagClass(object):def __init__(self, tag, css_class=""):self._tag = tagself._css_class = " class='{0}'".format(css_class) if css_class !="" else ""def __call__(self, fn):def wrapped(*args, **kwargs):return "<" + self._tag + self._css_class+">\n" + fn(*args, **kwargs) + "</" + self._tag + ">"return wrapped@makeHtmlTagClass(tag="b", css_class="bold_css") @makeHtmlTagClass(tag="i", css_class="italic_css") def hello(name):return "Hello, {}".format(name)print"----------------------------" print hello("Hao Chen") #https://coolshell.cn/articles/11265.html -----------class式的 Decorator上面這段代碼中,我們需要注意這幾點:
1)如果decorator有參數(shù)的話,__init__() 成員就不能傳入fn了,而fn是在__call__的時候傳入的。
2)這段代碼還展示了 wrapped(*args, **kwargs) 這種方式來傳遞被decorator函數(shù)的參數(shù)。(其中:args是一個參數(shù)列表,kwargs是參數(shù)dict,具體的細節(jié),請參考Python的文檔或是StackOverflow的這個問題,這里就不展開了)
用Decorator設置函數(shù)的調(diào)用參數(shù)
你有三種方法可以干這個事:
第一種,通過 **kwargs,這種方法decorator會在kwargs中注入?yún)?shù)。
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8') def decorate_A(function):print"decorate_A"def wrap_function(*args, **kwargs):print"wrap_function"# kwargs['str'] = 'Hello!'return function(*args, **kwargs)return wrap_function@decorate_A def print_message_A(*args, **kwargs):print"args=",argsprint(kwargs['str'])print"-"*100 print_message_A(98,str='appleyuchi') #代碼來自:https://coolshell.cn/articles/11265.html --------------用Decorator設置函數(shù)的調(diào)用參數(shù):第一種第二種,約定好參數(shù),直接修改參數(shù)
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8') def decorate_B(function):print"decotrate_B"#到這里為止粘貼到①處def wrap_function(strs,*args, **kwargs):#以下代碼粘貼到②處# strs = 'Hello!'return function(strs, *args, **kwargs)print"decorate_B end"return wrap_function@decorate_B#① def print_message_B(strs, *args, **kwargs):#在這里接收函數(shù)以后,會粘貼到②處print(strs)#②print"-"*100 print_message_B('yuchi') #https://coolshell.cn/articles/11265.html ------------用Decorator設置函數(shù)的調(diào)用參數(shù) 第二部分 #這里來詳細解釋下,所謂的裝飾器函數(shù)就是被拆為連部分, # 一部分粘貼到被裝飾函數(shù)print_message_B的上面, # 一部分粘貼到被裝飾函數(shù)print_message_B的下面第三種,通過 *args 注入
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8')def decorate_C(function):#這個裝飾器函數(shù)print"decorate_C"#這里為止是最先執(zhí)行的#---------------下面部分是滯后執(zhí)行的--------------------------def wrap_function(strs,*args, **kwargs):strs2 = '進入wrap_function'print "strs2(裝飾器定義中)=",strs2#args.insert(1, strs)args = args +(strs,)return function(strs,*args, **kwargs)#-----------------上面部分是滯后執(zhí)行的------------------------print"decorate_C end"#這里往下面也是最先執(zhí)行的。也就是說,先執(zhí)行裝飾器的殼,然后執(zhí)行被裝飾的函數(shù)本身return wrap_functionclass Printer:def __init__(self,strs):self.strs2=strs@decorate_Cdef print_message(self, *args, **kwargs):#這里的strs可以由成員函數(shù)的地方來獲取print"***********************************"print"strs2=",self.strs2print"---------1-----------------" #下方代碼不會有輸出 strs='appleyuchi' p = Printer(strs) #上方代碼不會有輸出 print"---------2-----------------"p.print_message() # 裝飾器在定義的時候就會執(zhí)行外層函數(shù),在裝飾器被使用的時候,從內(nèi)層函數(shù)開始執(zhí)行,然后再執(zhí)行被裝飾的函數(shù)Decorator的副作用
到這里,我相信你應該了解了整個Python的decorator的原理了。
相信你也會發(fā)現(xiàn),被decorator的函數(shù)其實已經(jīng)是另外一個函數(shù)了,對于最前面那個hello.py的例子來說,如果你查詢一下foo.__name__的話,你會發(fā)現(xiàn)其輸出的是“wrapper”,而不是我們期望的“foo”,這會給我們的程序埋一些坑。所以,Python的functool包中提供了一個叫wrap的decorator來消除這樣的副作用。下面是我們新版本的hello.py。
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8') from functools import wraps def hello(fn):@wraps(fn)def wrapper():print "hello, %s" % fn.__name__fn()print "goodby, %s" % fn.__name__return wrapper@hello def foo():'''foo help doc'''print "i am foo"passfoo() print foo.__name__ #輸出 foo print foo.__doc__ #輸出 foo help doc當然,即使是你用了functools的wraps,也不能完全消除這樣的副作用。
來看下面這個示例:
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8') import inspect from inspect import getmembers, getargspec from functools import wrapsdef wraps_decorator(f):@wraps(f)def wraps_wrapper(*args, **kwargs):return f(*args, **kwargs)return wraps_wrapperclass SomeClass(object):@wraps_decoratordef method(self, x, y):passobj = SomeClass() for name, func in getmembers(obj, predicate=inspect.ismethod):print "Member Name: %s" % nameprint "Func Name: %s" % func.func_nameprint "Args: %s" % getargspec(func)[0]# 輸出: # Member Name: method # Func Name: method # Args: []你會發(fā)現(xiàn),即使是你你用了functools的wraps,你在用getargspec時,參數(shù)也不見了。
要修正這一問,我們還得用Python的反射來解決,下面是相關(guān)的代碼:
| def get_true_argspec(method):????argspec = inspect.getargspec(method)????args = argspec[0]????if args and args[0] == 'self':????????return argspec????if hasattr(method, '__func__'):????????method = method.__func__????if not hasattr(method, 'func_closure') or method.func_closure is None:????????raise Exception("No closure for method.")????method = method.func_closure[0].cell_contents????return get_true_argspec(method) |
當然,我相信大多數(shù)人的程序都不會去getargspec。所以,用functools的wraps應該夠用了。
一些decorator的示例
好了,現(xiàn)在我們來看一下各種decorator的例子:
給函數(shù)調(diào)用做緩存
這個例實在是太經(jīng)典了,整個網(wǎng)上都用這個例子做decorator的經(jīng)典范例,因為太經(jīng)典了,所以,我這篇文章也不能免俗。
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8') from functools import wraps def memo(fn):cache = {}miss = object()@wraps(fn)def wrapper(*args):result = cache.get(args, miss)if result is miss:result = fn(*args)cache[args] = resultreturn resultreturn wrapper@memo#注意觀察運行時間,這句話如果注釋掉的話,就會需要0.8s的時間 def fib(n):if n < 2:return nreturn fib(n - 1) + fib(n - 2) if __name__ == '__main__':print fib(30)上面這個例子中,是一個斐波拉契數(shù)例的遞歸算法。我們知道,這個遞歸是相當沒有效率的,因為會重復調(diào)用。比如:我們要計算fib(5),于是其分解成fib(4) + fib(3),而fib(4)分解成fib(3)+fib(2),fib(3)又分解成fib(2)+fib(1)…… 你可看到,基本上來說,fib(3), fib(2), fib(1)在整個遞歸過程中被調(diào)用了兩次。
而我們用decorator,在調(diào)用函數(shù)前查詢一下緩存,如果沒有才調(diào)用了,有了就從緩存中返回值。一下子,這個遞歸從二叉樹式的遞歸成了線性的遞歸。
Profiler的例子
這個例子沒什么高深的,就是實用一些。
#-*- encoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8') import cProfile, pstats, StringIOdef profiler(func):def wrapper(*args, **kwargs):datafn = func.__name__ + ".profile" # Name the data fileprof = cProfile.Profile()retval = prof.runcall(func, *args, **kwargs)#prof.dump_stats(datafn)s = StringIO.StringIO()sortby = 'cumulative'ps = pstats.Stats(prof, stream=s).sort_stats(sortby)ps.print_stats()print s.getvalue()return retvalreturn wrapper@profiler def prints():print "hello,world" if __name__ == '__main__':prints()#可以看出,這個profiler函數(shù)就是用來分析被裝飾的函數(shù)的性能的。注冊回調(diào)函數(shù)
下面這個示例展示了通過URL的路由來調(diào)用相關(guān)注冊的函數(shù)示例:
| 12345678910111213141516171819202122232425262728 | class MyApp():????def __init__(self):????????self.func_map = {}????def register(self, name):????????def func_wrapper(func):????????????self.func_map[name] = func????????????return func????????return func_wrapper????def call_method(self, name=None):????????func = self.func_map.get(name, None)????????if func is None:????????????raise Exception("No function registered against - " + str(name))????????return func()app = MyApp()@app.register('/')def main_page_func():????return "This is the main page."@app.register('/next_page')def next_page_func():????return "This is the next page."print app.call_method('/')print app.call_method('/next_page') |
注意:
1)上面這個示例中,用類的實例來做decorator。
2)decorator類中沒有__call__(),但是wrapper返回了原函數(shù)。所以,原函數(shù)沒有發(fā)生任何變化。
給函數(shù)打日志
下面這個示例演示了一個logger的decorator,這個decorator輸出了函數(shù)名,參數(shù),返回值,和運行時間。
from functools import wraps import inspect import timedef advance_logger(loglevel):def get_line_number():return inspect.currentframe().f_back.f_back.f_linenodef _basic_log(fn, result, *args, **kwargs):print "function = " + fn.__name__,print "arguments = {0} {1}".format(args, kwargs)print "return = {0}".format(result)def info_log_decorator(fn):@wraps(fn)def wrapper(*args, **kwargs):result = fn(*args, **kwargs)_basic_log(fn, result, args, kwargs)return wrapperdef debug_log_decorator(fn):@wraps(fn)def wrapper(*args, **kwargs):ts = time.time()result = fn(*args, **kwargs)te = time.time()_basic_log(fn, result, args, kwargs)print " time = %.6f sec" % (te-ts)print " called_from_line : " + str(get_line_number())return wrapperif loglevel is "debug":return debug_log_decoratorelse:return info_log_decorator @advance_logger("debug") def multipy(x,y):return x * y@advance_logger("debug") def sum_num(n):s = 0for i in xrange(n+1):s += ireturn sprint multipy(2,10) print sum_num(100) print sum_num(10000000)你可以看到兩點,
1)我們分了兩個log level,一個是info的,一個是debug的,然后我們在外尾根據(jù)不同的參數(shù)返回不同的decorator。
2)我們把info和debug中的相同的代碼抽到了一個叫_basic_log的函數(shù)里,DRY原則。
一個MySQL的Decorator
下面這個decorator是我在工作中用到的代碼,我簡化了一下,把DB連接池的代碼去掉了,這樣能簡單點,方便閱讀。
| 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758 | import umysqlfrom functools import wrapsclass Configuraion:????def __init__(self, env):????????if env == "Prod":????????????self.host??? = "coolshell.cn"????????????self.port??? = 3306????????????self.db????? = "coolshell"????????????self.user??? = "coolshell"????????????self.passwd? = "fuckgfw"????????elif env == "Test":????????????self.host?? = 'localhost'????????????self.port?? = 3300????????????self.user?? = 'coolshell'????????????self.db???? = 'coolshell'????????????self.passwd = 'fuckgfw'def mysql(sql):????_conf = Configuraion(env="Prod")????def on_sql_error(err):????????print err????????sys.exit(-1)????def handle_sql_result(rs):????????if rs.rows > 0:????????????fieldnames = [f[0] for f in rs.fields]????????????return [dict(zip(fieldnames, r)) for r in rs.rows]????????else:????????????return []????def decorator(fn):????????@wraps(fn)????????def wrapper(*args, **kwargs):????????????mysqlconn = umysql.Connection()????????????mysqlconn.settimeout(5)????????????mysqlconn.connect(_conf.host, _conf.port, _conf.user, \??????????????????????????????_conf.passwd, _conf.db, True, 'utf8')????????????try:????????????????rs = mysqlconn.query(sql, {})????????????except umysql.Error as e:????????????????on_sql_error(e)????????????data = handle_sql_result(rs)????????????kwargs["data"] = data????????????result = fn(*args, **kwargs)????????????mysqlconn.close()????????????return result????????return wrapper????return decorator@mysql(sql = "select * from coolshell" )def get_coolshell(data):????... ...????... .. |
線程異步
下面量個非常簡單的異步執(zhí)行的decorator,注意,異步處理并不簡單,下面只是一個示例。
from threading import Thread from functools import wrapsdef async(func):@wraps(func)def async_func(*args, **kwargs):func_hl = Thread(target = func, args = args, kwargs = kwargs)func_hl.start()return func_hlreturn async_func from time import sleep@async def print_somedata():print 'starting print_somedata'sleep(2)print 'print_somedata: 2 sec passed'sleep(2)print 'print_somedata: 2 sec passed'sleep(2)print 'finished print_somedata'def main():#這里的異步的意思就是第一個函數(shù)啟動以后,就啟動第二個函數(shù),而不用等待第一個函數(shù)完全執(zhí)行結(jié)束print_somedata()print 'first function'print"---------------------------------"print_somedata()print 'second function'if __name__ == '__main__':main()觀察Wraps的作用:
#-*- enncoding:utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8') from functools import wraps def tracer(func):@wraps(func)#這一句話如果被注銷的話,那么裝飾器就會破壞被裝飾的函數(shù)fibonaccidef wrapper(*args, **kwargs):result = func(*args, **kwargs)print('%s(%r,%r)->%r'%(func.__name__,args,kwargs,result))return resultreturn wrapper@tracer def fibonacci(n):if n in (0,1):return nreturn (fibonacci(n-1)+fibonacci(n-2))fibonacci(3) print(fibonacci) print('help:') help(fibonacci) #這個代碼主要是為了體現(xiàn)裝飾器不會破壞原來的函數(shù) #wraps的意思就是被裝飾的函數(shù)具備的屬性,不要去破壞 #代碼來源:https://www.cnblogs.com/935415150wang/p/7729213.html其它
關(guān)于更多的示例,你可以參看:?Python Decorator Library
關(guān)于Python Decroator的各種提案,可以參看:Python Decorator Proposals
總結(jié)
以上是生活随笔為你收集整理的Python修饰器的函数式编程的全部內(nèi)容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: python调用stanfordNLP的
- 下一篇: 《概率论与数理统计习题全解指南》中的“计