奇怪的python行為,python容易犯的錯誤

本文目錄一覽：

• 1、Python 很奇怪的問題，為什麼會這樣輸出
• 2、可以用 Python 編程語言做哪些神奇好玩的事情
• 3、python出錯，請問是什麼問題
• 4、python多線程運行過程中出現奇怪的等待行為
• 5、Python正則表達式奇怪現象

Python 很奇怪的問題，為什麼會這樣輸出

你重寫了__del__方法，還給它加了一個name參數，__del__是系統自行調用，默認只傳一個對象，也就是self，自然就會報錯

可以用 Python 編程語言做哪些神奇好玩的事情

機器學習,比如手寫字識別,人臉識別,垃圾郵件處理等。 當然還可以畫圖,和matlab類似,不過是工業級的。

也許最初設計 Python 這種語言的人並沒有想到今天Python 會在工業和科研上獲得如此廣泛的使用。著名的自由軟件作者Eric Raymond 在他的文章《如何成為一名黑客》中，將Python 列為黑客應當學習的四種編程語言之一，並建議人們從Python 開始學習編程。這的確是一個中肯的建議，對於那些從來沒有學習過編程或者並非計算機專業的編程學習者而言，Python 是最好的選擇之一。Python 第一次學習Python，我只用了不到二十分鐘的時間，站在書店裡把一本教初學編程的人學習Python 的書翻了一遍。也是從那時起，我開始被這種神奇的語言吸引。 Python 可以用來開發symbian 上的東西。 易用與速度的完美結合Python 是一種用起來很方便的語言，很多初學Java 的人都會被 Java 的CLASSPATH 搞得暈頭轉向，花上半天的時間才搞明白原來是CLASSPATH 搞錯了自己的 Hello World 才沒法運行。用Python 就不會有這種問題，只要裝上就能直接用。 Python 是一種腳本語言，寫好了就可以直接運行，省去了編譯鏈接的麻煩，對於需要多動手實踐的初學者而言，也就是少了出錯的機會。而且Python 還有一種交互的方式，如果是一段簡單的小程序，連編輯器都可以省了，直接敲進去就能運行。Python 是一種清晰的語言，用縮進來表示程序的嵌套關係可謂是一種創舉，把過去軟性的編程風格升級為硬性的語法規定。再不需要在不同的風格間選擇、再不需要為不同的風格爭執。與 Perl 不同，Python 中沒有各種隱晦的縮寫，不需要去強記各種奇怪的符號的含義。Python 寫的程序很容易懂，這是不少人的共識。Python 是一種面向對象的語言，但它的面向對象卻不象C++那樣強調概念，而是更注重實用。不是為了體現對概念的完整支持而把語言搞得很複雜，而是用最簡單的方法讓編程者能夠享受到面向對象帶來的好處，這正是 Python 能像 Java、C#那樣吸引眾多支持者的原因之一。 Python 是一種功能豐富的語言，它擁有一個強大的基本類庫和數量眾多的第三方擴展，使得Python 程序員無需去羨慕Java 的JDK。Python 為程序員提供了豐富的基本功能使得人們寫程序時用不着一切最底層做起。說到這裡，人們通常會用一種擔心：腳本語言通常很慢。腳本語言從運行的速度講的確會慢一些，但 Python 的速度卻比人們想像得快很多。雖然 Python 是一種腳本語言，但實際上也可以對它進行編譯，就象編譯Java 程序一樣將Python 程序編譯為一種特殊的ByteCode，在程序運行時，執行的是ByteCode，省去了對程序文本的分析解釋，速度自然提升很多。在用Java 編程是，人們崇尚一種Pure Java 的方式，除了虛擬機一切東西都用Java 編寫，無論是基本的數據結構還是圖形界面，而Pure Java 的SWING，卻成為無數Java 應用開發者的噩夢。Python 崇尚的是實用，它的整體環境是用C 來編寫的，很多基本的功能和擴展的模塊都是用 C/C++來編寫的，當執行這一部分代碼時，它的速度就是C 的速度。用Python 編寫的普通桌面程序，其啟動運行速度與用C 寫的程序差別不大。除了這些，通過一些第三方軟件包，用Python 編寫的源代碼還可以以類似JIT 的方式運行，而這可以大大提高Python 代碼的運行速度，針對不同類型的代碼，會有2 倍至100 倍不等的速度提升。 Python 是我見到過的語言中，在易用性和速度上結合的最完美的一個，通過喪失一點點經常可以忽略不計的運行速度從而獲得更高的編程效率，這就是我選擇Python 的原因。把精力放在要解決的問題上選擇一種合適的語言，才能讓你把有限的精力放到最需要解決的問題上。不同的語言有不同的作用，C 和彙編適合編寫系統軟件，如果用它們來編寫企業應用，恐怕沒幾個人能得心應手。我以前就碰到一個用彙編寫數據庫程序的哥，雖然最基本的功能完成了，但要增加個報表預覽什麼的，他就沒法應付了。聰明的程序員是用合適的工具去完成任務，想找一把萬能鑰匙是不太可能的。Python 的自動的垃圾回收機制是高級的編程語言的一種基本特性，用擁有這一功能的語言編程，程序員們通常不用去關心內存泄漏的問題，而當我們用 C/C++寫程序時，這卻是最重要的需要認真考慮卻又很容易出錯的問題之一。數據結構是程序構成的重要部分，鏈表、樹、圖這些在用C 編程時需要仔細表達的問題在Python 中簡單了很多。在Python 中，最基本的數據結構就是數組、序列和哈希表，用它們想要表達各種常見的數據結構是非常容易的。沒了定義指針、分配內存的任務，編程變得有趣了。CORBA 是一種高級的軟件體系結構，它是語言無關平台無關的。C++、Java 等語言都有CORBA 綁定，但與它們相比，Python 的 CORBA 綁定卻容易很多，因為在程序員看來，一個 CORBA 的類和 Python 的類用起來以及實現起來並沒有什麼差別。沒了複雜體系結構的困擾，用 Python 編寫CORBA 程序也變得容易了。好鋼要用在刀刃上，要想用有限的時間完成盡量多的任務，就要把各種無關的問題拋棄，而Python 恰恰提供了這種方法。跨平台又易擴展隨着Linux 的不斷成熟，越來越多的人轉到Linux 平台上工作，軟件的開發者自然就希望自己編寫的軟件可以在所有平台下運行。Java 一次編寫處處運行的口號使它成為跨平台的開發工具的典範，但其運行速度卻不被人們看好。實際上，幾乎所有的著名腳本語言都是跨平台的，Python 也不例外。

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多線程運行過程中出現奇怪的等待行為

你這個程序問題在new = Thread( self.subfunc(i) ) 傳進去的時候就已經調用了self.subfunc

改成 new = Thread( target=self.subfunc, args=(i,) )

另外i 數字太小也看不出來，因為工作量太小，在線程的一個時間片內函數就執行完了，看不到切換的過程，設成if i10000就明顯了

Python正則表達式奇怪現象

因為你的正則表達式寫的有問題。

你寫的是r'[0-9]*’其中這個*表示是匹配0個或0個以上，對於hu這也是符合0個的。所以什麼都沒有打印，至於空格則是print ,這個逗號自動產生的。

最後為什麼是15個，這個是英文字母含有11個，另外3個連續數字，最後加一個空串，最後總共就是15個了。。

如果你要只匹配數字部分應該用r'[0-9]+’或r’\d+’，+號表示至少匹配1個