本文目錄一覽：
Python中定義函數默認參數值的使用注意事項？
4.7.1. 默認參數值
最常用的一種形式是為一個或多個參數指定默認值。這會創建一個可以使用比定義是允許的參數更少的參數調用的函數，例如:
def ask_ok(prompt, retries=4, complaint=’Yes or no, please!’):
while True:
ok = input(prompt)
if ok in (‘y’, ‘ye’, ‘yes’):
return True
if ok in (‘n’, ‘no’, ‘nop’, ‘nope’):
return False
retries = retries – 1
if retries 0:
raise OSError(‘uncooperative user’)
print(complaint)
這個函數可以通過幾種不同的方式調用:
只給出必要的參數:
ask_ok(‘Do you really want to quit?’)
給出一個可選的參數:
ask_ok(‘OK to overwrite the file?’, 2)
或者給出所有的參數:
ask_ok(‘OK to overwrite the file?’, 2, ‘Come on, only yes or no!’)
這個例子還介紹了 in 關鍵字。它測定序列中是否包含某個確定的值。
默認值在函數 定義 作用域被解析，如下所示:
i = 5
def f(arg=i):
print(arg)
i = 6
f()
將會輸出 5。
重要警告: 默認值只被賦值一次。這使得當默認值是可變對象時會有所不同，比如列表、字典或者大多數類的實例。例如，下面的函數在後續調用過程中會累積（前面）傳給它的參數:
def f(a, L=[]):
L.append(a)
return L
print(f(1))
print(f(2))
print(f(3))
這將輸出:
[1]
[1, 2]
[1, 2, 3]
如果你不想讓默認值在後續調用中累積，你可以像下面一樣定義函數:
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
python出錯，請問是什麼問題
要把代碼發現來才知道，以下是常見的錯誤
下面終於要講到當你用到更多的Python的功能（數據類型，函數，模塊，類等等）時可能碰到的問題了。由於篇幅有限，這裡盡量精簡，尤其是對一些高級的概念。要想了解更多的細節，敬請閱讀Learning Python, 2nd Edition的「小貼士」以及「Gotchas」章節。
打開文件的調用不使用模塊搜索路徑
當你在Python中調用open()來訪問一個外部的文件時，Python不會使用模塊搜索路徑來定位這個目標文件。它會使用你提供的絕對路徑，或者假定這個文件是在當前工作目錄中。模塊搜索路徑僅僅為模塊載入服務的。
不同的類型對應的方法也不同
列表的方法是不能用在字元串上的，反之亦然。通常情況下，方法的調用是和數據類型有關的，但是內部函數通常在很多類型上都可以使用。舉個例子來說，列表的reverse方法僅僅對列表有用，但是len函數對任何具有長度的對象都適用
不能直接改變不可變數據類型
記住你沒法直接的改變一個不可變的對象（例如，元組，字元串）：
T = (1, 2, 3)
T[2] = 4 # 錯誤
用切片，聯接等構建一個新的對象，並根據需求將原來變數的值賦給它。因為Python會自動回收沒有用的內存，因此這沒有看起來那麼浪費：
T = T[:2] + (4,) # 沒問題了: T 變成了 (1, 2, 4)
使用簡單的for循環而不是while或者range
當你要從左到右遍歷一個有序的對象的所有元素時，用簡單的for循環（例如，for x in seq:）相比於基於while-或者range-的計數循環而言會更容易寫，通常運行起來也更快。除非你一定需要，盡量避免在一個for循環里使用range：讓Python來替你解決標號的問題。在下面的例子中三個循環結構都沒有問題，但是第一個通常來說更好；在Python里，簡單至上。
S = “lumberjack”
for c in S: print c # 最簡單
for i in range(len(S)): print S[i] # 太多了
i = 0 # 太多了
while i len(S): print S[i]; i += 1
不要試圖從那些會改變對象的函數得到結果
諸如像方法list.append()和list.sort()一類的直接改變操作會改變一個對象，但不會將它們改變的對象返回出來（它們會返回None）；正確的做法是直接調用它們而不要將結果賦值。經常會看見初學者會寫諸如此類的代碼：
mylist = mylist.append(X)
目的是要得到append的結果，但是事實上這樣做會將None賦值給mylist，而不是改變後的列表。更加特別的一個例子是想通過用排序後的鍵值來遍歷一個字典里的各個元素，請看下面的例子：
D = {…}
for k in D.keys().sort(): print D[k]
差一點兒就成功了——keys方法會創建一個keys的列表，然後用sort方法來將這個列表排序——但是因為sort方法會返回None，這個循環會失敗，因為它實際上是要遍歷None（這可不是一個序列）。要改正這段代碼，將方法的調用分離出來，放在不同的語句中，如下：
Ks = D.keys()
Ks.sort()
for k in Ks: print D[k]
只有在數字類型中才存在類型轉換
在Python中，一個諸如123+3.145的表達式是可以工作的——它會自動將整數型轉換為浮點型，然後用浮點運算。但是下面的代碼就會出錯了：
S = “42”
I = 1
X = S + I # 類型錯誤
這同樣也是有意而為的，因為這是不明確的：究竟是將字元串轉換為數字（進行相加）呢，還是將數字轉換為字元串（進行聯接）呢？在Python中，我們認為「明確比含糊好」（即，EIBTI（Explicit is better than implicit）），因此你得手動轉換類型：
X = int(S) + I # 做加法: 43
X = S + str(I) # 字元串聯接: “421”
循環的數據結構會導致循環
儘管這在實際情況中很少見，但是如果一個對象的集合包含了到它自己的引用，這被稱為循環對象（cyclic object）。如果在一個對象中發現一個循環，Python會輸出一個[…]，以避免在無限循環中卡住：
L = [‘grail’] # 在 L中又引用L自身會
L.append(L) # 在對象中創造一個循環
L
[‘grail’, […]]
除了知道這三個點在對象中表示循環以外，這個例子也是很值得借鑒的。因為你可能無意間在你的代碼中出現這樣的循環的結構而導致你的代碼出錯。如果有必要的話，維護一個列表或者字典來表示已經訪問過的對象，然後通過檢查它來確認你是否碰到了循環。
賦值語句不會創建對象的副本，僅僅創建引用
這是Python的一個核心理念，有時候當行為不對時會帶來錯誤。在下面的例子中，一個列表對象被賦給了名為L的變數，然後L又在列表M中被引用。內部改變L的話，同時也會改變M所引用的對象，因為它們倆都指向同一個對象。
L = [1, 2, 3] # 共用的列表對象
M = [‘X’, L, ‘Y’] # 嵌入一個到L的引用
M
[‘X’, [1, 2, 3], ‘Y’]
L[1] = 0 # 也改變了M
M
[‘X’, [1, 0, 3], ‘Y’]
通常情況下只有在稍大一點的程序里這就顯得很重要了，而且這些共用的引用通常確實是你需要的。如果不是的話，你可以明確的給他們創建一個副本來避免共用的引用；對於列表來說，你可以通過使用一個空列表的切片來創建一個頂層的副本：
L = [1, 2, 3]
M = [‘X’, L[:], ‘Y’] # 嵌入一個L的副本
L[1] = 0 # 僅僅改變了L，但是不影響M
L
[1, 0, 3]
M
[‘X’, [1, 2, 3], ‘Y’]
切片的範圍起始從默認的0到被切片的序列的最大長度。如果兩者都省略掉了，那麼切片會抽取該序列中的所有元素，並創造一個頂層的副本（一個新的，不被公用的對象）。對於字典來說，使用字典的dict.copy()方法。
靜態識別本地域的變數名
Python默認將一個函數中賦值的變數名視作是本地域的，它們存在於該函數的作用域中並且僅僅在函數運行的時候才存在。從技術上講，Python是在編譯def代碼時，去靜態的識別本地變數，而不是在運行時碰到賦值的時候才識別到的。如果不理解這點的話，會引起人們的誤解。比如，看看下面的例子，當你在一個引用之後給一個變數賦值會怎麼樣：
X = 99
def func():
… print X # 這個時候還不存在
… X = 88 # 在整個def中將X視作本地變數
…
func( ) # 出錯了！
你會得到一個「未定義變數名」的錯誤，但是其原因是很微妙的。當編譯這則代碼時，Python碰到給X賦值的語句時認為在這個函數中的任何地方X會被視作一個本地變數名。但是之後當真正運行這個函數時，執行print語句的時候，賦值語句還沒有發生，這樣Python便會報告一個「未定義變數名」的錯誤。
事實上，之前的這個例子想要做的事情是很模糊的：你是想要先輸出那個全局的X，然後創建一個本地的X呢，還是說這是個程序的錯誤？如果你真的是想要輸出這個全局的X，你需要將它在一個全局語句中聲明它，或者通過包絡模塊的名字來引用它。
默認參數和可變對象
在執行def語句時，默認參數的值只被解析並保存一次，而不是每次在調用函數的時候。這通常是你想要的那樣，但是因為默認值需要在每次調用時都保持同樣對象，你在試圖改變可變的默認值（mutable defaults）的時候可要小心了。例如，下面的函數中使用一個空的列表作為默認值，然後在之後每一次函數調用的時候改變它的值：
def saver(x=[]): # 保存一個列表對象
… x.append(1) # 並每次調用的時候
… print x # 改變它的值
…
saver([2]) # 未使用默認值
[2, 1]
saver() # 使用默認值
[1]
saver() # 每次調用都會增加！
[1, 1]
saver()
[1, 1, 1]
有的人將這個視作Python的一個特點——因為可變的默認參數在每次函數調用時保持了它們的狀態，它們能提供像C語言中靜態本地函數變數的類似的一些功能。但是，當你第一次碰到它時會覺得這很奇怪，並且在Python中有更加簡單的辦法來在不同的調用之間保存狀態（比如說類）。
要擺脫這樣的行為，在函數開始的地方用切片或者方法來創建默認參數的副本，或者將默認值的表達式移到函數裡面；只要每次函數調用時這些值在函數里，就會每次都得到一個新的對象：
def saver(x=None):
… if x is None: x = [] # 沒有傳入參數？
… x.append(1) # 改變新的列表
… print x
…
saver([2]) # 沒有使用默認值
[2, 1]
saver() # 這次不會變了
[1]
saver()
[1]
其他常見的編程陷阱
下面列舉了其他的一些在這裡沒法詳述的陷阱：
在頂層文件中語句的順序是有講究的：因為運行或者載入一個文件會從上到下運行它的語句，所以請確保將你未嵌套的函數調用或者類的調用放在函數或者類的定義之後。
reload不影響用from載入的名字：reload最好和import語句一起使用。如果你使用from語句，記得在reload之後重新運行一遍from，否則你仍然使用之前老的名字。
在多重繼承中混合的順序是有講究的：這是因為對superclass的搜索是從左到右的，在類定義的頭部，在多重superclass中如果出現重複的名字，則以最左邊的類名為準。
在try語句中空的except子句可能會比你預想的捕捉到更多的錯誤。在try語句中空的except子句表示捕捉所有的錯誤，即便是真正的程序錯誤，和sys.exit()調用，也會被捕捉到。
Python面試基礎題十大陷阱，你中招了嗎
我們在會碰到各種各樣的面試，有的甚至是HR專門為你設置的障礙，在python面試中也是，無論你是應聘Python web開發，爬蟲工程師，或是數據分析，還是自動化運維，這些python面試基礎題十大陷阱也許你會遇到，今天的python培訓總結出來給你以防萬一：
問題1：請問如何修改以下Python代碼，使得下面的代碼調用類A的show方法?
class A(object)
def show(self):
print ‘derived show’
class B(A)
def show(self):
print ‘derived show’
obj=B()
obj.show()
答：這道題的考點是類繼承，只要通過__class__ 方法指定類對象就可以了。補充的代碼如下：
obj._class_=A
obj.show()
問題2：請問如何修改以下Python代碼，使得代碼能夠運行?
class A(object):
def _init_ (self,a,b):
self._a = a
self._b = b
def myprint(self):
print ‘a=’,self._a,’b=’,self._b
a1=A(10,20)
a1.myprint()
a1=(80)
答：此題考察得是方法對象，為了能讓對象實例能被直接調用，需要實現 __call__ 方法，補充代碼如下：
class A(object):
def _init_ (self,a,b):
self._a = a
self._b = b
def myprint(self):
print ‘a=’,self._a,’b=’,self._b
def_call_(self,num):
print’call:’,num+self._a
問題3：下面這段代碼的輸出是什麼?
class B(object):
def fn(self):
print”B fn”
def_init_(self):
print”B INIT”
class A(object):
def fn(self):
print”A fn”
def_new_(cls,a):
print”NEW”,a
if a10:
return super(A,cls)._new_(cls)
return B()
def_init_(self,a):
print “INIT”,a
a1=A(5)
a1,fn()
a2=A(20)
a2,fn()
答：
NEW 5
B INIT
B fn
NEW 20
INIT 20
A fn
此題考察的是new和init的用法，使用 __new__ 方法，可以決定返回那個對象，也就是創建對象之前調用的，這個常見於於設計模式的單例、工廠模式。__init__ 是創建對象是調用的。
問題4：下面這段代碼輸出什麼?
1s=[1,2,3,4]
list1 =[i for i in ls if i2
print list1
list2 =[1*2 for i in ls if 12
print list2
dicl={x: x**2 for x in(2, 4, 6)}
print dic1
dic2={x: ‘ item’+ str(x**2)for x in (2, 4, 6)}
print dic2
setl ={x for x in ‘hello world’ if x not in ‘low level’}
print set1
答:
[3,4]
[6,8]
{2:4,4:16,6:36}
{2:’item4′,4:’item16』,6:’item36″}set([“h”,’r’,’d”])
此題考察的是列表和字典的生成。
問題5：下面這段代碼輸出什麼?
num= 9
def f1():
um=20
def f2():
print num
f2()
f1()
f2()
答:
9
9
此題考察全局變數和局部變數。num 不是個全局變數，所以每個函數都得到了自己的 num 拷貝，如果你想修改 num ，則必須用 global 關鍵字聲明。比如下面這樣
num=9
def f1():
global num
um=20
def f2():
print num
f2()
f1()
f2()
#prints:
#9
#20
問題6：如何使用一行代碼交換兩個變數值?
a=8
b=9
答：
(a,b)=(b,a)
問題7：如何添加代碼，使得沒有定義的方法都調用mydefault方法?
class A(object):
def_init_(self,a,b):
self.a1=a
self.b1=b
print’init’
def mydefault(self):
print’default’
a1=A(10,20)
a1.fn1()
a1.fn2()
a1.fn3()
答：
class A(object):
def_init_(self,a,b):
self.a1=a
self.b1=b
print’init’
def mydefault(self):
print’default’
def_getattr_(self,name):
return self.mydefault
a1=A(10,20)
a1.fn1()
a1.fn2()
a1.fn3()
此題的考的是Python的默認方法， 只有當沒有定義的方法調用時，才會調用方法 __getattr__。當 fn1 方法傳入參數時，我們可以給 mydefault 方法增加一個 *args 不定參數來兼容。
class A(object):
def_init_(self,a,b):
self.a1=a
self.b1=b
print’init’
def mydefault(self,*args):
print’default:’+str(args[0])
def_getattr_(self,name):
print”other fn:”,name
return self.mydefault
a1=A(10,20)
a1.fn1(33)
a1.fn2(‘hello’)
a1.fn3(10)
問題8：一個包里有三個模塊，mod1.py , mod2.py , mod3.py ，但使用 from demopack import * 導入模塊時，如何保證只有 mod1 、 mod3 被導入了。
答:在包中增加 __init__.py 文件，並在文件中增加：
_all_=[‘mod1′,’mod3’]
問題9：寫一個函數，接收整數參數 n ，返回一個函數，函數返回n和參數的積。
答:
def mulby(num):
def gn(val):
return num*val
return gn
zw=mulby(7)
print(zw(9));
問題10：請問下面的代碼有什麼隱患?(Python2中)
def strtest1(num):
str=’first’
for i in range(num):
str+=”X”
return str
答：由於變數str是個不可變對象，每次迭代，python都會生成新的str對象來存儲新的字元串，num越大，創建的str對象越多，內存消耗越大。
python的簡單問題？
要把代碼發現來才知道，以下是常見的錯誤下面終於要講到當你用到更多的Python的功能（數據類型，函數，模塊，類等等）時可能碰到的問題了。由於篇幅有限，這裡盡量精簡，尤其是對一些高級的概念。要想了解更多的細節，敬請閱讀Learning Python, 2nd Edition的逗小貼士地以及逗Gotchas地章節。 打開文件的調用不使用模塊搜索路徑當你在Python中調用open()來訪問一個外部的文件時，Python不會使用模塊搜索路徑來定位這個目標文件。它會使用你提供的絕對路徑，或者假定這個文件是在當前工作目錄中。模塊搜索路徑僅僅為模塊載入服務的。不同的類型對應的方法也不同列表的方法是不能用在字元串上的，反之亦然。通常情況下，方法的調用是和數據類型有關的，但是內部函數通常在很多類型上都可以使用。舉個例子來說，列表的reverse方法僅僅對列表有用，但是len函數對任何具有長度的對象都適用不能直接改變不可變數據類型記住你沒法直接的改變一個不可變的對象（例如，元組，字元串）： T = (1, 2, 3) T[2] = 4 # 錯誤 用切片，聯接等構建一個新的對象，並根據需求將原來變數的值賦給它。因為Python會自動回收沒有用的內存，因此這沒有看起來那麼浪費： T = T[:2] + (4,) # 沒問題了: T 變成了 (1, 2, 4) 使用簡單的for循環而不是while或者range 當你要從左到右遍歷一個有序的對象的所有元素時，用簡單的for循環（例如，for x in seq:）相比於基於while-或者range-的計數循環而言會更容易寫，通常運行起來也更快。除非你一定需要，盡量避免在一個for循環里使用range：讓Python來替你解決標號的問題。在下面的例子中三個循環結構都沒有問題，但是第一個通常來說更好；在Python里，簡單至上。 S = “lumberjack” for c in S: print c # 最簡單 for i in range(len(S)): print S[i] # 太多了 i = 0 # 太多了 while i len(S): print S[i]; i += 1 不要試圖從那些會改變對象的函數得到結果諸如像方法list.append()和list.sort()一類的直接改變操作會改變一個對象，但不會將它們改變的對象返回出來（它們會返回None）；正確的做法是直接調用它們而不要將結果賦值。經常會看見初學者會寫諸如此類的代碼： mylist = mylist.append(X) 目的是要得到append的結果，但是事實上這樣做會將None賦值給mylist，而不是改變後的列表。更加特別的一個例子是想通過用排序後的鍵值來遍歷一個字典里的各個元素，請看下面的例子： D = {…} for k in D.keys().sort(): print D[k] 差一點兒就成功了——keys方法會創建一個keys的列表，然後用sort方法來將這個列表排序——但是因為sort方法會返回None，這個循環會失敗，因為它實際上是要遍歷None（這可不是一個序列）。要改正這段代碼，將方法的調用分離出來，放在不同的語句中，如下： Ks = D.keys() Ks.sort() for k in Ks: print D[k] 只有在數字類型中才存在類型轉換在Python中，一個諸如123+3.145的表達式是可以工作的——它會自動將整數型轉換為浮點型，然後用浮點運算。但是下面的代碼就會出錯了： S = “42” I = 1 X = S + I # 類型錯誤 這同樣也是有意而為的，因為這是不明確的：究竟是將字元串轉換為數字（進行相加）呢，還是將數字轉換為字元串（進行聯接）呢看在Python中，我們認為逗明確比含糊好地（即，EIBTI（Explicit is better than implicit）），因此你得手動轉換類型： X = int(S) + I # 做加法: 43 X = S + str(I) # 字元串聯接: “421” 循環的數據結構會導致循環儘管這在實際情況中很少見，但是如果一個對象的集合包含了到它自己的引用，這被稱為循環對象（cyclic object）。如果在一個對象中發現一個循環，Python會輸出一個[…]，以避免在無限循環中卡住： L = [‘grail’] # 在 L中又引用L自身會 L.append(L) # 在對象中創造一個循環 L [‘grail’, […]] 除了知道這三個點在對象中表示循環以外，這個例子也是很值得借鑒的。因為你可能無意間在你的代碼中出現這樣的循環的結構而導致你的代碼出錯。如果有必要的話，維護一個列表或者字典來表示已經訪問過的對象，然後通過檢查它來確認你是否碰到了循環。賦值語句不會創建對象的副本，僅僅創建引用這是Python的一個核心理念，有時候當行為不對時會帶來錯誤。在下面的例子中，一個列表對象被賦給了名為L的變數，然後L又在列表M中被引用。內部改變L的話，同時也會改變M所引用的對象，因為它們倆都指向同一個對象。 L = [1, 2, 3] # 共用的列表對象 M = [‘X’, L, ‘Y’] # 嵌入一個到L的引用 M [‘X’, [1, 2, 3], ‘Y’] L[1] = 0 # 也改變了M M [‘X’, [1, 0, 3], ‘Y’] 通常情況下只有在稍大一點的程序里這就顯得很重要了，而且這些共用的引用通常確實是你需要的。如果不是的話，你可以明確的給他們創建一個副本來避免共用的引用；對於列表來說，你可以通過使用一個空列表的切片來創建一個頂層的副本： L = [1, 2, 3] M = [‘X’, L[:], ‘Y’] # 嵌入一個L的副本 L[1] = 0 # 僅僅改變了L，但是不影響M L [1, 0, 3] M [‘X’, [1, 2, 3], ‘Y’] 切片的範圍起始從默認的0到被切片的序列的最大長度。如果兩者都省略掉了，那麼切片會抽取該序列中的所有元素，並創造一個頂層的副本（一個新的，不被公用的對象）。對於字典來說，使用字典的dict.copy()方法。靜態識別本地域的變數名 Python默認將一個函數中賦值的變數名視作是本地域的，它們存在於該函數的作用域中並且僅僅在函數運行的時候才存在。從技術上講，Python是在編譯def代碼時，去靜態的識別本地變數，而不是在運行時碰到賦值的時候才識別到的。如果不理解這點的話，會引起人們的誤解。比如，看看下面的例子，當你在一個引用之後給一個變數賦值會怎麼樣： X = 99 def func(): … print X # 這個時候還不存在 … X = 88 # 在整個def中將X視作本地變數 … func( ) # 出錯了！ 你會得到一個逗未定義變數名地的錯誤，但是其原因是很微妙的。當編譯這則代碼時，Python碰到給X賦值的語句時認為在這個函數中的任何地方X會被視作一個本地變數名。但是之後當真正運行這個函數時，執行print語句的時候，賦值語句還沒有發生，這樣Python便會報告一個逗未定義變數名地的錯誤。事實上，之前的這個例子想要做的事情是很模糊的：你是想要先輸出那個全局的X，然後創建一個本地的X呢，還是說這是個程序的錯誤看如果你真的是想要輸出這個全局的X，你需要將它在一個全局語句中聲明它，或者通過包絡模塊的名字來引用它。默認參數和可變對象在執行def語句時，默認參數的值只被解析並保存一次，而不是每次在調用函數的時候。這通常是你想要的那樣，但是因為默認值需要在每次調用時都保持同樣對象，你在試圖改變可變的默認值（mutable defaults）的時候可要小心了。例如，下面的函數中使用一個空的列表作為默認值，然後在之後每一次函數調用的時候改變它的值： def saver(x=[]): # 保存一個列表對象 … x.append(1) # 並每次調用的時候 … print x # 改變它的值 … saver([2]) # 未使用默認值 [2, 1] saver() # 使用默認值 [1] saver() # 每次調用都會增加！ [1, 1] saver() [1, 1, 1] 有的人將這個視作Python的一個特點——因為可變的默認參數在每次函數調用時保持了它們的狀態，它們能提供像C語言中靜態本地函數變數的類似的一些功能。但是，當你第一次碰到它時會覺得這很奇怪，並且在Python中有更加簡單的辦法來在不同的調用之間保存狀態（比如說類）。要擺脫這樣的行為，在函數開始的地方用切片或者方法來創建默認參數的副本，或者將默認值的表達式移到函數裡面；只要每次函數調用時這些值在函數里，就會每次都得到一個新的對象： def saver(x=None): … if x is None: x = [] # 沒有傳入參數看 … x.append(1) # 改變新的列表 … print x … saver([2]) # 沒有使用默認值 [2, 1] saver() # 這次不會變了 [1] saver() [1] 其他常見的編程陷阱下面列舉了其他的一些在這裡沒法詳述的陷阱：在頂層文件中語句的順序是有講究的：因為運行或者載入一個文件會從上到下運行它的語句，所以請確保將你未嵌套的函數調用或者類的調用放在函數或者類的定義之後。 reload不影響用from載入的名字：reload最好和import語句一起使用。如果你使用from語句，記得在reload之後重新運行一遍from，否則你仍然使用之前老的名字。在多重繼承中混合的順序是有講究的：這是因為對superclass的搜索是從左到右的，在類定義的頭部，在多重superclass中如果出現重複的名字，則以最左邊的類名為準。在try語句中空的except子句可能會比你預想的捕捉到更多的錯誤。在try語句中空的except子句表示捕捉所有的錯誤，即便是真正的程序錯誤，和sys.exit()調用，也會被捕捉到。
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/308713.html
微信掃一掃 
支付寶掃一掃 