pythoncallback函數

Ⅰ python回調函數的使用方法

python回調函數的使用方法
在計算機程序設計中，回調函數，或簡稱回調（Callback），是指通過函數參數傳遞到其它代碼的，某一塊可執行代碼的引用。這一設計允許了底層代碼調用在高層定義的子程序
有兩種類型的回調函數：

那麼，在python中如何實現回調函數呢，看代碼：
代碼如下:

def my_callback(input):
print "function my_callback was called with %s input" % (input,)

def caller(input, func):
func(input)

for i in range(5):
caller(i, my_callback)

Ⅱ 求這段python的注釋

片段代碼沒法注釋

比如引入的頭文件，看不到頭文件的源碼或者說明注釋之類的，完全只能靠猜測

再說這只是片段代碼 ，幾乎得不到什麼有用信息。

嘗試，注釋

#引入各種模塊
importBigWorld
fromfunctoolsimportpartial
fromgui.Scaleform.BattleimportDamagePanel
fromgui.battle_controlimportg_sessionProvider

#定義一個私有函數，一個參數bool
def__setFireInVehicle(self,bool):
#調用old_setFireInVehicle函數，並傳入一個參數bool
old_setFireInVehicle(self,bool)
#升早大概是一個類答孝的函數callback回調，傳入各種參數
BigWorld.callback(4.57692e+018,partial(g_sessionProvider.getEquipmentsCtrl().changeSettingByTag,'extinguisher',None,BigWorld.player()))
#兩個賦值語句
old_setFireInVehicle=DamagePanel._setFireInVehicle
DamagePanel._setFireInVehicle=__setFireInVehicle

#就能得到這么多

再舉個例子：

前提：我又一篇文言文，並且你對此文一無所知。

那麼問題來了：我隨便從中抽取一個片段，問你什麼意思。（你覺著你清笑稿能翻譯出來的可能性有多大）

Ⅲ python中，怎麼更新labelz中的文本

#-*-coding:utf-8-*-

'''
按照我個人的理解：
你的time.sleep調用在了mainloop之前，就是在顯示label之前delay就已經完成了，同樣config也完成了，所以直接顯示了text=2的結果。
但是即使是在label彈出顯示之後調用sleep函數（我也試過了），還有一個問題，就是sleep是阻塞式執行的，sleep完之前用戶進行不了任何操作，UI也無法更新，必須要等到sleep做完了才能發生。
所以我另外開了一個線程，用於延遲，延遲完成之後通過回調函數通知UI進行更新。
凱寬脊廢話不多了，下面是代碼，我用的時python2.7.8。
如果有說的不對的地方，請高手指點。

'''

fromTkinterimport*
importtime
importthreading

#計時線程用於延時
classMyThread(threading.Thread):
#sleeptime為需要延遲的時間
#callback為延遲結束後觸發的回調函數
def__init__(self,id,sleeptime,callback):
threading.Thread.__init__(self)
self.id=id
self.callback=callback
self.sleeptime=sleeptime
#重寫線程run函數
defrun(self):
time.sleep(self.sleeptime)
#延時完成後傳入回調函數
self.callback()
classExample(Frame):
def__init__(self,parent):
Frame.__init__(self,parent)
self.parent=parent
self.label=None
self.initUI()

#初始化窗體
definitUI(self):
self.label=Label(self,巧姿text='1')
self.label.bind('<Visibility>',self.onVis)
self.label.pack()

self.parent.title("Label")
self.pack()

#在label顯示後進行調用
defonVis(self,*args):
print"LabelVisible!"
#創建一個新的線程用於延遲，並且傳入changeText作為回調函數
t=MyThread(001,2,self.changeText)
盯滲t.start()

#在延遲完成後進行調用，與Mythread的callback綁定
defchangeText(self):
self.label.config(text='10')

window=Tk()
app=Example(window)
window.mainloop()

Ⅳ python的yield 和callback 求助

for k in ojt:
if k['url']:
print k['url']
yield Request(k['url'],callback=self.parse_item)
print len(ojt)
def parse_item(self,response):
hxs = Selector(response)
movie_name = hxs.xpath('//*[@id="content"]/h1/span[1]/text()').extract()
movie_director =hxs.xpath('//*[@id="info"]/span[1]/span[2]/a/text()').extract()
movie_writer = hxs.xpath('//*[@id="info"]/span[2]/span[2]/a/text()').extract()
在這段代碼裡面的yield執行順序我很不解，這段代碼的意思是將得到的url都輸出，但是每次輸出的時候都滾尺會將url放進yield語句的呀 為什麼沒有執行呢 就是每次輸出遲改一條url就調用下一個函數呢 就是callback函數呢 而且輸出的len（）為什麼碼備判只執行了一次呢？

兄弟，看起來像是scrapy。

yield Request(k['url'],callback=self.parse_item)

這段話的意思大概是說，請求k['url']這個url，然後給parse_item函數做處理。
具體的不說啦。你去網路yield和callback

Ⅳ 如何在Python中創建一個CFUNCTYPE-python，回調callback，ctypes

1. 我忘了ctypes的操作方法是：
下面是從復制
因此，我們的回調函數接收整型指針，並且必須返回一個整數。首先，我們創建了回調函數的類型：
CMPFUNC = CFUNCTYPE(c_int, POINTER(c_int), POINTER(c_int))

對於優先個回調函數中，我們簡單地列印出我們得到，並返回0（;-)：
def py_cmp_func(a, b):
print "py_cmp_func", a, b
return 0

創建C可調用的回調函數：
cmp_func = CMPFUNC(py_cmp_func)

Ⅵ python callback錯誤該如何解決

很多api的結果大概都是遲卜下面這個樣子，如：
eg：url地址+參數1+參數2

這個跟回調沒有碼擾穗關系啊，就是請求一個地址給你返回參數。

但是如果改成：
eg：url地址+參數1+參數2+callback函數
這樣請求成功後，再調用callback函數，才叫回調。

如李旁果解決了您的問題請採納！

Ⅶ 回調函數(callback)是什麼 ,,

回調函數就是一個被作為參數傳遞的函數。在C語言中，回調函數只能使用函數指針實現，在C++、Python、ECMAScript等更現代的編程語言中還可以使用仿函數或匿名函數。

回調函數的使用可以大大提升編程的效率，這使得它在現代編程中被非常多地使用。同時，有一些需求必須要使用回調函數來實現。

最著名的回調函數調用有C/C++標准庫stdlib.h/cstdlib中的快速排序函數qsort和二分查找函數bsearch中都會要求的一個與strcmp類似的參數，用於設置數據的比較方法。

意義

因為可以把調用者與被調用者分開，所以調用者不關心誰是被調用者。它只需知道存在一個具有特定原型和限制條件的被調用函數。簡而言之，回調函數就是允許用戶把需要調用的函數的指針作為參數傳遞給一個函數，以便該函數在處理相似事件的時候可以靈活的使用不同的方法。

Ⅷ 如何在Python使用裝飾器來注冊回調函數

之前一直知道裝飾器可以增強一個已經存在的方法,Python也提供了annotation的方法,很好用. 但是再看flask login的擴展包的時候. 發現裝飾器還可以實現回調函數的注冊搜緩功能.
flask login就是通過下面的裝飾器,來注冊回調函數,當沒有sessionID時,通過裝飾器指定的襲廳函數來讀取用戶到session中.
@login_manager.user_loader
下面寫了一個簡單的測試例子來演示這個功能.
import time
import functools
class Test():
#/**feature將調用callback(), 但是在Test中並沒有真正的定義callback**/
def feature(self):
self.callback()
def decorate(self, func):
self.callback=func
return func
test = Test()
#/**將foo注冊為回調函數*//
@test.decorate
def foo():
print 'in foo()'
#/**調用feature將觸發世禪模回調函數**/
test.feature()

Ⅸ Python回調函數用法

本文實例講述了Python回調函數用法。分享給大家供大家參考。具體分析如下：
一、網路上對回調函數的解釋：
回調函數就是一個通過函數指針調用的函數。如果你把函數的指針(地址)作為參數傳遞給另一個函數，當這個指針被用為調用它所指向的函數時，我們就說這是回調函數。回調函數不是由該函數的實現方直接調用，而是在特定的事件或條件發生時由另外的一方調用的，用於對該事件或條件進行響應。
二、什麼是回調：
軟體握亂模塊之間總是存在著一定的介面毀謹，從調用方式上，可以把他們分為三類：同步調用、回調和非同步調用。同步調用是一種阻塞式調用，調用方要等待對方執行完畢才返回，它是一種單向調用;回調是一種雙向調用模式，也就是說，被調用方在介面被調用時也會調用對方的介面;非同步調用是一種類似消息或事件的機制，不過它的調用方向剛好相反，介面的服務在收到某種訊息或發生某種事件時，會主動通知客戶方(即調用客戶方的介面)。回調和非同步調用的關系非常緊密，通常我們使用回調來實現非同步消息的注冊，通過非同步調用來實現消息的通知。同步調用是三者當中段余檔最簡單的，而回調又常常是非同步調用的基礎，因此，下面我們著重討論回調機制在不同軟體架構中的實現。
三、一個小例子：
16
17
18
19
20
21
22
#call.py
import called
def callback():
print in callback
def main():
#called.test()
called.test_call(callback)
print in call.py
main()
#called.py
def test():
print in called.py test()
def test_call(p_call):
print in called.py test_call()
p_call()
joe@joe:~/test/python$ python call.py
in called.py test_call()
in callback
in call.py
joe@joe:~/test/python$
網上搜到的一個面向對象實現的例子：
當你要加入回調(Callback)功能的時候，代碼往往會偏重於回調的實現而不是問題本身了。一個解決方法就是實現一個通用的基礎類來解決回調的需求，然後再來實現你為某個事件(Event)所綁定(Binding)的方法(Method)。
代碼如下：
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class CallbackBase:
def __init__(self):
self.__callbackMap = {}
for k in (getattr(self, x) for x in dir(self)):
if hasattr(k, bind_to_event):
self.__callbackMap.setdefault(k.bind_to_event, []).append(k)
elif hasattr(k, bind_to_event_list):
for j in k.bind_to_event_list:
self.__callbackMap.setdefault(j, []).append(k)
## staticmethod is only used to create a namespace
@staticmethod
def callback(event):
def f(g, ev = event):
g.bind_to_event = ev
return g
return f
@staticmethod
def callbacklist(eventlist):
def f(g, evl = eventlist):
g.bind_to_event_list = evl
return g
return f
def dispatch(self, event):
l = self.__callbackMap[event]
f = lambda *args, **kargs:
map(lambda x: x(*args, **kargs), l)
return f
## Sample
class MyClass(CallbackBase):
EVENT1 = 1
EVENT2 = 2
@CallbackBase.callback(EVENT1)
def handler1(self, param = None):
print handler1 with param: %s % str(param)
return None
@CallbackBase.callbacklist([EVENT1, EVENT2])
def handler2(self, param = None):
print handler2 with param: %s % str(param)
return None
def run(self, event, param = None):
self.dispatch(event)(param)
if __name__ == __main__:
a = MyClass()
a.run(MyClass.EVENT1, mandarina)
a.run(MyClass.EVENT2, naranja)
這里有一個類，它有兩個事件(EVENT1和EVENT2)和兩個處理函數(handler)。第一個處理函數handler1注冊了EVENT1，而第二個處理函數handler2當EVENT1或者EVENT2發生的時候都會執行(即注冊了全部的事件)。
運行函數(run)在MyClass的主循環中，它會將對應的事件派送(dispatch)出去。這(這里指dispatch函數)會返回一個函數，我們可以把所有需要傳給這個函數的參數列表傳給它。這個函數運行結束會返回一個列表(list)，列表中是所有的返回值。
也許，使用Metaclass能夠實現的更優雅一些吧。
希望本文所述對大家的Python程序設計有所幫助。

Ⅹ python 中callback怎麼使用

在計算機程序設計中，回調函數，或簡稱回調（Callback），是指通過函數參數傳遞到其它代碼的，某一塊可執行代碼的模團引用。這一設計允許了底層代碼調用在高層定義的子程序：

例如：

defmy_callback(input):
print"functionmy_callbackwascalledwith%sinput"%(input,)

defcaller(input,缺碼螞func):
func(input)

foriinrange(5):
caller(i,my_callback)

執行結果是：

functionmy_callbackwascalledwith0input
functionmy_callbackwascalledwith1input
functionmy_callbackwascalledwith2input
functionmy_callbackwascalledwith3input
functionmy_callbackwas伏埋calledwith4input