既然學習 Python，那麼至少得了解下這門語言，知道 Python 代碼執行過程吧。Python 的歷史有興趣的百度百科下就有，這個不多說了。
1、我們先來了解下什麼是解釋型語言和編譯型語言？（私信小編007獲取視頻教程以及PDF電子書籍！）
計算機是不能夠識別高級語言的，所以當我們運行一個高級語言程序的時候，就需要一個“翻譯機”來從事把高級語言轉變成計算機能讀懂的機器語言的過程。這個過程分成兩類，第一種是編譯，第二種是解釋。
編譯型語言在程序執行之前，先會通過編譯器對程序執行一個編譯的過程，把程序轉變成機器語言。運行時就不需要翻譯，而直接執行就可以了。最典型的例子就是 C 語言。
解釋型語言就沒有這個編譯的過程，而是在程序運行的時候，通過解釋器對程序逐行作出解釋，然後直接運行，最典型的例子是 Ruby。
通過以上的例子，我們可以來總結一下解釋型語言和編譯型語言的優缺點，因為編譯型語言在程序運行之前就已經對程序做出了“翻譯”，所以在運行時就少掉了“翻譯”的過程，所以效率比較高。但是我們也不能一概而論，一些解釋型語言也可以通過解釋器的優化來在對程序做出翻譯時對整個程序做出優化，從而在效率上超過編譯型語言。
此外，隨著 Java 等基於虛擬機的語言的興起，我們又不能把語言純粹地分成解釋型和編譯型這兩種。用 Java 來舉例，Java 首先是通過編譯器編譯成字節碼文件，然後在運行時通過解釋器給解釋成機器文件。所以我們說 Java 是一種先編譯後解釋的語言。再換成 C#，C# 首先是通過編譯器將 C# 文件編譯成 IL 文件，然後在通過 CLR 將 IL 文件編譯成機器文件。所以我們說 C# 是一門純編譯語言，但是 C# 是一門需要二次編譯的語言。同理也可等效運用到基於 .NET 平臺上的其他語言。
2、那麼 Python 到底是什麼？
其實 Python 和 Java、C# 一樣，也是一門基於虛擬機的語言，我們先來從表面上簡單地瞭解一下 Python 程序的運行過程。
當我們在命令行中輸入 python hello.py 時，其實是激活了 Python 的“解釋器”，告訴“解釋器”：你要開始工作了。可是在“解釋”之前，其實執行的第一項工作和 Java 一樣，是編譯。
熟悉 Java 的讀者可以想一下我們在命令行中如何執行一個 Java 的程序：
javac hello.java
java hello
只是我們在用 Eclipse 之類的 IDE 時，將這兩部給融合成了一部而已。其實 Python 也一樣，當我們執行 python hello.py 時，它也一樣執行了這麼一個過程，所以我們應該這樣來描述 Python，Python 是一門先編譯後解釋的語言。
3、簡述 Python 的運行過程
在說這個問題之前，我們先來說兩個概念，PyCodeObject 和 pyc 文件。
我們在硬盤上看到的 pyc 自然不必多說，而其實 PyCodeObject 則是 Python 編譯器真正編譯成的結果。我們先簡單知道就可以了，繼續向下看。
當 Python 程序運行時，編譯的結果則是保存在位於內存中的 PyCodeObject 中，當 Python 程序運行結束時，Python 解釋器則將 PyCodeObject 寫回到 pyc 文件中。
當 Python 程序第二次運行時，首先程序會在硬盤中尋找 pyc 文件，如果找到，則直接載入，否則就重複上面的過程。
所以我們應該這樣來定位 PyCodeObject 和 pyc 文件，我們說 pyc 文件其實是 PyCodeObject 的一種持久化保存方式。
最後：
- “人生苦短，我用Python”
- Python 的設計哲學是“優雅”、“明確”、“簡單”。
一、變量和字符串
首先：Python 每個語句結束可以不寫分號 ; ， 如 print('hello') 打印 hello
1.1 變量
有過編程基礎的話，變量就不用多說了。
變量的命名法：
- 駝峰式命名法
- 帕斯卡命名法
1.2 字符串
1、基本介紹
單引號 ' ' 或者雙引號 " " 都可以，再或者 ''' ''' 三個引號，其中三個引號被用於過於長段的文字或者是說明，只要是三引號不完你就可以隨意換行寫下文字。
①字符串直接能相加，如：
str1 = 'hi'
str2 = 'hello'
print(str1 + str2)
運行結果：
hi jaybo
②字符串相乘，如：
string = 'bang!'
total = string * 3
打印 total 結果：
bang!bang!bang!
2、字符串的分片與索引
字符串可以通過 string[x] 的方式進行索引、分片。
字符串的分片實際可以看作是從字符串中找出來你要截取的東西，複製出來一小段你要的長度，存儲在另一個地方，而不會對字符串這個源文件改動。分片獲得的每個字符串可以看作是原字符串的一個副本。
先看下面這段代碼：
name = 'My name is Mike'
print(name[0])
'M'
print(name[-4])
'M'
print(name[11:14]) # from 11th to 14th, 14th one is excluded
'Mik'
print(name[11:15]) # from 11th to 15th, 15th one is excluded
'Mike'
print(name[5:])
'me is Mike'
print(name[:5])
'My na'
如果感到困惑話，可以對照如下表格理解和分析：
: 兩邊分別代表著字符串的分割從哪裡開始，併到哪裡結束。
以 name[11:14] 為例，截取的編號從第11個字符開始，到位置為14但不包含第14個字符結束。而像 name[5:] 這樣的寫法代表著從編號為5的字符到結束的字符串分片。相反， name[:5] 則代表著從編號為0的字符開始到編號為5但包含第5個字符分片。可能容易搞混，可以想象成第一種是從5到最後面，程序員懶得數有多少個所以就省略地寫，第二種是從最前面到5，同樣懶得寫0，所以就寫成了 [:5] 。
3、字符串的方法
- replace 方法：第一個參數表示被替代部分，第二個參數表示替代成怎樣的字符串。
- 字符串填空，如：
4、問題
問題1：
num = 1
string = '1'
print(num + string)
上面代碼將出錯？
解釋：整數型不能和字符串直接相加。可以先把該字符串轉為整數型，再相加，即 int(string)
num = 1
string = '1'
print(num + int(string))
二、函數
舉些你可能已經使用過的函數例子：
判斷數據類型：type(str)
字符串類型數據轉為整數型：int(str)
...
通過觀察規律不難發現，Python 中所謂的使用函數就是把你要處理的對象放到一個名字後面的括號就可以了。簡單的來說，函數就是這麼使用，可以往裡面塞東西得到處理結果。這樣的函數在 Python 中還有這些：
以 Python3.5 版本為例，一個有 68 個這樣的函數，它們被稱為 內建函數 。這裡內建的是指這些函數為安裝好了 Python 就可以使用。
2.1 函數格式
定義函數的格式：
其中， def 和 return 為 關鍵字 。
注意：函數縮進後面的語句被稱為是語句塊，縮進是為了表名語句的邏輯與從屬關係。縮進這個問題不能忽視，否則會導致代碼無法成功運行，這裡需要特別注意。
2.2 函數參數
①位置參數，舉例，看代碼：
def trapezoid_area(base_up, base_down, height):
return 1/2 * (base_up + base_down) * height
接下來我們開始調用該函數：
trapezoid_area(1,2,3)
不難看出，填入的參數1，2，3分別對應著參數 base_up，base_down 和 height。這種傳入參數的方式被稱作為位置參數。
②關鍵詞參數：在函數調用的時候，將每個參數名稱後面賦予一個我們想要傳入的值，如調用 fun1 函數時候： fun1(a=1, b=2, c=3) 。
看下圖：
- 第一行的函數參數按照反序傳入，因為是關鍵詞參數，所以並不影響函數正常運作；
- 第二行的函數參數反序傳入，但是到了第三個卻變成了位置函數，遺憾的是這種方式是錯誤的語法，因為如果按照位置來傳入，最後一個應該是參數 height 的位置。但是前面 height 已經按照名稱傳入了值3，所以是衝突的。
- 第三行的函數參數正序傳入，前兩個是以關鍵字的方式傳入，最後一個以位置參數傳入，但是位置參數不能再關鍵詞參數後面，所以是錯誤的。
- 第四行的函數參數正序傳入，前兩個是以位置的方式傳入，最後一個以關鍵字參數傳入，這個函數是可以正常運行的。
③不定長參數
有時我們在設計函數接口的時候，可會需要可變長的參數。也就是說，我們事先無法確定傳入的參數個數。
Python 提供了一種元組的方式來接受沒有直接定義的參數。這種方式在參數前邊加星號 * 。如果在函數調用時沒有指定參數，它就是一個空元組。我們也可以不向函數傳遞未命名的變量。例如：
def print_user_info( name , age , sex = '男' , * hobby):
# 打印用戶信息
print('暱稱：{}'.format(name) , end = ' ')
print('年齡：{}'.format(age) , end = ' ')
print('性別：{}'.format(sex) ,end = ' ' )
print('愛好：{}'.format(hobby))
return;
# 調用 print_user_info 函數
print_user_info( '小明' , 25, '男', '打籃球','打羽毛球','跑步')
輸出的結果：
暱稱：小明 年齡：25 性別：男 愛好：('打籃球', '打羽毛球', '跑步')
通過輸出的結果可以知道， * hobby 是可變參數，且 hobby 其實就是一個 tuple （元祖）。
可變長參數也支持關鍵參數，沒有被定義的關鍵參數會被放到一個字典裡。這種方式即是在參數前邊加 ** ，更改上面的示例如下：
def print_user_info( name , age , sex = '男' , ** hobby ):
# 打印用戶信息
print('暱稱：{}'.format(name) , end = ' ')
print('年齡：{}'.format(age) , end = ' ')
print('性別：{}'.format(sex) ,end = ' ' )
print('愛好：{}'.format(hobby))
return;
# 調用 print_user_info 函數
print_user_info( name = '小明' , age = 25 , sex = '男', hobby = ('打籃球','打羽毛球','跑步'))
輸出的結果：
暱稱：小明 年齡：24 性別：男 愛好：{'hobby': ('打籃球', '打羽毛球', '跑步')}
通過對比上面的例子和這個例子，可以知道， * hobby 是可變參數，且 hobby 其實就是一個 tuple （元祖）， ** hobby 是關鍵字參數，且 hobby 就是一個 dict （字典）。
④ 只接受關鍵字參數
關鍵字參數使用起來簡單，不容易參數出錯，那麼有些時候，我們定義的函數希望某些參數強制使用關鍵字參數傳遞，這時候該怎麼辦呢？將強制關鍵字參數放到某個 * 參數或者單個 * 後面就能達到這種效果,比如：
def print_user_info( name , *, age, sex = '男' ):
# 打印用戶信息
print('暱稱：{}'.format(name) , end = ' ')
print('年齡：{}'.format(age) , end = ' ')
print('性別：{}'.format(sex))
return;
# 調用 print_user_info 函數
print_user_info( name = '小明' ,age = 25 , sex = '男' )
# 這種寫法會報錯，因為 age ，sex 這兩個參數強制使用關鍵字參數
#print_user_info( '小明' , 25 , '男' )
print_user_info('小明',age='22',sex='男')
通過例子可以看，如果 age , sex 不適用關鍵字參數是會報錯的。
2.3 匿名函數
有沒有想過定義一個很短的回調函數，但又不想用 def 的形式去寫一個那麼長的函數，那麼有沒有快捷方式呢？
——答案是有的。
Python 使用 lambda 來創建匿名函數，也就是不再使用 def 語句這樣標準的形式定義一個函數。
匿名函數主要有以下特點：
def
基本語法： lambda [arg1 [,arg2,.....argn]]:expression
示例：
sum = lambda num1 , num2 : num1 + num2;
print( sum( 1 , 2 ) )
輸出的結果： 3
注意：儘管 lambda 表達式允許你定義簡單函數，但是它的使用是有限制的。 你只能指定單個表達式，它的值就是最後的返回值。也就是說不能包含其他的語言特性了， 包括多個語句、條件表達式、迭代以及異常處理等等。
匿名函數中，有一個特別需要注意的問題，比如，把上面的例子改一下：
num2 = 100
sum1 = lambda num1 : num1 + num2 ;
num2 = 10000
sum2 = lambda num1 : num1 + num2 ;
print( sum1( 1 ) )
print( sum2( 1 ) )
你會認為輸出什麼呢？第一個輸出是 101，第二個是 10001，結果不是的，輸出的結果是這樣：
10001
10001
這主要在於 lambda 表達式中的 num2 是一個自由變量，在運行時綁定值，而不是定義時就綁定，這跟函數的默認值參數定義是不同的。所以建議還是遇到這種情況還是使用第一種解法。
三、循環與判斷
3.1 布爾表達式和判斷
Python 中的布爾類型值： True 和 Flase 其中，注意這兩個都是首字母大寫。
但凡能夠產生一個布爾值的表達式為 布爾表達式 ：
1 > 2 # False
1 < 2 <3 # True
42 != '42' # True
'Name' == 'name' # False
'M' in 'Magic' # True
number = 12
number is 12 # True
注1：不同類型的對象不能使用 < 、 > 、 <= 、 => 進行比較，卻可以使用 == 和 != 。
注2：浮點類型和整數類型雖然是不同類型，但不影響比較運算。還有，不等於 != 可以寫作 <> 。
話說，布爾類型可以比較嗎？如： True > Flase ，回答是可以的， Ture 和 Flase 對於計算機就像是 1 和 0 一樣，所以結果是真，即 True 。
3.2 條件控制
定義格式：
用一句話該結構作用：如果...條件是成立的，就做...；反之，就做...
所謂條件成立，指的是 返回值為 True 的布爾表達式。
3.3 循環
①for 循環
把 for 循環所的事情概括成一句話就是： 於...其中的每一個元素，做...事情。
打印九九乘法表：
for i in range(1, 10):
for j in range(1, i+1):
print('{}x{}={}\t'.format(i, j, i*j), end='')
print()
運行結果：
1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
4x1=4 4x2=8 4x3=12 4x4=16
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
②while 循環
總結：只要...條件一成立，就一直做...
在循環過程中，可以使用 break 跳過循環，使用 continue 跳過該次循環。
在 Python 的 while 循環中，可以使用 else 語句，while … else 在循環條件為 false 時執行 else 語句塊。如：
count = 0
while count < 3:
print (count)
count = count + 1
else:
print (count)
運行結果：
0
1
2
3
複製代碼
有 while … else 語句，當然也有 for … else 語句，for 中的語句和普通的沒有區別，else 中的語句會在循環正常執行完（即 for 不是通過 break 跳出而中斷的）的情況下執行，while … else 也是一樣。如：
for num in range(10,20): # 迭代 10 到 20 之間的數字
for i in range(2,num): # 根據因子迭代
if num%i == 0: # 確定第一個因子
j=num/i # 計算第二個因子
print ('%d 是一個合數' % num)
break # 跳出當前循環
else: # 循環的 else 部分
print ('%d 是一個質數' % num)
運行結果：
10 是一個合數
11 是一個質數
12 是一個合數
13 是一個質數
14 是一個合數
15 是一個合數
16 是一個合數
17 是一個質數
18 是一個合數
19 是一個質數
四、數據結構
Python 有四種數據結構，分別是：列表、字典、元組、集合。我們先從整體上認識一下這四種數據結構：
list = [val1,val2,val3,val4] #列表
dict = {key1:val1,key2:val2} #字典
tuple = (val1,val2,val3,val4) #元組
set = {val1,val2,val3,val4} #集合
4.1 列表（List）
- 列表中的每個元素都是可變的；
- 列表中的元素是有序的，也就是說每個元素都有一個位置；
- 列表中可以容納 Python 中的任何對象。如下：
all_in_list = [
1, #整數
1.0, #浮點數
'a word', #字符串
print(1), #函數
True, #布爾值
[1,2], #列表中套列表
(1,2), #元祖
{'key':'value'} #字典
]
另外，對於數據的操作，最常見的為增刪改查。在此就省略了，網上找下相應函數練習下即可。
4.2 字典（Dict）
- 字典中數據必須是以鍵值對的形式出現的；
- 邏輯上講，鍵是不能重複的；
- 字典中的鍵（key）是不可變的，也就是無法修改的，而值（value）是可變的，可修改的，可以是任何對象。
- 下面是個例子：
NASDAQ_code = {
'BIDU':'Baidu',
'SINA':'Sina',
'YOKU':'Youku'
}
一個字典中鍵與值並不能脫離對方而存在，如果你寫成了 {'BIDU':} 會引發一個語法錯誤： invalid syntax 。
如果試著將一個可變（mutable）的元素作為 key 來構建字典，比如列表： key_test = {[]:'a Test'} ，則會報一個錯： unhashable type:'list' 。
同時字典中的鍵值不會重複，即便你這麼做，相同的鍵值也只能出現一次： a = {'key':123,'key':123} 。
增刪改查操作，在此省略了。
備註：
- 列表中用來添加多個元素的方法為 extend ，在字典中添加多個元素的方法為 update()
- 字典是不能切片的，即這樣的寫法是錯誤的： chart[1:4]
4.3 元組（Tuple）
元組可以理解為一個穩固版的列表，因為元組是不可以修改的，因此在列表中的存在的方法均不可以使用在元組上，但是元組是可以被查看索引的，方式和列表一樣。
letters = ('a, 'b', 'c', 'd')
letters[0]
相關的操作找代碼練習下即可。
4.4 集合（Set）
集合則更接近數學上集合的概念。每一個集合中是的元素是無序的、不重複的任意對象，我們可以通過集合去判斷數據的從屬關係，有時還可以通過集合把數據結構中重複的元素減掉。
集合不能被切片也不能被索引，除了做集合運算之外，集合元素可以被添加還有刪除：
a_set = {1,2,3,4}
a_set.add(5)
a_set.discard(5)
4.5 數據結構的一些技巧
4.5.1 多重循環
如下：
代碼演示：
for a, b in zip(num, str):
print(b, 'is', a)
4.5.2 推導式
列表推導式的用法很好理解，可以簡單地看成兩部分。如下圖：
紅色虛線後面的是我們熟悉的 for 循環的表達式，而虛線前面的可以認為是我們想要放在列表中的元素。
代碼演示：
a = []
for i in range(1, 11):
a.append(i)
可以換成列表解析的方式來寫：
b = [i for in i range(1, 11)]
列表解析式不僅方便，並且在執行效率上要遠遠勝過前者。
五、類的理解
5.1 類的介紹
類的定義：
class CocaCola:
formula = ['caffeine','sugar','water','soda']
使用 class 來定義一個類，就如同創建函數時使用的 def 定義一個函數一樣簡單。如上你可以看到定義了名為 CocaCola 的類，接著在縮進的地方有一個裝載著列表的變量的 formula ，這個在類裡面定義的變量就是類的變量，而類的變量有一個專有的術語，我們稱之為類的屬性。
類的屬性：
- 類變量
- 方法
①類的實例化：
coke_for_me = CocaCola()
coke_for_you = CocaCola()
複製代碼
②類變量屬性的引用： CocaCola.formula 、 coke_for_me.formula
類方法的使用：
class CocaCola:
formula = ['caffeine','sugar','water','soda']
def drink(self):
print('Energy!')
coke = CocaCola()
coke.drink()
結果：
Energy!
5.2 self
我想很多人會有關注到這個奇怪的地方——似乎沒有派上任何用場的 self 參數。我們來說明下原理，其實很簡單，我們修改下上面的代碼：
class CocaCola:
formula = ['caffeine','sugar','water','soda']
def drink(coke): # 把self改為coke
print('Energy!')
coke = CocaCola()
coke.drink()
結果：
Energy!
怎麼樣，有些頭緒了吧！這個參數其實就是被創建的實例本身。也就是將一個個對象作為參數放入函數括號內，再進一步說，一旦一個類被實例化，那麼我們其實可以使用和與我們使用函數相似的方式：
coke = CocaCola
coke.drink() == CocaCola.drink(coke) #左右兩邊的寫法完全一致
被實例化的對象會被編譯器默默地傳入後面方法的括號中，作為第一個參數。上面兩個方法是一樣的，但我們更多地會寫成前面那種形式。其實 self 這個參數名稱是可以隨意修改的（編譯器並不會因此而報錯）。
和函數一樣，類的方法也能有屬於自己的參數，如下：
class CocaCola:
formula = ['caffeine','sugar','water','soda']
def drink(self,how_much):
if how_much == 'a sip':
print('Cool~')
elif how_much == 'whole bottle’:
print('Headache!')
ice_coke = CocaCola()
結果：
Cool~
5.3 魔術方法
Python 的類中存在一些方法，被稱為「魔術方法」， _init_() 就是其中之一。
class CocaCola():
formula = ['caffeine','sugar','water','soda']
def __init__(self):
self.local_logo = '可口可樂'
def drink(self):
print('Energy!')
coke = CocaCola()
print(coke.local_logo)
作用：在創建實例之前，它做了很多事情。說直白點，意味著即使你在創建實例的時候不去引用 init_() 方法，其中的語句也會先被自動的執行。這給類的使用提供了極大的靈活性。
class CocaCola:
formula = ['caffeine','sugar','water','soda']
def __init__(self,logo_name):
self.local_logo = logo_name
def drink(self):
print('Energy!')
coke = CocaCola('ݢݗݢԔ')
coke.local_logo
>>> 可口可樂
有過面向對象編程經驗很好理解了，也就是很多面向對象語言中的「構造函數」。
5.4 類的繼承
如下代碼：
class CaffeineFree(CocaCola):
caffeine = 0
ingredients = [
'High Fructose Corn Syrup',
'Carbonated Water',
'Phosphoric Acid',
'Natural Flavors',
'Caramel Color',
]
coke_a = CaffeineFree('Cocacola-FREE')
coke_a.drink()
表示 CaffeineFree 繼承了 CocaCola 類。
類中的變量和方法可以被子類繼承，但如需有特殊的改動也可以進行 覆蓋。
Q1： 類屬性 如果被重新賦值，是否會影響到類屬性的引用？
class TestA():
attr = 1
obj_a = TestA()
TestA.attr = 24
print(obj_a.attr)
>>> 結果：24
A1：會影響。
Q2： 實例屬性 如果被重新賦值，是否會影響到類屬性的引用？
class TestA:
attr = 1
obj_a = TestA()
obj_b = TestA()
obj_a.attr = 42
print(obj_b.attr)
>>> 結果：1
A2：不會影響。
Q3：類屬性實例屬性具有相同的名稱，那麼 . 後面引用的將會是什麼？
class TestA():
attr =1
def __init__(self):
self.attr = 24
obj_a = TestA()
print(obj_a.attr)
>>> 結果：24
A3：類屬性賦值後的值。
總結：如圖所示，Python 中屬性的引用機制是自外而內的，當你創建了一個實例之後，準備開始引用屬性，這時候編譯器會先搜索該實例是否擁有該屬性，如果有，則引用；如果沒有，將搜索這個實例所屬的類是否有這個屬性，如果有，則引用，沒有那就只能報錯了。
六、使用第三方庫
6.1 安裝自己的庫
我們一般使用 pip 來進行第三方庫的安裝，那麼自己的庫要怎麼安裝呢？當然可以把自己的庫提交到 pip 上，但是還要添加一定量的代碼和必要的文件才行，在這裡我們使用一個更簡單的方法：
site-packages
這個文件夾應該有你所安裝的所有第三方庫。如果你並不清楚你的安裝路徑，可以嘗試使用如下方式搞清楚它究竟在哪裡：
import sys
print(sys.path)
打印出來的會是一個列表，列表中的第四個將是你的庫安裝路徑所在，因此你也可以直接這麼做：
import sys
print(sys.path[3])
6.2 安裝第三方庫
令人驚歎的第三方庫
如果用手機來比喻編程語言，那麼 Python 是一款智能機。正如含量的手機應用出現在 iOS、Android 平臺上，同樣有各種各樣的第三方庫為 Python 開發者提供了極大的便利。
當你想要搭建網站時，可以選擇功能全面的 Django、輕量的 Flask 等 web 框架；當你想寫一個小遊戲的時候，可以使用 PyGame 框架；當你想做一個 爬蟲時，可以使用 Scrapy 框架；當你想做數據統計分析時，可以使用 Pandas 數據框架......這麼多豐富的資源可以幫助我們高效快捷地做到想做的事，就不需要再重複造輪子了。
那麼如何根據自己的需求找到相應的庫呢？可以到awesome-python.com 這個網站上按照分類去尋找，上面收錄了比較全的第三方庫。比如想要找爬出方面的庫時，查看 Web Crawling 這個分類，就能看到相應的第三方庫的網站與簡介，可以進入庫的網站查看更詳細的介紹，並確認這個庫支持的是 Python 2 還是 Python 3，不過絕大多數常用庫已經都支持了這兩者。另外，你也可以直接通過搜索引擎尋找。
安裝第三方庫方式：
①最簡單的方式：在 PyCharm 中安裝
- 在 PyCharm 的菜單中選擇：File --> Default Setting
- 搜索 project interpreter，選擇當前 python 版本，點擊“+”添加庫
- 輸入庫的名稱，勾選，並點擊 Install Package
在安裝成功後， PyCharm 會有成功提示。也可以在 project interpreter 這個界面中查看安裝了哪些庫，點“-”號就可以卸載不再需要的庫。
②最直接的方式：在終端/命令行中安裝
PyPI（Python Package Index）是 Python 官方的第三方庫的倉庫，PyPI 推薦使用 pip 包管理器來下載第三方庫。
- 安裝 pip
- 在 Python 3.4 之後，安裝好 Python 環境就可以直接支持 pip，你可以在終端/命令行裡輸入這句檢查一下： pip --version （前提電腦 path 路徑已經配置好了），如果顯示 pip 版本，就說明 pip 已經成功安裝了；如果發現沒有安裝，則根據不同系統如下方式安裝
使用 pip 安裝庫
在安裝好了 pip 之後，以後安裝庫，只需要在命令行裡面輸入： pip3 install PackageName（注：如果你想要安裝到 Python 2 中，需要把 pip3 換成 pip ）。
- 如果你安裝了 Python 2 和 3 兩種版本，可能會遇到安裝目錄的問題，可以換成： python3 -m pip install PackageName （注：如果你想安裝到 Python2 中，需要把 Python3 換成 Python）
- 如果遇到權限問題，可以輸入： sudo pip install PackageName
- 安裝成功之後會提示： Successfully insyalled PackageName
- 一些常用的 pip 指令：
# pip 使用格式：pip[options] package_name
pip install package_name==1.9.2 # 安裝指定版本的包
pip install --upgrade package_name # 更新指定的包
pip uninstall package_name # 卸載指定的包
pip show package_name # 查看所安裝包的詳細信息
pip list # 查看所有安裝的包
pip --help # 查看幫助
複製代碼
補充：如果下載很慢，可以考慮更改 pip 下載源。
更改方法：
- Linux下永久生效的配置方法
- Windows 下永久生效的配置方法
③最原始的方式：手動安裝
進入pypi.python.org，搜索你要安裝的庫的名字，這時候有 3 種可能：
- 第一種是 exe 文件，這種最方便，下載滿足你的電腦系統和 Python 環境的對應的 exe ，再一路點擊 next 就可以安裝。
- 第二種是 .whl 類文件，好處在於可以自動安裝依賴的包。
- 到命令行輸入 pip3 install whell 等待執行完成，不能報錯（Python 2 中要換成 pip）
- 從資源管理器中確認你下載的 .whl 類文件的路徑，然後在命令行繼續輸入： cd C:\download ，此處需要改為你的路徑，路徑的含義是文件所在的文件夾，不包含這個文件名字本身，然後再命令行繼續輸入： pip3 install xxx.whl ， xxx.whl 是你下載的文件的完整文件名。
- 第三種是源碼，大概都是 zip 、 tar.zip 、 tar.bz2 格式的壓縮包，這個方法要求用戶已經安裝了這個包所依賴的其他包。例如 pandas 依賴於 numpy，你如果不安裝 numpy，這個方法是無法成功安裝 pandas 的。
- 解壓包，進入解壓好的文件夾，通常會看見一個 setup.py 的文件，從資源管理器中確認你下載的文件的路徑，打開命令行，輸入： cd C:\download 此處需要改為你的路徑，路徑的含義是文件所在的文件夾，不包含這個文件名字本身
- 然後在命令行中繼續輸入： python3 setup.py install 這個命令，就能把這個第三方庫安裝到系統裡，也就是你的 Python路徑，windows 大概是在 C:\Python3.5\Lib\site-packages 。
- 注：想要卸庫的時候，找到 Python 路徑，進入 site-packages 文件夾，在裡面刪掉庫文件就可以了。
閱讀更多 編程夢工廠 的文章
