為什么推薦學Python

這篇文章將為大家詳細講解有關為什么推薦學Python，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

習慣了靜態語言，當年覺得C++就是不二選擇了。我的觀點也一直很明確：作為一位專業的程序員，第一門應該精通的語言是C，接著應該掌握匯編語言，之后再學什么語言都可以融會貫通。

然而自從接觸了JavaScript這種動態語言，才猛然發現靜態語言的不足，并轉向這個更為美麗的陣營。

動態語言有這幾種：JavaScript、Python、Ruby和Lua，而Python則是唯一推薦的。

這并不是說其他的語言不好，而是說如果你只想學一門語言，那么Python就是最好的選擇。

首先看下比較泛泛而談的方面：

快速上手。Python的書籍非常多，文檔也很詳細，大多數模塊都配有例子。我不知道初學編程的人要多久才能掌握Python，但我只用了半天就掌握了大部分Python的語法。你完全可以在等公交或擠地鐵時學會Python。

用途廣泛。如果不考慮性能，你幾乎可以用Python做任何事，包括系統編程、數據庫、應用軟件、游戲、WEB應用等等。

平臺無關。從嵌入式設備到幾十年前的大型機上你都能找到Python，它支持的平臺甚至多于Java。

模塊眾多。無論你是想操作數據庫，還是想進行音樂、圖像處理，或者處理文字編碼解碼，Python都在標準庫里為你提供了。而且不但標準庫不遜于Java，就連第三方庫的數量也沒有哪門語言可以比得上，并且這些庫大多是開源和免費的。

使用方便，無需編譯。打開命令行，敲入Python就能在控制臺直接執行Python語句了。用文本編輯器編輯一個.py文件，編寫完雙擊它就能運行了。在構建較大的應用時會節約很多時間，即便是Java這種語言，在打個par或war包時，仍然需要幾分鐘的編譯和構建時間。

代碼簡短，容易閱讀。由于內置了眾多實用的類型，合理的操作符重載，以及各種語法特性和庫的支持，實現同樣的事，Python幾乎總比絕大部分語言少寫很多代碼。

面向對象。如今大多數語言都已在語法層面上支持面向對象了，所以這或許算不上什么。只是想和Ruby擁護者強調一下，Python同樣也是純面向對象的語言。Python里所有你能看到的東西，全都是對象，包括1、2、3這種字面量，甚至代碼和棧幀。至于Python里有函數，所以不是純面向對象的這種說法也是站不住腳的：因為函數也是對象，一個函數調用就是將0到多個對象傳遞給函數對象的__call__方法的過程，難道非得加個小數點才叫面向對象？

接著看看一些值得一提的特性：

支持長整數類型，長度只受限于虛擬內存的大小。

例如123的321次方：

>>> 123 ** 321
72367033806371673149109894141163778628811792657571658906010558390395870363798401
74409528068615550773640492165707028496172182896059297790954263709889769722310262
26285667876540913278254539915951402057014129613641887324089361978905536997158369
51569999800431957769217006743321026257517932764164662319487914962533302741368207
21118949461532655279066772041128547416263676516890721192413497337430449601963537
66658585599417357039248364677569172479954695834874677915245821537445221075978652
77798136080074161485280424274076931083994487111719562249702540362855712911132265
96623575435535351670333904300150611852076035957773786947201861794212059087317071
0805078696371738906375721785723L

支持連續比較。

>>> 10 > 5 > 3
True
>>> 10 < 15 > 3
True
>>> 10 > 2 < 3
True

快速生成列表。

例如0～100之間所有的奇數：

>>> range(1, 100, 2)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41,
43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81,
83, 85, 87, 89, 91, 93, 95, 97, 99]

列表支持切片操作。

>>> x = range(20, 0, -1)
>>> x
[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> x[8:] # 生成x的第8到最后一個元素的列表
[12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> x[:8] # 生成x的第0到第8個（不包含第8）元素的列表
[20, 19, 18, 17, 16, 15, 14, 13]
>>> x[:-8] # 生成x的第0到倒數第8個元素的列表
[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9]
>>> x[8:-8] # 生成x的第8到倒數第8個元素的列表
[12, 11, 10, 9]
>>> x[::2] # 從x中每隔1個數生成的列表
[20, 18, 16, 14, 12, 10, 8, 6, 4, 2]
>>> x[8:-8:2] # x的第8到倒數第8個元素中，每隔1個數生成的列表
[12, 10]

元組可以自動打包和解包。

>>> a, b = 1, 2
>>> a
1
>>> b
2
>>> a, b = b, a
>>> a
2
>>> b
1
>>> def f():
...   return 3, 4 # 函數可以返回多個值，實際上也是元組
...
>>> a, b = f()
>>> a
3
>>> b
4
>>> a = f()
>>> a
(3, 4)

強大的for循環讓大多數情況下無需處理循環索引。

例如計算0～100的奇數和：

>>> s = 0
>>> for i in range(1, 100, 2):
...   s += i # 每次迭代，i都會被賦予下一個值
...
>>> s
2500

還可以同時獲得多個迭代值：

>>> x = (((1, 2), 3),)
>>> x *= 5
>>> x
(((1, 2), 3), ((1, 2), 3), ((1, 2), 3), ((1, 2), 3), ((1, 2), 3))
>>> for (i, j), k in x:
...   s += (i + j + k)
...
>>> s
30

可用zip函數同時迭代2個列表。

>>> a = range(5)
>>> b = range(5, 10)
>>> zip(a, b)
[(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]
>>> for x, y in zip(a, b):
...   print x + y,
...
5 7 9 11 13

支持lambda函數。（不過不如Lisp的簡潔，也沒有JavaScript的匿名函數強大，更不如Ruby的block優雅）

>>> f = lambda x: 2 * x
>>> f(3)
6
>>> (lambda x: 2 * x)(3)
6
>>> map(lambda x: 2 * x, range(10))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> filter(lambda x: x % 2, range(10))
[1, 3, 5, 7, 9]
>>> reduce(lambda x, y: x * y, range(1, 10))
362880

列表解析可以省略很多for循環、map和filter函數。

>>> [str(i) for i in range(10)]
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> [i * i for i in range(20) if i % 2 and i % 3 ]
[1, 25, 49, 121, 169, 289, 361]
>>> [i * j for i in range(5) for j in range(5, 10)]
[0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 15, 18, 21, 24, 27, 20, 24, 2
8, 32, 36]
>>> [i * j for i in range(5) for j in range(5) if i > j]
[0, 0, 2, 0, 3, 6, 0, 4, 8, 12]

支持缺省參數，且缺省參數位置隨意。

>>> def f(a, b=1, c=2):
...   return a + b + c
...
>>> f(1)
4
>>> f(1, 2)
5
>>> f(1, c=5)
7
>>> f(1, c=5, b=9)
15
>>> f(c=5, a=8, b=9)
22

支持參數列表和參數字典。

>>> def f(a, b=1, c=2):...   return a + b + c...>>> args = [9, 8, 7]>>> f(*args)
24
>>> kwargs = zip(['a', 'b', 'c'], args)
>>> kwargs
[('a', 9), ('b', 8), ('c', 7)]
>>> kwargs = dict(kwargs)
>>> kwargs
{'a': 9, 'c': 7, 'b': 8}
>>> f(**kwargs)
24
>>> f(9, *[8], **{'c': 7})
24
>>> a = (0, 1, 2, 3, 4)
>>> b = (5, 6, 7, 8, 9)
>>> zip(a, b)
[(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]
>>> zip(*zip(a, b))
[(0, 1, 2, 3, 4), (5, 6, 7, 8, 9)]
>>> c, d = zip(*zip(a, b))
>>> c # 等于a
(0, 1, 2, 3, 4)
>>> d # 等于b
(5, 6, 7, 8, 9)

支持閉包和高階函數。

>>> def f(x):
...   return  x + 1
...
>>> def g(func):
...   def wrap(x):
...     return func(x) * 2
...   return wrap
...
>>> h = g(f)
>>> h(2)
6
>>> @g
... def a(x):
...   return x + 1
...
>>> a(2)
6

對象的屬性和方法可以動態改變：

>>> class A(object):
...   def __init__(self, x):
...     self.x = x
...
>>> a = A(10)
>>> a.x
10
>>> a.y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'y'
>>> a.y = 5
>>> a.y
5
>>> del a.x
>>> a.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'x'
>>> def f(self):
...   return 10
...
>>> A.x = f
>>> a.x()
10

對象的類型可以動態改變。

>>> class A(object):
...   def __init__(self, x):
...     self.x = x
...   def y(self):
...     return self.x * 2
...
>>> class B(object):
...   def __init__(self, x):
...     self.x = x
...   def y(self):
...     return self.x / 2
...
>>> x = A(10)
>>> x.y()
20
>>> x.__class__ = B
>>> x.y()
5

其他雖然還有很多優點，為了公平起見，把部分缺點也列出。

性能不出色。比起靜態語言要差很多，但是在動態語言里表現尚可，至少不遜色于Ruby和PHP。

要追求性能，就不得不以C來重寫這些實現；但好在絕大部分Python程序員不需要做這種事，也有較為方便的工具可以將Python（的一個變種）轉換成C實現，并編譯成機器語言。

不支持switch...case結構，只能以傳統的if...elif...else來實現。

不過Ruby雖說支持switch...case，但我估計內部實現也是if...elif...else（未考證）。

沒有抽象類和接口，對象靠實現特殊的屬性和方法來實現一個接口，但書寫很麻煩（前后2個下劃線）。

私有屬性不是真正的私有（可以通過特殊的辦法訪問），且沒有保護和包訪問方式。

實例方法不能省略第一個self參數，內部也得使用“self.屬性名”的方式來訪問屬性。

這主要是因為Python的方法實現很奇特，實例方法、類方法和靜態方法是用相同的機制實現的，這在部分情況下提供了便利。

不支持多行注釋。只能靠編輯器來幫忙了。

內部函數不能改變外部函數的命名空間，包括賦值和刪除。Python 2.x只能將其提升為global變量來解決，而Python 3.x者可以使用nonlocal。

Python 3.x與Python 2.x不兼容，而大部分的庫只支持Python 2.x，會導致初學者不知道該學哪個版本。

關于為什么推薦學Python就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。