pythonkwds
① 有python高手嗎，有事求助
根據上節分析的處理流程，進程池的_task_handler線程，將任務從taskqueue中獲取出來，放入_inqueue中，觸發worker進程根據args和kwds調用func
運行結束後，將結果放入_outqueue，再由進程池中的_handle_results線程，將運行結果從_outqueue中取出，並找到_cache緩存中的ApplyResult對象，_set其運行結果，等待調用端獲取。
② 如何用python實現行列互換，大家怎麼看待呢
你需要確保該數組的行列數都是相同的。列表遞推式提供了一個簡便的矩陣轉置的方法:另一個更快和高級一些的方法。可以使用zip函數:本節提供了關於矩陣轉置的兩個方法，一個比較清晰簡單,另一個比較快速但有些隱晦。有時候，數據到來的時候使用錯誤的方式，比如，你使用微軟的ADO介面訪問資料庫,由於Python和MS在語言實現上的差別。Getrows方法在Python中可能返回的是列值，和方法的名稱不同.本節給的出的方法就是這個問題常見的解決方案，一個更清晰，一個更快速。在列表遞推式版本中,內層遞推式表示選則什麼(行),外層遞推式表示選擇者(列)。這個過程完成後就實現了轉置。在zip版本中,我們使用arr語法將一維數組傳遞給zip做為參數,接著,zip返回一個元組做為結果。然後我們對每一個元組使用list方法,產生了列表的列表(即矩陣)。因為我們沒有直接將zip的結果表示為list，所以我們可以我們可以使用itertools.izip來稍微的提高效率(因為izip並沒有將數據在內存中組織為列表)。但是,在特定的情況下，上面的方法對效率的微弱提升不能彌補對復雜度的增加。關於args和kwds語法:args(實際上，號後面跟著變數名)語法在Python中表示傳遞任意的位置變數，當你使用這個語法的時候(比如，你在定義函數時使用),Python將這個變數和一個元組綁定，並保留所有的位置信息,而不是具體的變數。當你使用這個方法傳遞參數時，變數可以是任意的可迭代對象(其實可以是任何錶達式,只要返回值是迭代器)。
③ 問一個python小問題
在未知參數個數時使用。
在參數名之前使用一個星號，就是讓函數接受任意多的位置參數。
如:
def story(*argv)
...
story(1,2,3,)
python在參數名之前使用2個星號來支持任意多的關鍵字參數。
story(foo='bar', spam='eggs')
④ python 多進程和多線程配合
由於python的多線程中存在PIL鎖，因此python的多線程不能利用多核，那麼，由於現在的計算機是多核的，就不能充分利用計算機的多核資源。但是python中的多進程是可以跑在不同的cpu上的。因此，嘗試了多進程+多線程的方式，來做一個任務。比如：從中科大的鏡像源中下載多個rpm包。
#!/usr/bin/pythonimport reimport commandsimport timeimport multiprocessingimport threadingdef download_image(url):
print '*****the %s rpm begin to download *******' % url
commands.getoutput('wget %s' % url)def get_rpm_url_list(url):
commands.getoutput('wget %s' % url)
rpm_info_str = open('index.html').read()
regu_mate = '(?<=<a href=")(.*?)(?=">)'
rpm_list = re.findall(regu_mate, rpm_info_str)
rpm_url_list = [url + rpm_name for rpm_name in rpm_list] print 'the count of rpm list is: ', len(rpm_url_list) return rpm_url_
def multi_thread(rpm_url_list):
threads = [] # url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
# rpm_url_list = get_rpm_url_list(url)
for index in range(len(rpm_url_list)): print 'rpm_url is:', rpm_url_list[index]
one_thread = threading.Thread(target=download_image, args=(rpm_url_list[index],))
threads.append(one_thread)
thread_num = 5 # set threading pool, you have put 4 threads in it
while 1:
count = min(thread_num, len(threads)) print '**********count*********', count ###25,25,...6707%25
res = [] for index in range(count):
x = threads.pop()
res.append(x) for thread_index in res:
thread_index.start() for j in res:
j.join() if not threads:
def multi_process(rpm_url_list):
# process num at the same time is 4
process = []
rpm_url_group_0 = []
rpm_url_group_1 = []
rpm_url_group_2 = []
rpm_url_group_3 = [] for index in range(len(rpm_url_list)): if index % 4 == 0:
rpm_url_group_0.append(rpm_url_list[index]) elif index % 4 == 1:
rpm_url_group_1.append(rpm_url_list[index]) elif index % 4 == 2:
rpm_url_group_2.append(rpm_url_list[index]) elif index % 4 == 3:
rpm_url_group_3.append(rpm_url_list[index])
rpm_url_groups = [rpm_url_group_0, rpm_url_group_1, rpm_url_group_2, rpm_url_group_3] for each_rpm_group in rpm_url_groups:
each_process = multiprocessing.Process(target = multi_thread, args = (each_rpm_group,))
process.append(each_process) for one_process in process:
one_process.start() for one_process in process:
one_process.join()# for each_url in rpm_url_list:# print '*****the %s rpm begin to download *******' %each_url## commands.getoutput('wget %s' %each_url)
def main():
url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
url_paas = 'http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/'
url_paas2 ='http://mirrors.ustc.e.cn/fedora/development/26/Server/x86_64/os/Packages/u/'
start_time = time.time()
rpm_list = get_rpm_url_list(url_paas) print multi_process(rpm_list) # print multi_thread(rpm_list)
#print multi_process()
# print multi_thread(rpm_list)
# for index in range(len(rpm_list)):
# print 'rpm_url is:', rpm_list[index]
end_time = time.time() print 'the download time is:', end_time - start_timeprint main()123456789101112131415161718
代碼的功能主要是這樣的：
main（）方法中調用get_rpm_url_list（base_url）方法，獲取要下載的每個rpm包的具體的url地址。其中base_url即中科大基礎的鏡像源的地址，比如：http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/，這個地址下有幾十個rpm包，get_rpm_url_list方法將每個rpm包的url地址拼出來並返回。
multi_process（rpm_url_list）啟動多進程方法，在該方法中，會調用多線程方法。該方法啟動4個多進程，將上面方法得到的rpm包的url地址進行分組，分成4組，然後每一個組中的rpm包再最後由不同的線程去執行。從而達到了多進程+多線程的配合使用。
代碼還有需要改進的地方，比如多進程啟動的進程個數和rpm包的url地址分組是硬編碼，這個還需要改進，畢竟，不同的機器，適合同時啟動的進程個數是不同的。
⑤ Python如何通過字元或數字動態獲取對象的名稱或者屬性
首先通過一個例子來看一下本文中可能用到的對象和相關概念。
#coding: UTF-8
import sys # 模塊，sys指向這個模塊對象
import inspect
def foo(): pass # 函數，foo指向這個函數對象
class Cat(object): # 類，Cat指向這個類對象
def __init__(self, name='kitty'):
self.name = name
def sayHi(self): # 實例方法，sayHi指向這個方法對象，使用類或實例.sayHi訪問
print self.name, 'says Hi!' # 訪問名為name的欄位，使用實例.name訪問
cat = Cat() # cat是Cat類的實例對象
print Cat.sayHi # 使用類名訪問實例方法時，方法是未綁定的(unbound)
print cat.sayHi # 使用實例訪問實例方法時，方法是綁定的(bound)
有時候我們會碰到這樣的需求，需要執行對象的某個方法，或是需要對對象的某個欄位賦值，而方法名或是欄位名在編碼代碼時並不能確定，需要通過參數傳遞字元串的形式輸入。舉個具體的例子：當我們需要實現一個通用的DBM框架時，可能需要對數據對象的欄位賦值，但我們無法預知用到這個框架的數據對象都有些什麼欄位，換言之，我們在寫框架的時候需要通過某種機制訪問未知的屬性。
這個機制被稱為反射（反過來讓對象告訴我們他是什麼），或是自省（讓對象自己告訴我們他是什麼，好吧我承認括弧里是我瞎掰的- -#），用於實現在運行時獲取未知對象的信息。反射是個很嚇唬人的名詞，聽起來高深莫測，在一般的編程語言里反射相對其他概念來說稍顯復雜，一般來說都是作為高級主題來講；但在Python中反射非常簡單，用起來幾乎感覺不到與其他的代碼有區別，使用反射獲取到的函數和方法可以像平常一樣加上括弧直接調用，獲取到類後可以直接構造實例；不過獲取到的欄位不能直接賦值，因為拿到的其實是另一個指向同一個地方的引用，賦值只能改變當前的這個引用而已。
1. 訪問對象的屬性
以下列出了幾個內建方法，可以用來檢查或是訪問對象的屬性。這些方法可以用於任意對象而不僅僅是例子中的Cat實例對象；Python中一切都是對象。
cat = Cat('kitty')
print cat.name # 訪問實例屬性
cat.sayHi() # 調用實例方法
print dir(cat) # 獲取實例的屬性名，以列表形式返回
if hasattr(cat, 'name'): # 檢查實例是否有這個屬性
setattr(cat, 'name', 'tiger') # same as: a.name = 'tiger'
print getattr(cat, 'name') # same as: print a.name
getattr(cat, 'sayHi')() # same as: cat.sayHi()
dir([obj]):
調用這個方法將返回包含obj大多數屬性名的列表（會有一些特殊的屬性不包含在內）。obj的默認值是當前的模塊對象。
hasattr(obj, attr):
這個方法用於檢查obj是否有一個名為attr的值的屬性，返回一個布爾值。
getattr(obj, attr):
調用這個方法將返回obj中名為attr值的屬性的值，例如如果attr為'bar'，則返回obj.bar。
setattr(obj, attr, val):
調用這個方法將給obj的名為attr的值的屬性賦值為val。例如如果attr為'bar'，則相當於obj.bar = val。
2. 訪問對象的元數據
當你對一個你構造的對象使用dir()時，可能會發現列表中的很多屬性並不是你定義的。這些屬性一般保存了對象的元數據，比如類的__name__屬性保存了類名。大部分這些屬性都可以修改，不過改動它們意義並不是很大；修改其中某些屬性如function.func_code還可能導致很難發現的問題，所以改改name什麼的就好了，其他的屬性不要在不了解後果的情況下修改。
接下來列出特定對象的一些特殊屬性。另外，Python的文檔中有提到部分屬性不一定會一直提供，下文中將以紅色的星號*標記，使用前你可以先打開解釋器確認一下。
2.0. 准備工作：確定對象的類型
在types模塊中定義了全部的Python內置類型，結合內置方法isinstance()就可以確定對象的具體類型了。
isinstance(object, classinfo):
檢查object是不是classinfo中列舉出的類型，返回布爾值。classinfo可以是一個具體的類型，也可以是多個類型的元組或列表。
types模塊中僅僅定義了類型，而inspect模塊中封裝了很多檢查類型的方法，比直接使用types模塊更為輕松，所以這里不給出關於types的更多介紹，如有需要可以直接查看types模塊的文檔說明。本文第3節中介紹了inspect模塊。
2.1. 模塊(mole)
__doc__: 文檔字元串。如果模塊沒有文檔，這個值是None。
*__name__: 始終是定義時的模塊名；即使你使用import .. as 為它取了別名，或是賦值給了另一個變數名。
*__dict__: 包含了模塊里可用的屬性名-屬性的字典；也就是可以使用模塊名.屬性名訪問的對象。
__file__: 包含了該模塊的文件路徑。需要注意的是內建的模塊沒有這個屬性，訪問它會拋出異常！
import fnmatch as m
print m.__doc__.splitlines()[0] # Filename matching with shell patterns.
print m.__name__ # fnmatch
print m.__file__ # /usr/lib/python2.6/fnmatch.pyc
print m.__dict__.items()[0] # ('fnmatchcase', <function fnmatchcase="" at="" 0xb73deb54="">)</function>
2.2. 類(class)
__doc__: 文檔字元串。如果類沒有文檔，這個值是None。
*__name__: 始終是定義時的類名。
*__dict__: 包含了類里可用的屬性名-屬性的字典；也就是可以使用類名.屬性名訪問的對象。
__mole__: 包含該類的定義的模塊名；需要注意，是字元串形式的模塊名而不是模塊對象。
*__bases__: 直接父類對象的元組；但不包含繼承樹更上層的其他類，比如父類的父類。
print Cat.__doc__ # None
print Cat.__name__ # Cat
print Cat.__mole__ # __main__
print Cat.__bases__ # (<type ?object?="">,)
print Cat.__dict__ # {'__mole__': '__main__', ...}</type>
2.3. 實例(instance)
實例是指類實例化以後的對象。
*__dict__: 包含了可用的屬性名-屬性字典。
*__class__: 該實例的類對象。對於類Cat，cat.__class__ == Cat 為 True。
print cat.__dict__
print cat.__class__
print cat.__class__ == Cat # True
2.4. 內建函數和方法(built-in functions and methods)
根據定義，內建的(built-in)模塊是指使用C寫的模塊，可以通過sys模塊的builtin_mole_names欄位查看都有哪些模塊是內建的。這些模塊中的函數和方法可以使用的屬性比較少，不過一般也不需要在代碼中查看它們的信息。
__doc__: 函數或方法的文檔。
__name__: 函數或方法定義時的名字。
__self__: 僅方法可用，如果是綁定的(bound)，則指向調用該方法的類（如果是類方法）或實例（如果是實例方法），否則為None。
*__mole__: 函數或方法所在的模塊名。
2.5. 函數(function)
這里特指非內建的函數。注意，在類中使用def定義的是方法，方法與函數雖然有相似的行為，但它們是不同的概念。
__doc__: 函數的文檔；另外也可以用屬性名func_doc。
__name__: 函數定義時的函數名；另外也可以用屬性名func_name。
*__mole__: 包含該函數定義的模塊名；同樣注意，是模塊名而不是模塊對象。
*__dict__: 函數的可用屬性；另外也可以用屬性名func_dict。
不要忘了函數也是對象，可以使用函數.屬性名訪問屬性（賦值時如果屬性不存在將新增一個），或使用內置函數has/get/setattr()訪問。不過，在函數中保存屬性的意義並不大。
func_defaults: 這個屬性保存了函數的參數默認值元組；因為默認值總是靠後的參數才有，所以不使用字典的形式也是可以與參數對應上的。
func_code: 這個屬性指向一個該函數對應的code對象，code對象中定義了其他的一些特殊屬性，將在下文中另外介紹。
func_globals: 這個屬性指向當前的全局命名空間而不是定義函數時的全局命名空間，用處不大，並且是只讀的。
*func_closure: 這個屬性僅當函數是一個閉包時有效，指向一個保存了所引用到的外部函數的變數cell的元組，如果該函數不是一個內部函數，則始終為None。這個屬性也是只讀的。
下面的代碼演示了func_closure：
#coding: UTF-8
def foo():
n = 1
def bar():
print n # 引用非全局的外部變數n，構造一個閉包
n = 2
return bar
closure = foo()
print closure.func_closure
# 使用dir()得知cell對象有一個cell_contents屬性可以獲得值
print closure.func_closure[0].cell_contents # 2
由這個例子可以看到，遇到未知的對象使用dir()是一個很好的主意 ：）
2.6. 方法(method)
方法雖然不是函數，但可以理解為在函數外面加了一層外殼；拿到方法里實際的函數以後，就可以使用2.5節的屬性了。
__doc__: 與函數相同。
__name__: 與函數相同。
*__mole__: 與函數相同。
im_func: 使用這個屬性可以拿到方法里實際的函數對象的引用。另外如果是2.6以上的版本，還可以使用屬性名__func__。
im_self: 如果是綁定的(bound)，則指向調用該方法的類（如果是類方法）或實例（如果是實例方法），否則為None。如果是2.6以上的版本，還可以使用屬性名__self__。
im_class: 實際調用該方法的類，或實際調用該方法的實例的類。注意不是方法的定義所在的類，如果有繼承關系的話。
im = cat.sayHi
print im.im_func
print im.im_self # cat
print im.im_class # Cat
這里討論的是一般的實例方法，另外還有兩種特殊的方法分別是類方法(classmethod)和靜態方法(staticmethod)。類方法還是方法，不過因為需要使用類名調用，所以他始終是綁定的；而靜態方法可以看成是在類的命名空間里的函數（需要使用類名調用的函數），它只能使用函數的屬性，不能使用方法的屬性。
2.7. 生成器(generator)
生成器是調用一個生成器函數(generator function)返回的對象，多用於集合對象的迭代。
__iter__: 僅僅是一個可迭代的標記。
gi_code: 生成器對應的code對象。
gi_frame: 生成器對應的frame對象。
gi_running: 生成器函數是否在執行。生成器函數在yield以後、執行yield的下一行代碼前處於frozen狀態，此時這個屬性的值為0。
next|close|send|throw: 這是幾個可調用的方法，並不包含元數據信息，如何使用可以查看生成器的相關文檔。
def gen():
for n in xrange(5):
yield n
g = gen()
print g # <generator object gen at 0x...>
print g.gi_code # <code object gen at 0x...>
print g.gi_frame # <frame object at 0x...>
print g.gi_running # 0
print g.next() # 0
print g.next() # 1
for n in g:
print n, # 2 3 4
接下來討論的是幾個不常用到的內置對象類型。這些類型在正常的編碼過程中應該很少接觸，除非你正在自己實現一個解釋器或開發環境之類。所以這里只列出一部分屬性，如果需要一份完整的屬性表或想進一步了解，可以查看文末列出的參考文檔。
2.8. 代碼塊(code)
代碼塊可以由類源代碼、函數源代碼或是一個簡單的語句代碼編譯得到。這里我們只考慮它指代一個函數時的情況；2.5節中我們曾提到可以使用函數的func_code屬性獲取到它。code的屬性全部是只讀的。
co_argcount: 普通參數的總數，不包括*參數和**參數。
co_names: 所有的參數名（包括*參數和**參數）和局部變數名的元組。
co_varnames: 所有的局部變數名的元組。
co_filename: 源代碼所在的文件名。
co_flags: 這是一個數值，每一個二進制位都包含了特定信息。較關注的是0b100(0×4)和0b1000(0×8)，如果co_flags & 0b100 != 0，說明使用了*args參數；如果co_flags & 0b1000 != 0，說明使用了**kwargs參數。另外，如果co_flags & 0b100000(0×20) != 0，則說明這是一個生成器函數(generator function)。
co = cat.sayHi.func_code
print co.co_argcount # 1
print co.co_names # ('name',)
print co.co_varnames # ('self',)
print co.co_flags & 0b100 # 0
2.9. 棧幀(frame)
棧幀表示程序運行時函數調用棧中的某一幀。函數沒有屬性可以獲取它，因為它在函數調用時才會產生，而生成器則是由函數調用返回的，所以有屬性指向棧幀。想要獲得某個函數相關的棧幀，則必須在調用這個函數且這個函數尚未返回時獲取。你可以使用sys模塊的_getframe()函數、或inspect模塊的currentframe()函數獲取當前棧幀。這里列出來的屬性全部是只讀的。
f_back: 調用棧的前一幀。
f_code: 棧幀對應的code對象。
f_locals: 用在當前棧幀時與內建函數locals()相同，但你可以先獲取其他幀然後使用這個屬性獲取那個幀的locals()。
f_globals: 用在當前棧幀時與內建函數globals()相同，但你可以先獲取其他幀……。
def add(x, y=1):
f = inspect.currentframe()
print f.f_locals # same as locals()
print f.f_back # <frame object at 0x...>
return x+y
add(2)
2.10. 追蹤(traceback)
追蹤是在出現異常時用於回溯的對象，與棧幀相反。由於異常時才會構建，而異常未捕獲時會一直向外層棧幀拋出，所以需要使用try才能見到這個對象。你可以使用sys模塊的exc_info()函數獲得它，這個函數返回一個元組，元素分別是異常類型、異常對象、追蹤。traceback的屬性全部是只讀的。
tb_next: 追蹤的下一個追蹤對象。
tb_frame: 當前追蹤對應的棧幀。
tb_lineno: 當前追蹤的行號。
def div(x, y):
try:
return x/y
except:
tb = sys.exc_info()[2] # return (exc_type, exc_value, traceback)
print tb
print tb.tb_lineno # "return x/y" 的行號
div(1, 0)
3. 使用inspect模塊
inspect模塊提供了一系列函數用於幫助使用自省。下面僅列出較常用的一些函數，想獲得全部的函數資料可以查看inspect模塊的文檔。
3.1. 檢查對象類型
is{mole|class|function|method|builtin}(obj):
檢查對象是否為模塊、類、函數、方法、內建函數或方法。
isroutine(obj):
用於檢查對象是否為函數、方法、內建函數或方法等等可調用類型。用這個方法會比多個is*()更方便，不過它的實現仍然是用了多個is*()。
im = cat.sayHi
if inspect.isroutine(im):
im()
對於實現了__call__的類實例，這個方法會返回False。如果目的是只要可以直接調用就需要是True的話，不妨使用isinstance(obj, collections.Callable)這種形式。我也不知道為什麼Callable會在collections模塊中，抱歉！我猜大概是因為collections模塊中包含了很多其他的ABC(Abstract Base Class)的緣故吧：）
3.2. 獲取對象信息
getmembers(object[, predicate]):
這個方法是dir()的擴展版，它會將dir()找到的名字對應的屬性一並返回，形如[(name, value), ...]。另外，predicate是一個方法的引用，如果指定，則應當接受value作為參數並返回一個布爾值，如果為False，相應的屬性將不會返回。使用is*作為第二個參數可以過濾出指定類型的屬性。
getmole(object):
還在為第2節中的__mole__屬性只返回字元串而遺憾嗎？這個方法一定可以滿足你，它返回object的定義所在的模塊對象。
get{file|sourcefile}(object):
獲取object的定義所在的模塊的文件名|源代碼文件名（如果沒有則返回None）。用於內建的對象（內建模塊、類、函數、方法）上時會拋出TypeError異常。
get{source|sourcelines}(object):
獲取object的定義的源代碼，以字元串|字元串列表返回。代碼無法訪問時會拋出IOError異常。只能用於mole/class/function/method/code/frame/traceack對象。
getargspec(func):
僅用於方法，獲取方法聲明的參數，返回元組，分別是(普通參數名的列表, *參數名, **參數名, 默認值元組)。如果沒有值，將是空列表和3個None。如果是2.6以上版本，將返回一個命名元組(Named Tuple)，即除了索引外還可以使用屬性名訪問元組中的元素。
def add(x, y=1, *z):
return x + y + sum(z)
print inspect.getargspec(add)
#ArgSpec(args=['x', 'y'], varargs='z', keywords=None, defaults=(1,))
getargvalues(frame):
僅用於棧幀，獲取棧幀中保存的該次函數調用的參數值，返回元組，分別是(普通參數名的列表, *參數名, **參數名, 幀的locals())。如果是2.6以上版本，將返回一個命名元組(Named Tuple)，即除了索引外還可以使用屬性名訪問元組中的元素。
def add(x, y=1, *z):
print inspect.getargvalues(inspect.currentframe())
return x + y + sum(z)
add(2)
#ArgInfo(args=['x', 'y'], varargs='z', keywords=None, locals={'y': 1, 'x': 2, 'z': ()})
getcallargs(func[, *args][, **kwds]):
返回使用args和kwds調用該方法時各參數對應的值的字典。這個方法僅在2.7版本中才有。
getmro(cls):
返回一個類型元組，查找類屬性時按照這個元組中的順序。如果是新式類，與cls.__mro__結果一樣。但舊式類沒有__mro__這個屬性，直接使用這個屬性會報異常，所以這個方法還是有它的價值的。
print inspect.getmro(Cat)
#(<class '__main__.Cat'>, <type 'object'>)
print Cat.__mro__
#(<class '__main__.Cat'>, <type 'object'>)
⑥ 求一個PyQt5的圖片瀏覽的例子
PyQt5不兼容PyQt4（盡管經驗表明，將PyQt4的應用程序移植到PyQt5難度不是很大）。本節描述了兩者之間的主要差異。
支持Python的版本
不支持較早的Python2.6之前的版本┊。
推薦使用特性
PyQt5不支持任何被標記為過時的或廢棄的QT V5.0 的API。然而，還是可能有一些逗漏網之魚地。如果將來發現了，這些錯誤將被刪除。
多個API
PyQt4支持許多不同的API版本（QString，QVariant等）。QVariant
PyQt5隻支持V2版本的API。一個例外：對於QVariant ，去除了QPyNullVariant。
老式的信號和槽
PyQt4的舊式的信號和槽不再被支持。因此以下用法在PyQt5中已經不能使用：
QObject.connect()
QObject.emit()
SIGNAL()
SLOT()
所有那些含有參數，並且對返回結果調用SIGNAL()或SLOT()的方法不再被支持。綁定信號與調用函數總是等效的。
此外，另一個差異是增加了下面的函數：
disconnect() 斷開所有對 QObject實例的連接，不需要參數。
新風格的信號和槽
QT實現的信號與一個可選的參數作為兩個獨立的信號，一個與論點 和一個沒有它。PyQt4暴露這兩允許你連接到他們每個 。然而，當發射信號，你必須使用適當的參數 發出的信號數。
PyQt5暴露唯一的信號在所有指定參數。然而它 允許任何可選參數被省略時，發射信號。
不同於PyQt4，PyQt5支持在類中自定義屬性、信號與槽，即使這個類沒有繼承自QObject（比如：混合類）。
QtDeclarative，QtScript和QtScriptTools模塊
PyQt4的QtDeclarative，QtScript和QtScriptTools模塊不再支持。這些已被替換為PyQt5的QtQml和QtQuick模塊，PyQt5支持 Python對象創建QML。
QtGui模塊
PyQt4的QtGui模塊，在PyQt5中被拆分成三個模塊：QtGui，QtPrintSupport和QtWidgets。
QtOpenGL模塊
只有QGlContext，QGlFormat和QGlWidget類被PyQt5支持。
QtWebKit模塊
PyQt4的QtWebKit模塊被分成PyQt5的QtWebKit和QtWebkitWidgets模塊。
pyqtconfig模塊
PyQt4的pyqtconfig模塊不支持。截面PyQt5擴展的API介紹了支持PyQt5 （例如提供第三方包qscintilla ），要建立在PyQt5。
dbus.mainloop.qt模塊
PyQt4的dbus.mainloop.qt模塊稱為dbus.mainloop.PyQt5在 PyQt5。這使得他們可以並排安裝。它們的功能是 相同。
QDataStream
的reaint8()，readint8()，writeuint8()和writeint8()方法解釋值 讀寫數字。PyQt4中它們被解釋為 單個字元的字元串。
QFileDialog
PyQt4的QFileDialog類的getOpenFileNameAndFilter()，getOpenFileNamesAndFilter()和getSaveFileNameAndFilter()方法，
在PyQt5中已更名為 getOpenFileName()，getOpenFileNames()和getSaveFileName()。
而PyQt4原來的getOpenFileName()，getOpenFileNames()和getSaveFileName()不再被PyQt5支持。
QGraphicsItemAnimation
對廢棄的QGraphicsItemAnimation類的支持已被刪除。如果移植現有的PyQt4應用程序，首先考慮用QPropertyAnimation替換。
QMatrix
對廢棄的QMatrix類的支持已被刪除。如果移植現有的PyQt4應用程序，首先考慮用QTransform替換。
QPyTextObject
PyQt4的QPyTextObject，是作為一個無法定義一個繼承多個Qt類的Python類的變通的解決方法。PyQt5 支持定義一個Python類，來繼承多個Qt類，只要他們已經在C++聲明為Q_DECLARE_INTERFACE 。所以，QPyTextObject沒有在PyQt5中實現。
QSet
PyQt4，套裝在Python中的V2和V3一組Python 列表實現。在PyQt5套裝總是作為一個集實現。
pyuic5
pyuic5不支持pyqt3——包裝國旗pyuic4。
pyrcc5
pyrcc5不支持- PY2和- PY3國旗pyrcc4。輸出pyrcc5兼容所有版本的Python Python 2.6 入手。
多重繼承
不像PyQt4 PyQt5類實現多重繼承，合作。在其他的話總是做 PyQt5類下面的Python代碼在等效 V3__init__方法（如kwds是一個未使用的關鍵詞 參數字典）：
super().__init__(**kwds)
這意味著，那些未使用的關鍵字的參數傳遞給__init__任何mixin類的方法。這些混合類必須合作，即 必須如果他們有自己做一個類似的電話__init__實現。
當使用多重繼承PyQt4是常見的電話__init__的超類方法明確，例如：
class MyQObject(QObject, MyMixin):
def __init__(self, parent, mixin_arg):
QObject.__init__(self, parent)
MyMixin.__init__(self, mixin_arg)
# Other initialisation...
在上述將導致PyQt5mymixin __init__。被稱為兩 。而要實現：
class MyQObject(QObject, MyMixin):
def __init__(self, **kwds):
super().__init__(**kwds)
# Other initialisation...
請注意，如果沒有其他的初始化做那麼__init__方法不需要。
混合類應實施如下：
class MyMixin:
def __init__(self, mixin_arg, **kwds):
super().__init__(**kwds)
# Other initialisation...
⑦ 用python寫了一個檢索人名的小程序，但不知道如何使程序與用wxPython寫的GUI相聯系，程序如下，望前輩指點
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import wx
class MyFrame3(wx.Frame):
def __init__(self, *args, **kwds):
# begin wxGlade: MyFrame3.__init__
kwds["style"] = wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self, *args, **kwds)
self.sizer_7_staticbox = wx.StaticBox(self, -1, _(u"顯示區"))
self.sizer_6_staticbox = wx.StaticBox(self, -1, _(u"功能區"))
self.radio_box_1 = wx.RadioBox(self, -1, _("radio_box_1"), choices=[_("choice 1"), _("choice 2"), _("choice 3")], majorDimension=0, style=wx.RA_SPECIFY_ROWS)
self.button_1 = wx.Button(self, -1, _("button_1"))
self.text_ctrl_1 = wx.TextCtrl(self, -1, "", style=wx.TE_RICH2)
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.clickButton, self.button_1)
# end wxGlade
def __set_properties(self):
# begin wxGlade: MyFrame3.__set_properties
self.SetTitle(_("frame_4"))
self.SetSize((400, 300))
self.radio_box_1.SetMinSize((210, 90))
self.radio_box_1.SetSelection(0)
self.button_1.SetMinSize((170, 90))
self.text_ctrl_1.SetMinSize((390, 99))
# end wxGlade
def __do_layout(self):
# begin wxGlade: MyFrame3.__do_layout
sizer_4 = wx.BoxSizer(wx.VERTICAL)
sizer_5 = wx.BoxSizer(wx.VERTICAL)
sizer_7 = wx.StaticBoxSizer(self.sizer_7_staticbox, wx.VERTICAL)
sizer_6 = wx.StaticBoxSizer(self.sizer_6_staticbox, wx.VERTICAL)
sizer_8 = wx.BoxSizer(wx.HORIZONTAL)
sizer_8.Add(self.radio_box_1, 0, wx.ALIGN_CENTER_VERTICAL, 0)
sizer_8.Add(self.button_1, 0, wx.ALIGN_CENTER_VERTICAL, 0)
sizer_6.Add(sizer_8, 1, wx.EXPAND, 0)
sizer_5.Add(sizer_6, 1, wx.EXPAND, 0)
sizer_7.Add(self.text_ctrl_1, 0, 0, 0)
sizer_5.Add(sizer_7, 1, wx.EXPAND, 0)
sizer_4.Add(sizer_5, 1, wx.EXPAND, 0)
self.SetSizer(sizer_4)
self.Layout()
# end wxGlade
def clickButton(self, event):
print "Event handler `clickButton' not implemented!"
event.Skip()
# end of class MyFrame3
if __name__ == "__main__":
import gettext
gettext.install("app") # replace with the appropriate catalog name
app = wx.PySimpleApp(0)
wx.InitAllImageHandlers()
frame_4 = MyFrame3(None, -1, "")
app.SetTopWindow(frame_4)
frame_4.Show()
app.MainLoop()
按照你的要求做了個界面，調用clickButton函數處理你的邏輯，然後調用textbox的setvalue方法將你的結果寫到文本框中
你覺得界面不合理的話，你可以自己調用layout和properties兩個參數是界面參數
⑧ python的return函數，為什麼會返回true和false編寫時設定的是return 'name'。這個函數是什麼意思
你好，python的return的返回結果返回true和false只是因為你讓它返回的是true和false。
什麼意思呢？
『name』in kwds代表的是「kwds里有『name』嗎？」，
答案肯定是 『是』或『否』
在python里就是『Ture』或『False』
還有一個說法：return的運算級別比較低，所以是先得出return後面的結果，再return出去。
什麼時候是Ture，什麼時候是False？
這個是如果kwds里有『name』的情況，返回的是Ture，反之是False。
至於第三個問題/應該是python新版本推出的語法，
可能spyder運行的Python版本比較低，你更新一下版本應該就好了。
至於return它其實不是列印，而是返回一個函數或方法的結果。
只是在互動式環境下它會列印，如果在文件里就沒用了。
列印實際上是print（）。
希望對你有幫助。
⑨ 求Python大神，這個代碼什麼意思，看不懂，也運行不出來
函數定義def call_foo(*args, **kwds)中，*args稱為可變位置參數，**kwds稱為關鍵字參數。args是一個元組，它負責收集所有傳遞到call_foo函數中的可變位置參數；kwds是一個字典，它負責收集所有傳遞到call_foo函數中的關鍵字參數。例如用以下形式調用call_foo()：
call_foo(1, 2, 'hello', m=None, n=[])
則call_foo函數中args元組的內容為(1, 2, 'hello')，kwds字典的內容為{'m': None, 'n': []}。
foo(*args, **kwds)則表示調用foo函數並將元組args和字典kwds的內容解包作為參數傳入。接上面的例子，相當於調用foo(1, 2, 'hello', m=None, n=[])。
⑩ python threadpool有多個參數怎麼提交
仔細的研究了一下，發現函數調用時
result = request.callable(*request.args, **request.kwds)
第一個解包list，第二個解包dict，所以可以這樣：
#----------------------------------------------------------------------
def hello(m, n, o):
""""""
print "m = %s, n = %s, o = %s"%(m, n, o)
if __name__ == '__main__':
# 方法1
lst_vars_1 = ['1', '2', '3']
lst_vars_2 = ['4', '5', '6']
func_var = [(lst_vars_1, None), (lst_vars_2, None)]
# 方法2
dict_vars_1 = {'m':'1', 'n':'2', 'o':'3'}
dict_vars_2 = {'m':'4', 'n':'5', 'o':'6'}
func_var = [(None, dict_vars_1), (None, dict_vars_2)]
pool = threadpool.ThreadPool(2)
requests = threadpool.makeRequests(hello, func_var)
[pool.putRequest(req) for req in requests]
pool.wait()