Python 面試中可能會被問到的30個問題

第一家公司問的題目

1 簡述解釋型和編譯型編程語言？

解釋型語言編寫的程序不須要編譯，在執行的時候，專門有一個解釋器可以將VB語言翻譯成機器語言，每一個語句都是執行的時候才翻譯。這樣解釋型語言每執行一次就要翻譯一次，效率比較低。

用編譯型語言寫的程序執行以前，須要一個專門的編譯過程，經過編譯系統，把源高級程序編譯成爲機器語言文件，翻譯只作了一次，運行時不須要翻譯，因此編譯型語言的程序執行效率高，但也不能一律而論，

部分解釋型語言的解釋器經過在運行時動態優化代碼，甚至可以使解釋型語言的性能超過編譯型語言。

2 Python解釋器種類以及特色？

CPython

當 從Python官方網站下載並安裝好Python2.7後，就直接得到了一個官方版本的解釋器：Cpython，這個解釋器是用C語言開發的，因此叫 CPython，在命名行下運行python，就是啓動CPython解釋器，CPython是使用最廣的Python解釋器。

IPython

IPython是基於CPython之上的一個交互式解釋器，也就是說，IPython只是在交互方式上有所加強，可是執行Python代碼的功能和CPython是徹底同樣的，比如不少國產瀏覽器雖然外觀不一樣，但內核實際上是調用了IE。

PyPy

PyPy是另外一個Python解釋器，它的目標是執行速度，PyPy採用JIT技術，對Python代碼進行動態編譯，因此能夠顯著提升Python代碼的執行速度。

Jython

Jython是運行在Java平臺上的Python解釋器，能夠直接把Python代碼編譯成Java字節碼執行。

IronPython

IronPython和Jython相似，只不過IronPython是運行在微軟.Net平臺上的Python解釋器，能夠直接把Python代碼編譯成.Net的字節碼。

在Python的解釋器中，使用普遍的是CPython，對於Python的編譯，除了能夠採用以上解釋器進行編譯外，技術高超的開發者還能夠按照本身的需求自行編寫Python解釋器來執行Python代碼，十分的方便！

3 位和字節的關係？

bit就是位，也叫比特位，是計算機表示數據最小的單位

byte就是字節

1byte=8bit

1byte就是1B

一個字符=2字節

1KB=1024B

字節就是Byte，也是B

位就是bit也是b

轉換關係以下：1)1KB=1024B

1B= 8b

4 請至少列舉5個 PEP8 規範（越多越好）。

PEP8 編碼規範
a.不要在行尾加分號, 也不要用分號將兩條命令放在同一行。

b.每行不超過80個字符（長的導入模塊語句和註釋裏的URL除外）

c.不要使用反斜槓鏈接行。Python會將圓括號, 中括號和花括號中的行隱式的鏈接起來

d.寧缺毋濫的使用括號，除非是用於實現行鏈接, 不然不要在返回語句或條件語句中使用括號. 不過在元組兩邊使用括號是能夠的.

e.用4個空格來縮進代碼，不要用tab, 也不要tab和空格混用. 對於行鏈接的狀況, 你應該要麼垂直對齊換行的元素,或者使用4空格的懸掛式縮進

f.頂級定義之間空2行, 方法定義之間空1行，頂級定義之間空兩行, 好比函數或者類定義. 方法定義, 類定義與第一個方法之間, 都應該空一行. 函數或方法中, 某些地方要是你以爲合適, 就空一行.

5 經過代碼實現以下轉換：

二進制轉換成十進制：v = 「0b1111011」

先將其轉換爲字符串，再使用int函數，指定進制轉換爲十進制。

print(int("0b1111011",2))
值爲123

十進制轉換成二進制：v = 18

print("轉換爲二進制爲：", bin(18))

轉換爲二進制爲： 0b10010

八進制轉換成十進制：v = 「011」

print(int("011",8))

9

十進制轉換成八進制：v = 30

print("轉換爲八進制爲：", oct(30))

轉換爲八進制爲： 0o36

十六進制轉換成十進制：v = 「0x12」

print(int("0x12",16))

18

十進制轉換成十六進制：v = 87

print("轉換爲十六進制爲：", hex(87))
轉換爲十六進制爲： 0x57

6 python遞歸的最大層數？

def fab(n):
if n == 1:
return 1
else:
return fab(n-1)+ n
print (fab(998))

獲得的最大數爲998，之後就是報錯了，998這個數值莫名想起廣告詞····

import sys
sys.setrecursionlimit(100000)
def foo(n):
print(n)
n += 1
foo(n)
if name == 'main':
foo(1)

獲得的最大數字在3922-3929之間浮動，這個是和計算機有關係的，將數字調到足夠大了，已經大於系統堆棧，python已經沒法支撐到太大的遞歸崩了。

7 ascii、unicode、utf-八、gbk 區別？

最先只有127個字母被編碼到計算機裏，也就是大小寫英文字母、數字和一些符號，這個編碼表被稱爲ASCII編碼，好比大寫字母A的編碼是65，小寫字母z的編碼是122。

可是要處理中文顯然一個字節是不夠的，至少須要兩個字節，並且還不能和ASCII編碼衝突，因此，中國製定了GB2312編碼，用來把中文編進去。

你能夠想獲得的是，全世界有上百種語言，日本把日文編到Shift_JIS裏，韓國把韓文編到Euc-kr裏，各國有各國的標準，就會不可避免地出現衝突，結果就是，在多語言混合的文本中，顯示出來會有亂碼。

所以，Unicode應運而生。Unicode把全部語言都統一到一套編碼裏，這樣就不會再有亂碼問題了。

Unicode標準也在不斷髮展，但最經常使用的是用兩個字節表示一個字符（若是要用到很是偏僻的字符，就須要4個字節）。現代操做系統和大多數編程語言都直接支持Unicode。

新的問題又出現了：若是統一成Unicode編碼，亂碼問題今後消失了。可是，若是你寫的文本基本上所有是英文的話，用Unicode編碼比ASCII編碼須要多一倍的存儲空間，在存儲和傳輸上就十分不划算。

因此，本着節約的精神，又出現了把Unicode編碼轉化爲「可變長編碼」的UTF-8編碼。UTF-8編碼把一個Unicode字符根據不一樣的數字大小編碼成1-6個字節，經常使用的英文字母被編碼成1個字節，漢字一般是3個字節，只有很生僻的字符纔會被編碼成4-6個字節。若是你要傳輸的文本包含大量英文字符，用UTF-8編碼就能節省空間。

UTF-8編碼有一個額外的好處，就是ASCII編碼實際上能夠被當作是UTF-8編碼的一部分，因此，大量只支持ASCII編碼的歷史遺留軟件能夠在UTF-8編碼下繼續工做。

8 字節碼和機器碼的區別？

機器碼(machine code)，學名機器語言指令，有時也被稱爲原生碼（Native Code），是電腦的CPU可直接解讀的數據。

一般意義上來理解的話，機器碼就是計算機能夠直接執行，而且執行速度最快的代碼。

用機器語言編寫程序，編程人員要首先熟記所用計算機的所有指令代碼和代碼的涵義。手編程序時，程序員得本身處理每條指令和每一數據的存儲分配和輸入輸出，還得記住編程過程當中每步所使用的工做單元處在何種狀態。這是一件十分繁瑣的工做，編寫程序花費的時間每每是實際運行時間的幾十倍或幾百倍。並且，編出的程序全是些0和1的指令代碼，直觀性差，還容易出錯。如今，除了計算機生產廠家的專業人員外，絕大多數的程序員已經再也不去學習機器語言了。

機器語言是微處理器理解和使用的，用於控制它的操做二進制代碼。

8086到Pentium的機器語言指令長度能夠從1字節到13字節。

儘管機器語言好像是很複雜的，然而它是有規律的。

存在着多至100000種機器語言的指令。這意味着不能把這些種類所有列出來。

總結：機器碼是電腦CPU直接讀取運行的機器指令，運行速度最快，可是很是晦澀難懂，也比較難編寫，通常從業人員接觸不到。

字節碼（Bytecode）是一種包含執行程序、由一序列 op 代碼/數據對 組成的二進制文件。字節碼是一種中間碼，它比機器碼更抽象，須要直譯器轉譯後才能成爲機器碼的中間代碼。

一般狀況下它是已經通過編譯，但與特定機器碼無關。字節碼一般不像源碼同樣可讓人閱讀，而是編碼後的數值常量、引用、指令等構成的序列。

字節碼主要爲了實現特定軟件運行和軟件環境、與硬件環境無關。字節碼的實現方式是經過編譯器和虛擬機器。編譯器將源碼編譯成字節碼，特定平臺上的虛擬機器將字節碼轉譯爲能夠直接執行的指令。字節碼的典型應用爲Java bytecode。

字節碼在運行時經過JVM（JAVA虛擬機）作一次轉換生成機器指令，所以可以更好的跨平臺運行。

總結：字節碼是一種中間狀態（中間碼）的二進制代碼（文件）。須要直譯器轉譯後才能成爲機器碼。

9 三元運算規則以及應用場景？

表達式格式
爲真時的結果 if 斷定條件 else 爲假時的結果

事例
1 if 3>2 else 0

10 用一行代碼實現數值交換：

a =1
b =2
a,b=b,a
print(a,b)

第二家公司問的題目

1 Python3和Python2中 int 和 long的區別？

Python 2有爲非浮點數準備的int和long類型。int類型的最大值不能超過sys.maxint，並且這個最大值是平臺相關的。能夠經過在數字的末尾附上一個L來定義長整型，顯然，它比int類型表示的數字範圍更大。在Python 3裏，只有一種整數類型int，大多數狀況下，它很像Python 2裏的長整型。因爲已經不存在兩種類型的整數，因此就沒有必要使用特殊的語法去區別他們。

2 文件操做時：xreadlines和readlines的區別？

read(size)

讀入指定大小的內容，以byte爲單位，size爲讀入的字符數，返回str類型

readline()

readline()讀取一行內容，放到一個字符串變量，返回str類型。

readlines()

readlines() 讀取文件全部內容，按行爲單位放到一個列表中，返回list類型。

xreadlines()

返回一個生成器，來循環操做文件的每一行。循環使用時和readlines基本同樣，可是直接打印就不一樣

3列舉布爾值爲False的常見值？

下面的值在做爲布爾表達式的時候，會被解釋器看做假（false）

False None 0 "" () [] {}

換句話說，也就是標準值False和None，全部類型的數字0（包括浮點型，長整型和其餘類型），空序列（好比空字符串、元組和列表）以及空的字典都爲假。其餘的一切都被解釋爲真，包括特殊值True.

也就是說Python中的全部值都能被解釋爲真值。」標準的「布爾值爲True和False。事實上，True和False只不過是1和0的一種「華麗」的說法而已----看起來不一樣，可是做用相同。

4 lambda表達式格式以及應用場景？

對於簡單的函數，也存在一種簡便的表示方式，即：lambda表達式

普通函數

def func(a):
return a+1
print 'test1_func0:',func(1000)

lambda表達式

func0 = lambda a:a+1
print 'test2_func0:',func0(1000)

上面這種方法，都實現了將1000+1的結果打印出來這個功能，可是用下面

lambda存在乎義就是對簡單函數的簡潔表示。

說道lambda，這裏再贈送一些能夠給lambda加buff小夥伴：

map函數

咱們使用map函數將會對列表中的全部元素進行操做。map有兩個參數（函數，列表），它會在內部遍歷列表中的每個元素，執行傳遞過來的函數參數。在輸出到新列表中。

li = [11, 22, 33]
new_list = map(lambda a: a + 100, li)
輸出：[111, 122, 133]

reduce函數

對於序列內全部元素進行累計操做：

lst = [11,22,33]
func2 = reduce(lambda arg1,arg2:arg1+arg2,lst)
print 'func2:',func2
輸出：func2: 66

filter函數

他能夠根據條件對數據進行過濾：

li = [11, 22, 33]
new_list = filter(lambda arg: arg > 22, li)
print new_list
輸出：[33]

divmod()

函數把除數和餘數運算結果結合起來，返回一個包含商和餘數的元組(a // b, a % b)。

divmod(7, 2)
(3, 1)
divmod(8, 2)
(4, 0)

zip() 函數

用於將可迭代的對象做爲參數，將對象中對應的元素打包成一個個元組，而後返回由這些元組組成的列表。

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b) # 打包爲元組的列表
[(1, 4), (2, 5), (3, 6)]
zip(a,c) # 元素個數與最短的列表一致
[(1, 4), (2, 5), (3, 6)]
zip(zipped) # 與 zip 相反，zipped 可理解爲解壓，返回二維矩陣式
[(1, 2, 3), (4, 5, 6)]

5 *arg和**kwarg做用

首先咱們能夠定一個簡單的函數, 函數內部只考慮required_arg這一個形參(位置參數)

def exmaple(required_arg):
print required_arg
exmaple("Hello, World!")

Hello, World!

那麼，若是咱們調用函數式傳入了不止一個位置參數會出現什麼狀況？固然是會報錯！

*arg和**kwarg 能夠幫助咱們處理上面這種狀況，容許咱們在調用函數的時候傳入多個實參

def exmaple2(required_arg, *arg, **kwarg):
if arg:
print "arg: ", arg
if kwarg:
print "kwarg: ", kwarg
exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo")

arg: (1, 2, 3)
kwarg: {'keyword2': 'foo', 'keyword1': 'bar'}
從上面的例子能夠看到，當我傳入了更多實參的時候

*arg會把多出來的位置參數轉化爲tuple

**kwarg會把關鍵字參數轉化爲dict

6 is和==的區別

在講is和==這兩種運算符區別以前，首先要知道Python中對象包含的三個基本要素，分別是：id(身份標識)、type(數據類型)和value(值)。

is和==都是對對象進行比較判斷做用的，但對對象比較判斷的內容並不相同。下面來看看具體區別在哪。

==比較操做符和is同一性運算符區別

==是python標準操做符中的比較操做符，用來比較判斷兩個對象的value(值)是否相等，例以下面兩個字符串間的比較：

a = 'cheesezh'
b = 'cheesezh'
a == b
True

is也被叫作同一性運算符，這個運算符比較判斷的是對象間的惟一身份標識，也就是id是否相同。經過對下面幾個list間的比較，你就會明白is同一性運算符的工做原理：

x = y = [4,5,6]
z = [4,5,6]
x == y
True
x == z
True
x is y
True
x is z
False

print id(x)
print id(y)
print id(z)

7 簡述Python的深淺拷貝以及應用場景？

可變對象-不可變對象

在Python中不可變對象指：一旦建立就不可修改的對象，包括字符串，元祖，數字

在Python中可變對象是指：能夠修改的對象，包括：列表、字典

L1 = [2,3,4] #L1變量指向的是一個可變對象:列表
L2 = L1 #將L1值賦給L2後，二者共享引用同一個列表對象[1,2,3,4]
L1[0] = 200 #由於列表可變，改變L1中第一個元素的值
L1; L2 #改變後，L1，L2同時改變，由於對象自己值變了
[200, 3, 4]
[200, 3, 4]

若是不想改變列表L2的值，有兩種方法:切片 和 copy模塊

L1 = [2,3,4]
L2 = L1
id(L1);id(L2) #共享引用一個可變對象
45811784L
45811784L
L2 = L1[:] #切片操做
id(L1);id(L2) #切片後，對象就不同了
45811784L
45806920L
L1[0] = 200
L1;L2 #L1發生改變，L2沒有變化
[200, 3, 4]
[2, 3, 4]

拷貝

切片技術應用於全部的序列，包括：列表、字符串、元祖

但切片不能應用於字典。對字典只能使用D.copy()方法或D.deepcopy()方法.

深淺拷貝，便可用於序列，也可用於字典

import copy
X = copy.copy(Y) #淺拷貝：只拷貝頂級的對象，或者說：父級對象
X = copy.deepcopy(Y) #深拷貝：拷貝全部對象，頂級對象及其嵌套對象。或者說：父級對象及其子對象
若是字典只有頂級對象:

若是字典中嵌套對象:

【結論】

深淺拷貝都是對源對象的複製，佔用不一樣的內存空間

若是源對象只有一級目錄的話，源作任何改動，不影響深淺拷貝對象

若是源對象不止一級目錄的話，源作任何改動，都要影響淺拷貝，但不影響深拷貝

序列對象的切片實際上是淺拷貝，即只拷貝頂級的對象

8 Python垃圾回收機制？

import sys sys.getrefcount()查看引用計數
字符串中間有空格！？等會從新建立新的字符串
總結

1. 小整數[-5,257)共用對象，常駐內存，不會被釋放。
2. 單個字符共用對象，常駐內存。
3. 單個單詞，不可修改，默認開啓intern機制，共用對象，引用計數爲0，則銷燬 。
4. 大整數不共用內存，引用計數爲0，銷燬 .
5. 數值類型和字符串類型在 Python 中都是不可變的，這意味着你沒法修改這個對象的值，每次對變量的修改，其實是建立一個新的對象 .
   Garbage collection(GC垃圾回收)
   python採用的是引用計數機制爲主，標記-清除和分代收集(隔代回收、分代回收)兩種機制爲輔的策略

引用計數機制的優勢：
一、簡單

二、實時性：一旦沒有引用，內存就直接釋放了。不用像其餘機制等到特定時機。實時性還帶來一個好處：處理回收內存的時間分攤到了平時。
引用計數機制的缺點：
維護引用計數消耗資源
循環引用，解決不了

gc模塊
3.1. 垃圾回收機制
致使引用計數+1的狀況
1.對象被建立，例如a = "hello"
2.對象被引用，例如b=a
3.對象被做爲參數，傳入到一個函數中，例如func(a)
4.對象做爲一個元素，存儲在容器中，例如list1=[a,a]

1. 經常使用函數
   一、gc.set_debug(flags) 設置gc的debug日誌，通常設置爲gc.DEBUG_LEAK
   二、gc.collect([generation]) 顯式進行垃圾回收，能夠輸入參數，0表明只檢查零代的對象，1表明檢查零，一代的對象，2表明檢查零，一，二代的對象，若是不傳參數，執行一個full collection，也就是等於傳2。 在python2中返回不可達（unreachable objects）對象的數目
   三、gc.get_threshold() 獲取的gc模塊中自動執行垃圾回收的頻率。
   四、gc.set_threshold(threshold0[, threshold1[, threshold2]) 設置自動執行垃圾回收的頻率。
   五、gc.get_count() 獲取當前自動執行垃圾回收的計數器，返回一個長度爲3的列表
   Python的GC模塊主要運用了引用計數來跟蹤和回收垃圾。在引用計數的基礎上，還能夠經過「標記-清除」解決容器對象可能產生的循環引用的問題。經過分代回收以空間換取時間進一步提升垃圾回收的效率。

標記-清除
標記-清除的出現打破了循環引用，也就是它只關注那些可能會產生循環引用的對象
缺點：該機制所帶來的額外操做和須要回收的內存塊成正比。
一旦這個差別累計超過某個閾值(700,10,10)，則Python的收集機制就啓動了，而且觸發上邊所說到的零代算法釋放「浮動的垃圾」，而且將剩下的對象移動到一代列表。隨着時間的推移，程序所使用的對象逐漸從零代列表移動到一代列表。經過這種方法，你的代碼所長期使用的對象，那些你的代碼持續訪問的活躍對象，會從零代鏈表轉移到一代再轉移到二代。經過不一樣的閾值設置，Python能夠在不一樣的時間間隔處理這些對象。Python處理零代最爲頻繁，其次是一代而後纔是二代。

隔代回收
原理：將系統中的全部內存塊根據其存活時間劃分爲不一樣的集合，每個集合就成爲一個「代」，垃圾收集的頻率隨着「代」的存活時間的增大而減少。也就是說，活得越長的對象，就越不多是垃圾，就應該減小對它的垃圾收集頻率。那麼如何來衡量這個存活時間：一般是利用幾回垃圾收集動做來衡量，若是一個對象通過的垃圾收集次數越多，能夠得出：該對象存活時間就越長。
dir(builtins)查看內建屬性
__getattribute__內建屬性。屬性訪問攔截器(方法和屬性均可以被攔截)，能夠返回一個值：之後不要在__getattribute__方法中調用self.xxxx會引發遞歸時程序死掉
map函數會根據提供的函數對指定序列作映射返回值是列表
map(function, sequence[, sequence, ...]) -> list
• function:是一個函數
• sequence:是一個或多個序列,取決於function須要幾個參數
• 返回值是一個list
filter函數python3返回的是生產器filter函數會對指定序列執行過濾操做
filter(function or None, sequence) -> list, tuple, or string
• function:接受一個參數，返回布爾值True或False
• sequence:序列能夠是str，tuple，list
list(filter(lambda x x%2==0,[1,2,3,4,5,6])---->[2,4,6]
sorted函數-排序
sorted(iterable, reverse=False) --> new sorted list
functools模塊import functools
partial函數(偏函數)把一個函數的某些參數設置默認值，返回一個新的函數，調用這個新函數會更簡單。
wraps函數 使用裝飾器時，讓外界看被裝飾的函數時內容一致。
例如，被裝飾後的函數其實已是另一個函數了（函數名等函數屬性會發生改變）。
functools.wraps(func)

9 求結果：

v = dict.fromkeys(['k1','k2'],[])
v['k1'].append('000')
print(v)
v['k1']=666
print(v)

{'k1': ['000'], 'k2': ['000']}
{'k1': 666, 'k2': ['000']}

10 求結果

def num():
return [lambda x:i*x for i in range(4)]
print([m(2) for m in num()])

[6, 6, 6, 6]
以上代碼的輸出是 [6, 6, 6, 6] （而不是 [0, 2, 4, 6]）。

這個的緣由是 Python 的閉包的後期綁定致使的 late binding，這意味着在閉包中的變量是在內部函數被調用的時候被查找。因此結果是，當任何 multipliers() 返回的函數被調用，在那時，i 的值是在它被調用時的周圍做用域中查找，到那時，不管哪一個返回的函數被調用，for 循環都已經完成了，i 最後的值是 3，所以，每一個返回的函數 multiplies 的值都是 3。所以一個等於 2 的值被傳遞進以上代碼，它們將返回一個值 6 （好比： 3 x 2）。

（順便說下，正如在 The Hitchhiker’s Guide to Python 中指出的，這裏有一點廣泛的誤解，是關於 lambda 表達式的一些東西。一個 lambda 表達式建立的函數不是特殊的，和使用一個普通的 def 建立的函數展現的表現是同樣的。）

這裏有兩種方法解決這個問題。

最廣泛的解決方案是建立一個閉包，經過使用默認參數當即綁定它的參數。例如：

def num():
return [lambda x, i=i : i * x for i in range(4)]
另一個選擇是，你可使用 functools.partial 函數：

from functools import partial
from operator import mul
def num():
return [partial(mul, i) for i in range(4)]

有家公司問的題目

直接讓我機試 打印99乘法表！

1 一行代碼實現9*9乘法表

print ("\n".join("\t".join(["%s%s=%s" %(x,y,xy) for y in range(1, x+1)]) for x in range(1, 10)))

11=1
21=2 22=4
31=3 32=6 33=9
41=4 42=8 43=12 44=16
51=5 52=10 53=15 54=20 55=25
61=6 62=12 63=18 64=24 65=30 66=36
71=7 72=14 73=21 74=28 75=35 76=42 77=49
81=8 82=16 83=24 84=32 85=40 86=48 87=56 88=64
91=9 92=18 93=27 94=36 95=45 96=54 97=63 98=72 9*9=81

2 列舉常見的內置函數？

內置函數

abs() divmod() input() open() staticmethod()
all() enumerate() int() ord() str()
any() eval() isinstance() pow() sum()
basestring() execfile() issubclass() print() super()
bin() file() iter() property() tuple()
bool() filter() len() range() type()
bytearray() float() list() raw_input() unichr()
callable() format() locals() reduce() unicode()
chr() frozenset() long() reload() vars()
classmethod() getattr() map() repr() xrange()
cmp() globals() max() reverse() zip()
compile() hasattr() memoryview() round() import()
complex() hash() min() set()
delattr() help() next() setattr()
dict() hex() object() slice()
dir() id() oct() sorted() exec 內置表達式

3 如何安裝第三方模塊？以及用過哪些第三方模塊？

使用軟件管理工具（pip，pip2，pip3）

　　python2和python3都自帶了pip，而pip就彷彿有一個倉庫，將咱們須要安裝的第三方模塊都收納其中，使用簡單的安裝命令便可完成安裝。

　　注意事項：用python3自帶的pip或者pip3安裝的第三方模塊就只能爲python3的編譯器使用，這對於python2的pip和pip2是同理的。

具體安裝方法：直接: pip3 install 模塊名

經常使用第三方模塊

Requests.Kenneth Reitz寫的最富盛名的http庫。每一個Python程序員都應該有它。

Scrapy.若是你從事爬蟲相關的工做，那麼這個庫也是必不可少的。用過它以後你就不會再想用別的同類庫了。

wxPython.Python的一個GUI（圖形用戶界面）工具。我主要用它替代tkinter。你必定會愛上它的。

Pillow.它是PIL（Python圖形庫）的一個友好分支。對於用戶比PIL更加友好，對於任何在圖形領域工做的人是必備的庫。

SQLAlchemy.一個數據庫的庫。對它的評價褒貶參半。是否使用的決定權在你手裏。

BeautifulSoup.我知道它很慢，但這個xml和html的解析庫對於新手很是有用。

Twisted.對於網絡應用開發者最重要的工具。它有很是優美的api，被不少Python開發大牛使用。

NumPy.咱們怎麼能缺乏這麼重要的庫？它爲Python提供了不少高級的數學方法。

SciPy.既然咱們提了NumPy，那就不得不提一下SciPy。這是一個Python的算法和數學工具庫，它的功能把不少科學家從Ruby吸引到了Python。

matplotlib.一個繪製數據圖的庫。對於數據科學家或分析師很是有用。

Pygame.哪一個程序員不喜歡玩遊戲和寫遊戲？這個庫會讓你在開發2D遊戲的時候如虎添翼。

Pyglet.3D動畫和遊戲開發引擎。很是有名的Python版本Minecraft就是用這個引擎作的。

pyQT.Python的GUI工具。這是我在給Python腳本開發用戶界面時次於wxPython的選擇。

pyGtk.也是Python GUI庫。頗有名的Bittorrent客戶端就是用它作的。

Scapy.用Python寫的數據包探測和分析庫。

pywin32.一個提供和windows交互的方法和類的Python庫。

nltk.天然語言工具包。我知道大多數人不會用它，但它通用性很是高。若是你須要處理字符串的話，它是很是好的庫。但它的功能遠遠不止如此，本身摸索一下吧。

nose.Python的測試框架。被成千上萬的Python程序員使用。若是你作測試導向的開發，那麼它是必不可少的。

SymPy.SymPy能夠作代數評測、差別化、擴展、複數等等。它封裝在一個純Python發行版本里。

IPython.怎麼稱讚這個工具的功能都不爲過。它把Python的提示信息作到了極致。包括完成信息、歷史信息、shell功能，以及其餘不少不少方面。必定要研究一下它。

4 re的match和search區別？

match（）函數只檢測RE是否是在string的開始位置匹配，search()會掃描整個string查找匹配；也就是說match（）只有在0位置匹配成功的話纔有返回，

若是不是開始位置匹配成功的話，match()就返回none。

例如：

print(re.match(‘super’, ‘superstition’).span()) 會返回(0, 5)

而print(re.match(‘super’, ‘insuperable’)) 則返回None

search()會掃描整個字符串並返回第一個成功的匹配

例如：print(re.search(‘super’, ‘superstition’).span())返回(0, 5)

5 什麼是正則的貪婪匹配？

如：String str="abcaxc";

　　　　Patter p="ab.*c";

　　貪婪匹配:正則表達式通常趨向於最大長度匹配，也就是所謂的貪婪匹配。如上面使用模式p匹配字符串str，結果就是匹配到：abcaxc(ab.*c)。

　　非貪婪匹配：就是匹配到結果就好，就少的匹配字符。如上面使用模式p匹配字符串str，結果就是匹配到：abc(ab.*c)。

編程中如何區分兩種模式

　　默認是貪婪模式；在量詞後面直接加上一個問號？就是非貪婪模式。

　　量詞：{m,n}：m到n個

　　　　　*：任意多個

　　　　　+：一個到多個

　　　　　？：0或一個

6 求結果：

l = [i % 2 for i in range(10)]
print(l)
t = (i % 2 for i in range(10))
print(t)
=============================
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
<generator object at 0x000000000271CB10>

7 求結果

print(1 or 2)
print(1 and 2)
print(1 < (2==2))
print(1 < 3 == 3)
print(True == 3)
print(True == 1)
=============================
1
2
False
True
False
True

8 def func(a,b=[]) 這種寫法有什麼坑？

def func(a,b=[]):
b.append(a)
print(b)
func(1)
func(1)
func(1)
func(1)
=================================
[1]
[1, 1]
[1, 1, 1]
[1, 1, 1, 1]
函數的第二個默認參數是一個list，當第一次執行的時候實例化了一個list，第二次執行仍是用第一次執行的時候實例化的地址存儲，因此三次執行的結果就是 [1, 1, 1] ，想每次執行只輸出[1] ，默認參數應該設置爲None。

9 如何實現 「1,2,3」 變成 [‘1’,’2’,’3’] ?

L = [1,2,3]
NL =list(map(str,L))
print(NL)

10 一、二、三、四、5 能組成多少個互不相同且無重複的三位數

for x in range(1,5): for y in range(1,5): for z in range(1,5): if (x!=y) and (y!=z) and (z!=x): print("%d%d%d" % (x, y, z))