編者按：在Java文章頻道里，我們大部分人應(yīng)該對該語言都非常的了解，而且在該生態(tài)圈內(nèi)至少已經(jīng)呆了好幾年了。這讓我們有常規(guī)和專業(yè)的知識，但是也同時(shí)也讓我們一些井蛙之見。 在Outside-In Java系列文章中，一些非Java開發(fā)人員會(huì)給我們講講他們對于我們這個(gè)生態(tài)圈的看法。

從哲學(xué)的角度來講，Python幾乎是與Java截然相反。它拋棄了靜態(tài)類型和剛性結(jié)構(gòu)，而是使用了一個(gè)松散的沙盒，在這里面你可以自由的做任何你想做的事情。也許Python是關(guān)于你能夠做什么，而Java則是關(guān)于你可以做什么。

然而，兩種語言都從C語言里吸取了大量的靈感。他們都是命令式語言，擁有塊、循環(huán)、方法、賦值以及中綴算術(shù)(infix math)。兩者都大量使用了類、對象、繼承以及多態(tài)性。兩者的功能異常都相當(dāng)優(yōu)秀。 兩者都能自動(dòng)管理內(nèi)存。它們都是編譯成可以運(yùn)行在某種虛擬機(jī)上的字節(jié)碼，盡管Python是透明的進(jìn)行編譯。 Python甚至從Java汲取了一些營養(yǎng)：比如基本庫的 logging 和 unittest 模塊分別是受到了log4j 和JUnit的啟發(fā)。

鑒于以上的技術(shù)重疊，我認(rèn)為Java開發(fā)人員在使用Python時(shí)理應(yīng)感到賓至如歸。 所以我來給你一些簡單的Python介紹。 我會(huì)可以告訴你什么使得Python與Java不同，以及為什么我覺得這些差異有吸引力。 至少，您可能會(huì)發(fā)現(xiàn)一些有趣的想法使您回到Java生態(tài)系統(tǒng)。

(如果你想要一個(gè)Python教程，Python文檔是一個(gè)很好的選擇，而且這是從Python 3的角度編寫的，Python 2的使用還是很常見的，它與Python 3有一些語法上的差異。

語法

我們先把語法弄明白。下面是 hello world入門程序：

1. print('Hello, world!') 

嗯， 并不是很有啟發(fā)性。 好吧，再來看一個(gè)函數(shù)，看看如何在一個(gè)文件中找到最常見的10個(gè)單詞。在這里我取巧使用了標(biāo)準(zhǔn)庫的 Counter 類型，但是它就是這么的好用。

1. from collections import Counter 
2.  
3. def count_words(path): 
4.     words = Counter() 
5.     with open(path) as f: 
6.         for line in f: 
7.             for word in line.strip().split(): 
8.                 words[word]  = 1 
9.  
10.     for word, count in words.most_common(10): 
11.         print(f'{word} x{count}') 

Python由空格分隔。人們經(jīng)常對此有強(qiáng)烈的意見。當(dāng)我第一次看到它的時(shí)候，我 甚至認(rèn)為這是異端邪說。現(xiàn)在，十多年過去了，這種寫法似乎自然到我很難再回到大括號式的寫法。如果你因此逃避，我甚至懷疑我可以說服你，不過我勸你至少暫時(shí)忽略一下它;實(shí)際上它并沒有造成任何嚴(yán)重的問題，反而消除了一大堆的干擾。此外，Python開發(fā)人員從來不必爭論{應(yīng)該放在哪里。

除了審美上的差異之外，其他方面應(yīng)該看起來很熟悉。我們有一些數(shù)字，一些賦值和一些方法調(diào)用。import 語句的工作方式有些不同，但它具有相同的“使這些內(nèi)容可用”的一般含義。 Python的for循環(huán)與Java的for-each循環(huán)非常相似，只是少了點(diǎn)標(biāo)點(diǎn)符號。函數(shù)本身使用def而不是類型進(jìn)行分隔，但它正是按照你期望的方式工作：您可以使用參數(shù)調(diào)用它，然后返回一個(gè)值(盡管某些函數(shù)不返回值)。

只有兩件事情是很不尋常的。 一個(gè)是 with 塊，非常類似于Java 7的“try-with-resources” – 它保證文件在塊的結(jié)尾處關(guān)閉，即使會(huì)拋出一個(gè)異常。 另一個(gè)是f“…”語法，這是一個(gè)相當(dāng)新的功能，允許將表達(dá)式直接插入到字符串中。

就是這樣! 你已經(jīng)讀了一些Python的內(nèi)容。 至少，它不是來自一個(gè)完全不同的星球的語言。

動(dòng)態(tài)類型

看這個(gè)例子可能很明顯，但是Python代碼里沒有太多的類型聲明。 變量聲明上沒有，參數(shù)或返回類型上沒有，對象上也沒有。 任何值在任何時(shí)候都可以是任何類型的。 我還沒有顯示一個(gè)類定義，所以這里只是一個(gè)簡單的定義。

1. class Point: 
2.     def __init__(self, x, y): 
3.         self.x = x 
4.         self.y = y 
5.  
6.     def magnitude(self): 
7.         return (self.x ** 2   self.y ** 2) ** 0.5 
8.  
9. point = Point(3, 4) 
10. print(point.x)  # 3 
11. print(point.magnitude())  # 5.0 

盡管x和y有并沒有定義為屬性,它們的存在是因?yàn)闃?gòu)造器中創(chuàng)建了它們。沒有誰強(qiáng)制我必須傳個(gè)整型參數(shù),我也可以傳小數(shù)和分?jǐn)?shù)。

如果你以前只用過靜態(tài)語言，這可能看起來一片混亂。類型是溫暖的懶惰的以及令人滿意的。他們保證···(好吧，或許不會(huì))代碼實(shí)際能工作(雖然有人不同意)。但是當(dāng)你都不知道什么是正確類型的時(shí)候，你又怎么能依靠代碼呢?

但是等等 – Java也沒有這樣的保證! 畢竟任何對象可能都是null，對吧? 實(shí)際上幾乎從來沒有一個(gè)正確類型的對象。

您可能會(huì)將動(dòng)態(tài)類型視為對null問題的徹底放棄。 如果我們必須處理它，我們不妨擁抱它，并讓它為我們工作 – 通過將一切 延遲到運(yùn)行時(shí)。 類型錯(cuò)誤變成正常的邏輯錯(cuò)誤，您可以以相同的方式處理它們。

(對于相反的方法，請參閱 Rust，它沒有空值 – 或者異常，我還是寧愿寫Python，但是我很欣賞Rust的類型系統(tǒng)并不總是對我說謊。)

在我的magnitude方法中，self.x是int或float或任何其他類型，這都不重要。 它只需要支持**運(yùn)算符并返回支持 運(yùn)算符的內(nèi)容。 (Python支持操作符重載，所以這可能是任何內(nèi)容。)同樣適用于普通方法調(diào)用：任何類型都可以接受，只要它實(shí)際上可以工作。

這意味著Python不需要泛型; 一切都是按照泛型工作的。 不需要接口; 一切都已經(jīng)是多態(tài)的。 沒有向下轉(zhuǎn)型(downcasts)，沒有向上轉(zhuǎn)型(upcasts)，在類型系統(tǒng)中沒有逃生艙口(escape hatches)。 當(dāng)它們可以和任意Iterable工作良好時(shí)，運(yùn)行時(shí)API不需要List。

許多常見的模式變得更加容易。 您可以創(chuàng)建包裝器對象和代理，而無需更改消費(fèi)代碼。 您可以使用組合而不是繼承來擴(kuò)展第三方類型，而不需要為保留多態(tài)做任何特殊的操作。 靈活的API不需要將每個(gè)類作為接口復(fù)制; 一切都已經(jīng)作為一個(gè)隱式接口了。

動(dòng)態(tài)類型哲學(xué)

使用靜態(tài)類型，無論誰編寫 某些代碼來選擇這些類型，編譯器都會(huì)檢查它們是否正常工作。 使用動(dòng)態(tài)類型，無論誰使用 某些代碼來選擇這些類型，運(yùn)行時(shí)都會(huì)嘗試一下。 這就是對立的哲學(xué)在起作用：類型系統(tǒng)著重于你可以 做什么，而不是你可能 做什么。

這樣使用動(dòng)態(tài)類型有時(shí)被稱為 “鴨子類型”(duck typing)，這是基于這種思想： “如果它走起來像鴨子，而且叫起來也像鴨子，那么它就是一個(gè)鴨子?！?換言之，就是說，如果你想要的是能像鴨子一樣呱呱叫的東西的話，你不用強(qiáng)制你的代碼必須接收一個(gè)鴨子對象，相反的你可以接收任何給你的東西，并且讓它能夠呱呱叫即可。如果它可以達(dá)成你的目標(biāo)的話，那么它就跟鴨子一樣好用。(否則如果它無法如你所愿，會(huì)拋出AttributeError的錯(cuò)誤，但是這也沒什么大不了的。)

同時(shí)也要注意Python是強(qiáng)類型的。這個(gè)詞有點(diǎn)模糊，它通常意味著變量的值在運(yùn)行時(shí)會(huì)一直保持其類型不變。一個(gè)典型的例子是，Python不會(huì)讓你把一個(gè)字符串賦值給一個(gè)數(shù)字類型的變量，而像弱類型語言，如JavaScript 則可以將一種類型靜默的轉(zhuǎn)換成另一種，這里使用了優(yōu)先級的規(guī)則，跟你的預(yù)期會(huì)有所不同。

與大多數(shù)動(dòng)態(tài)語言不同的是，Python 在運(yùn)行之前就可以捕獲錯(cuò)誤信息。例如讀取一個(gè)不存在的變量會(huì)產(chǎn)生一個(gè)異常，包括從一個(gè)字典對象(如 Map)中讀取一個(gè)不存在的鍵時(shí)也會(huì)報(bào)錯(cuò)。在 JavaScript 、Lua 和類似語言中，上面兩種情況是返回 null 值。(Java 也是返回 null 值)。如果想在值不存在時(shí)返回默認(rèn)值，字典類提供了更加明確的方法調(diào)用。

這里絕對是一個(gè)權(quán)衡的結(jié)果，是否值得取決于不同的項(xiàng)目和人。對我來說，至少非常適合用來設(shè)計(jì)一個(gè)更加可靠的系統(tǒng)，以為我可以看到它實(shí)際執(zhí)行的情況。但是靜態(tài)類型的語言都期待有一個(gè)預(yù)先的設(shè)計(jì)。靜態(tài)類型很難嘗試各種不同的想法，更難發(fā)揮。

你確實(shí)擁有了更少的靜態(tài)檢查保證，但根據(jù)我的經(jīng)驗(yàn)，大多數(shù)的類型錯(cuò)誤可以正確被捕獲……因?yàn)槲覍懲甏a的第一件事就是嘗試去運(yùn)行它!其它任何錯(cuò)誤應(yīng)該可以被你的測試所捕獲—測試應(yīng)該在所有語言中都有，并且python語言寫測試相對來說更容易。

一個(gè)混合的范例

Python 和 Java 都是命令式和對象導(dǎo)向的：它們的工作方式是執(zhí)行指令，它們把每件事物塑造為對象。

在最近的發(fā)行版本中，Java增加了一些函數(shù)式語言特征，我認(rèn)為這是一件好事。Python也有函數(shù)式語言特征，但是實(shí)現(xiàn)的方式不太一樣。它提供了一些內(nèi)置的函數(shù)如map和reduce，但是它并不是基于串聯(lián)許多小函數(shù)的思想來設(shè)計(jì)的。

相反，Python混合了其它東西。我不知道Python采用的方法的通用名稱。我認(rèn)為它把“函數(shù)鏈”的思想分為兩個(gè)：作用于序列上和使函數(shù)自身更加有用。

序列

序列和迭代在Python有重要的地位。序列是最基礎(chǔ)的數(shù)據(jù)結(jié)構(gòu)，作為于之上的工具非常有價(jià)值。我認(rèn)為Python對于函數(shù)式編程的實(shí)現(xiàn)如下：Python首先使得使用命令式代碼來操作序列非常容易，而不是使得結(jié)合許多小函數(shù)然后應(yīng)用于序列非常容易。

回到本文開始的地方，我曾寫下這一行代碼：

1. for word, count in words.most_common(10): 

for循環(huán)對我們來說很熟悉，但是這行代碼一次迭代了兩個(gè)變量。 實(shí)際發(fā)生的是，列表most_common中的每個(gè)元素返回一個(gè)元組，它們是一組按順序區(qū)分的值。 真正發(fā)生的是元組可以通過將它們分配給元組變量名來解包。 元組通常用于在Python中返回多個(gè)值，但它們偶爾也可用于特殊結(jié)構(gòu)。 在Java中，您需要一個(gè)完整的類和幾行分配值的代碼。

任何可以迭代的東西同樣可以解包。 解包支持任意嵌套，所以a，(b，c)= …按照它看起來的樣子解包。 對于未知長度的序列，一個(gè)*leftovers元素可以出現(xiàn)在任何地方，并且將根據(jù)需要獲取盡可能多的元素。 也許你真的會(huì)喜歡LISP?

1. values = [5, 7, 9] 
2. head, *tail = values 
3. print(head)  # 5 
4. print(tail)  # (7, 9) 

Python還具有通過簡單表達(dá)式創(chuàng)建列表的語法 – 所謂的“列表解析” – 這比函數(shù)方法如map更為常見。 存在類似的語法用于創(chuàng)建分組和集合。 整個(gè)循環(huán)可以減少到一個(gè)單一的表達(dá)式，只突出你真正感興趣的部分。

1. values = [3, 4, 5] 
2.  
3. values2 = [val * 2 for val in values if val != 4] 
4.  
5. print(values2) # [6, 10] 

標(biāo)準(zhǔn)庫還在itertools模塊中包含了許多有趣的迭代，組合器和用法。

最后，Python具有用于生成命令行代碼的延遲序列的生成器。 包含yield關(guān)鍵字的函數(shù)在被調(diào)用時(shí)不立即執(zhí)行; 而是返回一個(gè)生成器對象。 當(dāng)生成器迭代結(jié)束時(shí)，該函數(shù)運(yùn)行直到它遇到一個(gè)yield，此時(shí)它暫停; 生成的值將成為下一個(gè)迭代值。

1. def odd_numbers(): 
2.     n = 1 
3.     while True: 
4.         yield n 
5.         n  = 2 
6.  
7. for x in odd_numbers(): 
8.     print(x) 
9.     if x > 4: 
10.         break 
11. # 1 
12. # 3 
13. # 5 

因?yàn)樯善餮舆t運(yùn)行，它們可以產(chǎn)生無限序列或在中途中斷。 他們可以產(chǎn)生大量的大型對象，不會(huì)因?yàn)樽屗鼈內(nèi)看婊疃囊淮蠖褍?nèi)存。 它們也可以作為“鏈?zhǔn)健焙瘮?shù)編程風(fēng)格的一般替代。 您可以編寫熟悉的命令行代碼，而不是組合map和filter。

1. # This is the pathlib.Path API from the standard library 
2. def iter_child_filenames(dirpath): 
3.     for child in dirpath.iterdir(): 
4.         if child.is_file(): 
5.             yield child.name 

要在Java中表示完全任意的惰性迭代器，您需要編寫一個(gè)手動(dòng)跟蹤其狀態(tài)的Iterator。除了最簡單的情況之外，這一切都會(huì)變得相當(dāng)棘手。 Python也有一個(gè)迭代接口，所以您仍然可以使用這種方法，但是生成器非常容易使用，以至于大多數(shù)自定義迭代都是用它們編寫的。

而且因?yàn)樯善骺梢宰约簳和＃运鼈冊谄渌恍┥舷挛闹惺怯杏玫摹?通過手動(dòng)調(diào)用生成器(而不是僅用一個(gè)for循環(huán)來一次性全部迭代)，就可以在一段時(shí)間內(nèi)運(yùn)行一個(gè)功能，讓它在某一點(diǎn)停止，并在恢復(fù)該函數(shù)之前運(yùn)行其他代碼。 Python充分利用這一點(diǎn)來添加對異步I/O(不使用線程的非阻塞網(wǎng)絡(luò))的支持，盡管現(xiàn)在它具有專用的async 和await 語法。

函數(shù)

乍一看，Python的函數(shù)看上去非常面熟。你可以使用參數(shù)來調(diào)用它們。傳遞風(fēng)格與Java完全相同—Python既沒有引用也沒有隱式復(fù)制。 Python甚至有“docstrings”，類似于Javadoc注釋，但它是內(nèi)置的語法并且在運(yùn)行時(shí)可見。

1. def foo(a, b, c): 
2.  
3. '''Print out the arguments. Not a very useful function, really.''' 
4.  
5. print('I got', a, b, c) 
6.  
7. foo(1, 2, 3) # I got 1 2 3 

Java具有args …語法的可變函數(shù); Python使用* args可以實(shí)現(xiàn)類似的功能。 (用于解包的*leftovers語法靈感來源于函數(shù)語法。)但是，Python還有一些技巧。任何參數(shù)都可以有一個(gè)默認(rèn)值，使其成為可選項(xiàng)。任何參數(shù)也可以通過名稱 給出 – 我之前使用Point(x = 3，y = 4)演示了這點(diǎn)。在調(diào)用 任何函數(shù)時(shí)，可以使用* args語法，它將傳遞一個(gè)序列，就像它是單獨(dú)的參數(shù)一樣，并且有一個(gè)等價(jià)的** kwargs將命名參數(shù)作為一個(gè)dict接受或傳遞。一個(gè)參數(shù)可以作為“僅關(guān)鍵字(keyword-only)”，所以它必須 通過名稱傳遞，這對于可選的布爾值是非常好的。

Python當(dāng)然沒有 函數(shù)重載，但是你使用它實(shí)現(xiàn)的功能大部分都可以被鴨子類型(duck typing)和可選參數(shù)替換。

這是現(xiàn)階段Python最強(qiáng)大的功能之一。 與動(dòng)態(tài)類型一樣，您可以通過包裝器或代理透明地替換對象，* args和** kwargs允許任何函數(shù) 被透明地包裝。

1. def log_calls(old_function): 
2.  
3. def new_function(*args, **kwargs): 
4.  
5. print('i'm being called!', args, kwargs) 
6.  
7. return old_function(*args, **kwargs) 
8.  
9. return new_function 
10.  
11. @log_calls 
12.  
13. def foo(a, b, c=3): 
14.  
15. print(f'a = {a}, b = , c = {c}') 
16.  
17. foo(1, b=2) 
18.  
19. # i'm being called! (1,) {'b': 2} 
20.  
21. # a = 1, b = 2, c = 3 

這有點(diǎn)難以理解，對不起。 不用擔(dān)心它究竟是如何工作的; 要點(diǎn)是，foo被一個(gè)new_function替換，它將所有的參數(shù)轉(zhuǎn)發(fā)到foo。 foo和調(diào)用者都不需要知道哪些事情有哪些不同。

我不能低估它有多么強(qiáng)大。 它可用于記錄，調(diào)試，管理資源，緩存，訪問控制，驗(yàn)證等。 它與其他元編程功能工作良好，同樣地，它可以讓您分解結(jié)構(gòu)，而不僅僅是代碼。

對象和動(dòng)態(tài)運(yùn)行時(shí)

動(dòng)態(tài)運(yùn)行時(shí)是一種在背后驅(qū)動(dòng)語言核心部分的東西 — 它可以在運(yùn)行時(shí)被執(zhí)行。像 C 或者 C 這類的語言絕不會(huì)具有動(dòng)態(tài)運(yùn)行時(shí);它們源碼的結(jié)構(gòu)被“烘焙”成編譯輸出，并且后續(xù)沒有明顯的方法來改變它的行為。從另一方面，Java的確具有動(dòng)態(tài)運(yùn)行時(shí)!它甚至帶有一整個(gè)專門用于反射的包。

Python 當(dāng)然也有反射。很多簡單的函數(shù)通過反射被構(gòu)建，用來聯(lián)機(jī)檢查或修改對象的屬性，這對調(diào)試以及偶爾的欺騙非常有用。

但 Python 對此更深入一點(diǎn)。 因?yàn)橐磺卸荚谶\(yùn)行時(shí)完成，Python 暴露了很多擴(kuò)展點(diǎn)來自定義它的語義。 你不能改變語法，代碼依然看起來像 Python，但你可以分解結(jié)構(gòu) — 這在一種更死板的語言是非常難以做到的。

舉個(gè)極端的例子，看下 pytest， 它聰明的處理了 Python 的 assert 聲明。 通常， assert x == 1 為 false 時(shí)只會(huì)簡單的拋出一個(gè) AssertionError 異常，導(dǎo)致你不知道錯(cuò)誤是什么或者哪里出錯(cuò)了。這就是為什么 Python 內(nèi)置的單元測試模塊 — 像 JUnit 和很多其他的測試工具 — 提供很多專門的工具函數(shù)，比如 assertEquals。不幸的是，這些工具函數(shù)使得測試初看到時(shí)，更加復(fù)雜更難以讀懂。但在 pytest 中， assert x == 1 是好用的。如果失敗，pytest 將告訴你 x 是… 或者兩個(gè)列表哪里有分歧，或者兩個(gè)集合哪些元素不同, 或者其他的。所有的這些都是基于比較完成和運(yùn)算對象的類型自動(dòng)發(fā)生的。

pytest是如何工作的呢? 你確實(shí)不想知道。你不需要知道如何用pytest寫測試 — 這使人很開心。

這就是動(dòng)態(tài)運(yùn)行時(shí)的真正優(yōu)勢所在。 就自己而言，可能沒有使用這些功能。但是你能從這些庫中收獲巨大的好處，你使用這些庫并不需要關(guān)心它們?nèi)绾芜\(yùn)行。 甚至 Python 本身依靠使用自己的擴(kuò)展點(diǎn)實(shí)現(xiàn)了很多額外的特性 — 這些不需要改變語法或者解釋器。

對象

屬性(在C#中一般翻譯成特性)存取是我喜歡舉的一個(gè)簡單例子。在 Java 中，一個(gè) Point 類可能選擇用 getX() 和 setX() 方法而不是一個(gè)簡單直白的 x 屬性。原因是如果你需要改變 x 的讀或?qū)?，你不需要破壞接口。?Python 中，你不需要擔(dān)心前面的這些， 因?yàn)楸匾獣r(shí)你能解釋屬性存取。

1. class Point: 
2.     def __init__(self, x, y): 
3.         self._x = x 
4.         self._y = y 
5.  
6.     @property 
7.     def x(self): 
8.         return self._x 
9.  
10.     # ... same for y ... 
11.  
12. point = Point(3, 4) 
13. print(point.x)  # 3 

有趣的 @property 語法是一種修飾，看來就像 Java 的注解，但它可以更直接地修改函數(shù)或類。這是完全透明的調(diào)用代碼——和讀其它屬性沒什么區(qū)別——但是對象可以根據(jù)自己的需要干預(yù)或處理它。與 Java 不同，屬性訪問是類 API 的一部分，可以自由的定義。(注意這個(gè)示例讓 x 成為只讀的，因?yàn)槲覜]有指定寫方法!可寫屬性的語法有點(diǎn)滑稽，這里暫時(shí)不管它如何工作。但你可以具體規(guī)定只有奇數(shù)可以賦值給 point.x。)

這個(gè)特性也存在于其它靜態(tài)語言中，比如 C#，所以這并不是什么大不了的東西。關(guān)于 Python 真正有趣的部分是，屬性并沒什么特別。它是一個(gè)正常的內(nèi)建類型，一段純粹而且不滿一屏的 Python 程序。它的工作原理是 Python 類可以自定義其屬性訪問，包括一般的和按屬性的。包裝、代理和組合很容易實(shí)現(xiàn)：你可以將所有訪問調(diào)用轉(zhuǎn)發(fā)到底層對象，而不必知道它有什么方法。

相同的鉤子屬性可用于懶加載屬性或者自動(dòng)持有弱引用的屬性——這對調(diào)用代碼完全透明，通過純 Python 就能實(shí)現(xiàn)。

你可能已經(jīng)注意到我的代碼沒有使用 public 或 private 修飾符。事實(shí)上，Python 中不存在這個(gè)概念。按照慣例，用一個(gè)下劃線開頭表示“私有”——或者更準(zhǔn)備地說，“不打算成為穩(wěn)定公開 API 的一部分”。但這并沒有語言上的意義，Phthon 本身不會(huì)阻止偵查或修改這樣的屬性(如果是方法的話，則是調(diào)用)。同樣，也沒有final 、static或const。

這是同樣的工作原理：核心 Python 通常不會(huì)妨礙你做任何事情。如果你需要，它會(huì)非常有用。我已經(jīng)通過啟動(dòng)時(shí)調(diào)用或重寫，甚至重新定義私有方法來修補(bǔ)第三方庫的 BUG。這樣我不需要重新做一個(gè)項(xiàng)目的本地分支，可以省不少事。而且一量官方修復(fù)了 BUG，可很容易就能刪掉自己的補(bǔ)丁代碼。

同樣，你可以輕松地編寫依賴外部狀態(tài)的測試代碼——比如當(dāng)前時(shí)間。如果重構(gòu)不可行，你可以在測試時(shí)把 time.time() 替換為模擬函數(shù)。庫函數(shù)只是模塊模塊的屬性(就像 Java 的包)，而且 Python 模塊是種對象，和其它對象一樣，所以它們可以以同樣的方式偵查到或被修改。

類

Java 的類由 Class 對象支持，但二者并不有完全互換。比如 Foo 類的 Class 對象是 Foo.class。我不認(rèn)為 Foo 可以被它自己使用，因?yàn)樗艘粋€(gè)類型，Java 在處理類型和值的時(shí)候會(huì)有一些微妙的區(qū)別。

Python 中，類是對象，是類型的實(shí)例(它本身就是對象，是它自己的實(shí)例，想起來很有趣。)類可以當(dāng)作其它值一樣使用：作為參數(shù)、保存一某個(gè)更大的數(shù)據(jù)結(jié)構(gòu)中、檢查、操作。有時(shí)候把類作為字典的鍵特別有用。而且因?yàn)轭愂菍?shí)例化的，可以簡單地調(diào)用它們——Python 沒有 new 關(guān)鍵字 —— 很多情況下 new 和簡單的函數(shù)調(diào)用可以互換。這樣一來，一些常見的模式，比如工廠模式，就太簡單了，幾乎不需要。

1. # 等等，Vehicle 是一個(gè)類還是一個(gè)工廠函數(shù)?誰管呢! 
2.  
3. # 就算它在類或工廠函數(shù)之間互換，也不會(huì)破壞這段代碼。 
4.  
5. car = Vehicle(wheels=4, doors=4) 

最近我好幾次把函數(shù)甚至常規(guī)代碼放在頂層，不在任何類里面。這樣做不會(huì)有問題，但是其含義有點(diǎn)微妙。Python 中甚至 class 和 def 都是常規(guī)代碼，在運(yùn)行的時(shí)候執(zhí)行。Python 文件從上往下執(zhí)行，class 和 def 并不特別。它們只是有特殊的語法，用來創(chuàng)建特定類型的對象：類和函數(shù)。

以下是真正酷的部分。類是對象，它們的類型是type，因此你可以子類化并改變它的運(yùn)行。然后，你可以生成你的子類的實(shí)例。

第一次接觸仔細(xì)想想會(huì)感覺有點(diǎn)奇怪。但是再想下，你獲益于不需要知道它是如何運(yùn)行的。比如，Python沒有enum塊，但它確實(shí)有 enum module:

1. class Animal(Enum): 
2.     cat = 0 
3.     dog = 1 
4.     mouse = 2 
5.     snake = 3 
6.  
7. print(Animal.cat)           # <Animal.cat: 0> 
8. print(Animal.cat.value)     # 0 
9. print(Animal(2))            # <Animal.mouse: 2> 
10. print(Animal['dog'])        # <Animal.dog: 1> 

class 語句創(chuàng)建了一個(gè)對象，這意味著它在某處調(diào)用了構(gòu)造函數(shù)，而且可以重寫該構(gòu)造函數(shù)來改變類的構(gòu)造方式。這里Enum創(chuàng)建了一個(gè)固定的實(shí)例集，而不是類屬性。所有這些都是用普通的 Python 代碼的常規(guī)的 Python 語法實(shí)現(xiàn)的。

實(shí)體庫也是基于這個(gè)思路來構(gòu)建的。你討厭在構(gòu)造函數(shù)中單調(diào)的干 self.foo = foo 這種事情嗎?然后純手工定義相等性比較、哈希和克隆和開發(fā)可讀的列表?Java 需要編譯器支持，這個(gè)支持可能來自 Amber 項(xiàng)目。Python 非常靈活，所以社區(qū)中有 attrs 庫解決了這個(gè)問題。

1. import attr 
2.  
3. @attr.s 
4. class Point: 
5.     x = attr.ib() 
6.     y = attr.ib() 
7.  
8. p = Point(3, 4) 
9. q = Point(x=3, y=4) 
10. p == q  # True, which it wouldn't have been before! 
11. print(p)  # Point(x=3, y=4) 

或者采用 SQLAlchemy 這個(gè)功能強(qiáng)大的 Python 數(shù)據(jù)庫封裝庫。它包含一個(gè)靈感來自 Hibernate 的 ORM，但不需要在配置文件里定義表結(jié)構(gòu)或者通過其他冗長的注解，你可直接在類里編寫數(shù)據(jù)庫映射代碼：

1. class Order(Table): 
2.     id = Column(Integer, primary_key=True) 
3.     order_number = Column(Integer, index=True) 
4.     status = Column(Enum('pending', 'complete'), default='pending') 
5.     ... 

它的基本思想類同Enum，但SQLAlchemy也使用和property同樣的鉤子，自然而然地，你可以修改欄位值。

1. order.order_number = 5 
2.  
3. session.commit() 

最后，類本身可以在運(yùn)行中被創(chuàng)建。 這有點(diǎn)好處，可是 thriftpy 創(chuàng)建的整個(gè) module， 里面全是基于 Thrift 定義文件的類。 在Java中，你得需要代碼生成，這就增加了全新的編譯步驟，從而導(dǎo)致不同步。

所有這些示例依賴于Python現(xiàn)存的語法，但也在里面吸收了新的含義。它能做的，沒有你在Java或者其他語言中不能做的。但它刪減了結(jié)構(gòu)性的重復(fù) — 正是這些使得編碼更易寫、易讀，以及產(chǎn)生更少的bug。

結(jié)語

Python 有很多和Java相同的基本概念，但處理方向非常不同，它加入了一些全新的思想。Java關(guān)注于穩(wěn)定性和可靠性，而Python關(guān)注于可表達(dá)性和靈活性。它是一種完全不同的思想方式來思考命令式編程。

我有理由相信Python將讓你在Java所擅長的領(lǐng)域替換Java。Python可能不會(huì)贏在速度競賽上，比如(Pypy，一種即時(shí)編譯的Python)。Java擁有對線程的原生支持，而Python界大都回避了這些問題。規(guī)模龐大復(fù)雜又有很多死角的軟件更喜歡靜態(tài)類型提供的合理性檢查(比如mypy，一種Python靜態(tài)類型檢查器)。

也許某些 Java 并不擅長的領(lǐng)域剛好是 Python 的強(qiáng)項(xiàng)。例如大量的軟件對性能的要求并不高，也不需要并行執(zhí)行，我們只需要考慮具體實(shí)現(xiàn)業(yè)務(wù)的問題。我發(fā)現(xiàn)使用 Python 開始一個(gè)項(xiàng)目非常簡單而且快速。沒有單獨(dú)的編譯過程，編碼然后運(yùn)行的速度非?？?。代碼很簡短，這也意味著代碼更容易被理解。嘗試不同的架構(gòu)方法看起來更加容易。而且有時(shí)候嘗試一些愚蠢的想法是如此的有趣，就好像 使用庫實(shí)現(xiàn) goto 功能。

我希望你能試試 Python ，自從我用了它之后，已經(jīng)從中獲得很多樂趣，我相信你也一樣。至少不用刻意的去拒絕它。

最壞的情況，還有個(gè) Pyjnius 可以讓你這樣做：

1. from jnius import autoclass  
2. System = autoclass('java.lang.System') 
3. System.out.println('Hello, world!')  

作者：佚名

來源：51CTO