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-8、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()查看引用計數
字符串中間有空格！？等會重新創建新的字符串
總結
Garbage collection(GC垃圾回收)
python采用的是引用計數機制為主，標記-清除和分代收集(隔代回收、分代回收)兩種機制為輔的策略
引用計數機制的優點：
1、簡單
2、實時性：一旦沒有引用，內存就直接釋放了。不用像其他機制等到特定時機。實時性還帶來一個好處：處理回收內存的時間分攤到了平時。
引用計數機制的缺點：
維護引用計數消耗資源
循環引用，解決不了
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
2、gc.collect([generation]) 顯式進行垃圾回收，可以輸入參數，0代表只檢查零代的對象，1代表檢查零，一代的對象，2代表檢查零，一，二代的對象，如果不傳參數，執行一個full collection，也就是等于傳2。 在python2中返回不可達（unreachable objects）對象的數目
3、gc.get_threshold() 獲取的gc模塊中自動執行垃圾回收的頻率。
4、gc.set_threshold(threshold0[, threshold1[, threshold2]) 設置自動執行垃圾回收的頻率。
5、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 1、2、3、4、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))
轉載于:https://www.cnblogs.com/xiejianxiong/p/10367083.html
與50位技術專家面對面20年技術見證，附贈技術全景圖總結
以上是生活随笔為你收集整理的Python 面试中可能会被问到的30个问题的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 移动端web自适应适配布局解决方案
- 下一篇： Python-语句执行