題目001: 在Python中如何實現單例模式。
點評：單例模式是指讓一個類只能創建出唯一的實例，這個題目在面試中出現的頻率極高，因爲它考察的不僅僅是單例模式，更是對Python語言到底掌握到何種程度，建議大家用裝飾器和元類這兩種方式來實現單例模式，因爲這兩種方式的通用性最強，而且也可以順便展示自己對裝飾器和元類中兩個關鍵知識點的理解。
方法一：使用裝飾器實現單例模式。
from functools import wraps
def singleton(cls):
"""單例類裝飾器"""
instances = {}
@wraps(cls)
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton
class President:
pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
擴展：裝飾器是Python中非常有特色的語法，用一個函數去裝飾另一個函數或類，爲其添加額外的能力。通常通過裝飾來實現的功能都屬橫切關注功能，也就是跟正常的業務邏輯沒有必然聯繫，可以動態添加或移除的功能。裝飾器可以爲代碼提供緩存、代理、上下文環境等服務，它是對設計模式中代理模式的踐行。在寫裝飾器的時候，帶裝飾功能的函數（上面代碼中的wrapper函數）通常都會用functools模塊中的wraps再加以裝飾，這個裝飾器最重要的作用是給被裝飾的類或函數動態添加一個__wrapped__屬性，這個屬性會將被裝飾之前的類或函數保留下來，這樣在我們不需要裝飾功能的時候，可以通過它來取消裝飾器，例如可以使用President = President.__wrapped__來取消對President類做的單例處理。需要提醒大家的是：上面的單例並不是線程安全的，如果要做到線程安全，需要對創建對象的代碼進行加鎖的處理。在Python中可以使用threading模塊的RLock對象來提供鎖，可以使用鎖對象的acquire和release方法來實現加鎖和解鎖的操作。當然，更爲簡便的做法是使用鎖對象的with上下文語法來進行隱式的加鎖和解鎖操作。
方法二：使用元類實現單例模式。
class SingletonMeta(type):
"""自定義單例元類"""
def __init__(cls, *args, **kwargs):
cls.__instance = None
super().__init__(*args, **kwargs)
def __call__(cls, *args, **kwargs):
if cls.__instance is None:
cls.__instance = super().__call__(*args, **kwargs)
return cls.__instance
class President(metaclass=SingletonMeta):
pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
擴展：Python是面向對象的編程語言，在面向對象的世界中，一切皆爲對象。對象是通過類來創建的，而類本身也是對象，類這樣的對象是通過元類來創建的。我們在定義類時，如果沒有給一個類指定父類，那麼默認的父類是object，如果沒有給一個類指定元類，那麼默認的元類是type。通過自定義的元類，我們可以改變一個類默認的行爲，就如同上面的代碼中，我們通過元類的__call__魔術方法，改變了President類的構造器那樣。
補充：關於單例模式，在面試中還有可能被問到它的應用場景。通常一個對象的狀態是被其他對象共享的，就可以將其設計爲單例，例如項目中使用的數據庫連接池對象和配置對象通常都是單例，這樣才能保證所有地方獲取到的數據庫連接和配置信息是完全一致的；而且由於對象只有唯一的實例，因此從根本上避免了重複創建對象造成的時間和空間上的開銷，也避免了對資源的多重佔用。再舉個例子，項目中的日誌操作通常也會使用單例模式，這是因爲共享的日誌文件一直處於打開狀態，只能有一個實例去操作它，否則在寫入日誌的時候會產生混亂。
題目002：不使用中間變量，交換兩個變量`a`和`b`的值。
點評：典型的送人頭的題目，通常交換兩個變量需要藉助一箇中間變量，如果不允許使用中間變量，在其他編程語言中可以使用異或運算的方式來實現交換兩個變量的值，但是Python中有更爲簡單明瞭的做法。
方法一：
a = a ^ b
b = a ^ b
a = a ^ b
1
2
3
4
方法二：
a, b = b, a
1
2
擴展：需要注意，a, b = b, a這種做法其實並不是元組解包，雖然很多人都這樣認爲。Python字節碼指令中有ROT_TWO指令來支持這個操作，類似的還有ROT_THREE，對於3個以上的元素，如a, b, c, d = b, c, d, a，纔會用到創建元組和元組解包。想知道你的代碼對應的字節碼指令，可以使用Python標準庫中dis模塊的dis函數來反彙編你的Python代碼。
題目003：寫一個刪除列表中重複元素的函數，要求去重後元素相對位置保持不變。
點評：這個題目在初中級Python崗位面試的時候經常出現，題目源於《Python Cookbook》這本書第一章的第10個問題，有很多面試題其實都是這本書上的原題，所以建議大家有時間好好研讀一下這本書。
def dedup(items):
no_dup_items = []
seen = set()
for item in items:
if item not in seen:
no_dup_items.append(item)
seen.add(item)
return no_dup_items
1
2
3
4
5
6
7
8
9
如果願意也可以把上面的函數改造成一個生成器，代碼如下所示。
def dedup(items):
seen = set()
for item in items:
if item not in seen:
yield item
seen.add(item)
1
2
3
4
5
6
7
擴展：由於Python中的集合底層使用哈希存儲，所以集合的in和not in成員運算在性能上遠遠優於列表，所以上面的代碼我們使用了集合來保存已經出現過的元素。集合中的元素必須是hashable對象，因此上面的代碼在列表元素不是hashable對象時會失效，要解決這個問題可以給函數增加一個參數，該參數可以設計爲返回哈希碼或hashable對象的函數。
題目004：假設你使用的是官方的CPython，說出下面代碼的運行結果。
點評：下面的程序對實際開發並沒有什麼意義，但卻是CPython中的一個大坑，這道題旨在考察面試者對官方的Python解釋器到底瞭解到什麼程度。
a, b, c, d = 1, 1, 1000, 1000
print(a is b, c is d)
def foo():
e = 1000
f = 1000
print(e is f, e is d)
g = 1
print(g is a)
foo()
1
2
3
4
5
6
7
8
9
10
11
12
運行結果：
True False
True False
True
1
2
3
4
上面代碼中a is b的結果是True但c is d的結果是False，這一點的確讓人費解。CPython解釋器出於性能優化的考慮，把頻繁使用的整數對象用一個叫small_ints的對象池緩存起來造成的。small_ints緩存的整數值被設定爲[-5, 256]這個區間，也就是說，在任何引用這些整數的地方，都不需要重新創建int對象，而是直接引用緩存池中的對象。如果整數不在該範圍內，那麼即便兩個整數的值相同，它們也是不同的對象。
CPython底層爲了進一步提升性能還做了另一個設定，對於同一個代碼塊中值不在small_ints緩存範圍內的整數，如果同一個代碼塊中已經存在一個值與其相同的整數對象，那麼就直接引用該對象，否則創建新的int對象。需要大家注意的是，這條規則對數值型適用，但對字符串則需要考慮字符串的長度，這一點大家可以自行證明。
擴展：如果你用PyPy（另一種Python解釋器實現，支持JIT，對CPython的缺點進行了改良，在性能上優於CPython，但對三方庫的支持略差）來運行上面的代碼，你會發現所有的輸出都是True。
題目005：Lambda函數是什麼，舉例說明的它的應用場景。
點評：這個題目主要想考察的是Lambda函數的應用場景，潛臺詞是問你在項目中有沒有使用過Lambda函數，具體在什麼場景下會用到Lambda函數，藉此來判斷你寫代碼的能力。因爲Lambda函數通常用在高階函數中，主要的作用是通過向函數傳入函數或讓函數返回函數最終實現代碼的解耦合。
Lambda函數也叫匿名函數，它是功能簡單用一行代碼就能實現的小型函數。Python中的Lambda函數只能寫一個表達式，這個表達式的執行結果就是函數的返回值，不用寫return關鍵字。Lambda函數因爲沒有名字，所以也不會跟其他函數發生命名衝突的問題。
擴展：面試的時候有可能還會考你用Lambda函數來實現一些功能，也就是用一行代碼來實現題目要求的功能，例如：用一行代碼實現求階乘的函數，用一行代碼實現求最大公約數的函數等。
fac = lambda x: __import__('functools').reduce(int.__mul__, range(1, x + 1), 1)
gcd = lambda x, y: y % x and gcd(y % x, x) or x
1
2
3
Lambda函數其實最爲主要的用途是把一個函數傳入另一個高階函數（如Python內置的filter、map等）中來爲函數做解耦合，增強函數的靈活性和通用性。下面的例子通過使用filter和map函數，實現了從列表中篩選出奇數並求平方構成新列表的操作，因爲用到了高階函數，過濾和映射數據的規則都是函數的調用者通過另外一個函數傳入的，因此這filter和map函數沒有跟特定的過濾和映射數據的規則耦合在一起。
items = [12, 5, 7, 10, 8, 19]
items = list(map(lambda x: x ** 2, filter(lambda x: x % 2, items)))
print(items) # [25, 49, 361]
1
2
3
4
擴展：用列表的生成式來實現上面的代碼會更加簡單明瞭，代碼如下所示。
items = [12, 5, 7, 10, 8, 19]
items = [x ** 2 for x in items if x % 2]
print(items) # [25, 49, 361]
1
2
3
4
題目006：說說Python中的淺拷貝和深拷貝。
點評：這個題目本身出現的頻率非常高，但是就題論題而言沒有什麼技術含量。對於這種面試題，在回答的時候一定要讓你的答案能夠超出面試官的預期，這樣才能獲得更好的印象分。所以回答這個題目的要點不僅僅是能夠說出淺拷貝和深拷貝的區別，深拷貝的時候可能遇到的兩大問題，還要說出Python標準庫對淺拷貝和深拷貝的支持，然後可以說說列表、字典如何實現拷貝操作以及如何通過序列化和反序列的方式實現深拷貝，最後還可以提到設計模式中的原型模式以及它在項目中的應用。
淺拷貝通常只複製對象本身，而深拷貝不僅會複製對象，還會遞歸的複製對象所關聯的對象。深拷貝可能會遇到兩個問題：一是一個對象如果直接或間接的引用了自身，會導致無休止的遞歸拷貝；二是深拷貝可能對原本設計爲多個對象共享的數據也進行拷貝。Python通過copy模塊中的copy和deepcopy函數來實現淺拷貝和深拷貝操作，其中deepcopy可以通過memo字典來保存已經拷貝過的對象，從而避免剛纔所說的自引用遞歸問題；此外，可以通過copyreg模塊的pickle函數來定製指定類型對象的拷貝行爲。
deepcopy函數的本質其實就是對象的一次序列化和一次返回序列化，面試題中還考過用自定義函數實現對象的深拷貝操作，顯然我們可以使用pickle模塊的dumps和loads來做到，代碼如下所示。
import pickle
my_deep_copy = lambda obj: pickle.loads(pickle.dumps(obj))
1
2
3
4
列表的切片操作[:]相當於實現了列表對象的淺拷貝，而字典的copy方法可以實現字典對象的淺拷貝。對象拷貝其實是更爲快捷的創建對象的方式。在Python中，通過構造器創建對象屬於兩階段構造，首先是分配內存空間，然後是初始化。在創建對象時，我們也可以基於“原型”對象來創建新對象，通過對原型對象的拷貝（複製內存）就完成了對象的創建和初始化，這種做法更加高效，這也就是設計模式中的原型模式。在Python中，我們可以通過元類的方式來實現原型模式，代碼如下所示。
import copy
class PrototypeMeta(type):
"""實現原型模式的元類"""
def __init__(cls, *args, **kwargs):
super().__init__(*args, **kwargs)
# 爲對象綁定clone方法來實現對象拷貝
cls.clone = lambda self, is_deep=True: \
copy.deepcopy(self) if is_deep else copy.copy(self)
class Person(metaclass=PrototypeMeta):
pass
p1 = Person()
p2 = p1.clone() # 深拷貝
p3 = p1.clone(is_deep=False) # 淺拷貝
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
題目007：Python是如何實現內存管理的？
點評：當面試官問到這個問題的時候，一個展示自己的機會就擺在面前了。你要先反問面試官：“你說的是官方的CPython解釋器嗎？”。這個反問可以展示出你瞭解過Python解釋器的不同的實現版本，而且你也知道面試官想問的是CPython。當然，很多面試官對不同的Python解釋器底層實現到底有什麼差別也沒有概念。所以，千萬不要覺得面試官一定比你強，懷揣着這份自信可以讓你更好的完成面試。
Python提供了自動化的內存管理，也就是說內存空間的分配與釋放都是由Python解釋器在運行時自動進行的，自動管理內存功能極大的減輕程序員的工作負擔，也能夠幫助程序員在一定程度上解決內存泄露的問題。以CPython解釋器爲例，它的內存管理有三個關鍵點：引用計數、標記清理、分代收集。
引用計數：對於CPython解釋器來說，Python中的每一個對象其實就是PyObject結構體，它的內部有一個名爲ob_refcnt 的引用計數器成員變量。程序在運行的過程中ob_refcnt的值會被更新並藉此來反映引用有多少個變量引用到該對象。當對象的引用計數值爲0時，它的內存就會被釋放掉。
typedef struct _object {
_PyObject_HEAD_EXTRA
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
} PyObject;
1
2
3
4
5
6
以下情況會導致引用計數加1：
對象被創建
對象被引用
對象作爲參數傳入到一個函數中
對象作爲元素存儲到一個容器中
以下情況會導致引用計數減1：
用del語句顯示刪除對象引用
對象引用被重新賦值其他對象
一個對象離開它所在的作用域
持有該對象的容器自身被銷燬
持有該對象的容器刪除該對象
可以通過sys模塊的getrefcount函數來獲得對象的引用計數。引用計數的內存管理方式在遇到循環引用的時候就會出現致命傷，因此需要其他的垃圾回收算法對其進行補充。
標記清理：CPython使用了“標記-清理”（Mark and Sweep）算法解決容器類型可能產生的循環引用問題。該算法在垃圾回收時分爲兩個階段：標記階段，遍歷所有的對象，如果對象是可達的（被其他對象引用），那麼就標記該對象爲可達；清除階段，再次遍歷對象，如果發現某個對象沒有標記爲可達，則就將其回收。CPython底層維護了兩個雙端鏈表，一個鏈表存放着需要被掃描的容器對象（姑且稱之爲鏈表A），另一個鏈表存放着臨時不可達對象（姑且稱之爲鏈表B）。爲了實現“標記-清理”算法，鏈表中的每個節點除了有記錄當前引用計數的ref_count變量外，還有一個gc_ref變量，這個gc_ref是ref_count的一個副本，所以初始值爲ref_count的大小。執行垃圾回收時，首先遍歷鏈表A中的節點，並且將當前對象所引用的所有對象的gc_ref減1，這一步主要作用是解除循環引用對引用計數的影響。再次遍歷鏈表A中的節點，如果節點的gc_ref值爲0，那麼這個對象就被標記爲“暫時不可達”（GC_TENTATIVELY_UNREACHABLE）並被移動到鏈表B中；如果節點的gc_ref不爲0，那麼這個對象就會被標記爲“可達“（GC_REACHABLE），對於”可達“對象，還要遞歸的將該節點可以到達的節點標記爲”可達“；鏈表B中被標記爲”可達“的節點要重新放回到鏈表A中。在兩次遍歷之後，鏈表B中的節點就是需要釋放內存的節點。
分代回收：在循環引用對象的回收中，整個應用程序會被暫停，爲了減少應用程序暫停的時間，Python 通過分代回收（空間換時間）的方法提高垃圾回收效率。分代回收的基本思想是：對象存在的時間越長，是垃圾的可能性就越小，應該儘量不對這樣的對象進行垃圾回收。CPython將對象分爲三種世代分別記爲0、1、2，每一個新生對象都在第0代中，如果該對象在一輪垃圾回收掃描中存活下來，那麼它將被移到第1代中，存在於第1代的對象將較少的被垃圾回收掃描到；如果在對第1代進行垃圾回收掃描時，這個對象又存活下來，那麼它將被移至第2代中，在那裏它被垃圾回收掃描的次數將會更少。分代回收掃描的門限值可以通過gc模塊的get_threshold函數來獲得，該函數返回一個三元組，分別表示多少次內存分配操作後會執行0代垃圾回收，多少次0代垃圾回收後會執行1代垃圾回收，多少次1代垃圾回收後會執行2代垃圾回收。需要說明的是，如果執行一次2代垃圾回收，那麼比它年輕的代都要執行垃圾回收。如果想修改這幾個門限值，可以通過gc模塊的set_threshold函數來做到。
題目008：說一下你對Python中迭代器和生成器的理解。
點評：很多人面試者都會寫迭代器和生成器，但是卻無法準確的解釋什麼是迭代器和生成器。如果你也有同樣的困惑，可以參考下面的回答。
迭代器是實現了迭代器協議的對象。跟其他編程語言不通，Python中沒有用於定義協議或表示約定的關鍵字，像interface、protocol這些單詞並不在Python語言的關鍵字列表中。Python語言通過魔法方法來表示約定，也就是我們所說的協議，而__next__和__iter__這兩個魔法方法就代表了迭代器協議。可以通過for-in循環從迭代器對象中取出值，也可以使用next函數取出迭代器對象中的下一個值。生成器是迭代器的語法升級版本，可以用更爲簡單的代碼來實現一個迭代器。
擴展：面試中經常讓寫生成斐波那契數列的迭代器，大家可以參考下面的代碼。
class Fib(object):
def __init__(self, num):
self.num = num
self.a, self.b = 0, 1
self.idx = 0
def __iter__(self):
return self
def __next__(self):
if self.idx < self.num:
self.a, self.b = self.b, self.a + self.b
self.idx += 1
return self.a
raise StopIteration()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
如果用生成器的語法來改寫上面的代碼，代碼會簡單優雅很多。
def fib(num):
a, b = 0, 1
for _ in range(num):
a, b = b, a + b
yield a
1
2
3
4
5
6
題目009：正則表達式的match方法和search方法有什麼區別？
點評：正則表達式是字符串處理的重要工具，所以也是面試中經常考察的知識點。在Python中，使用正則表達式有兩種方式，一種是直接調用re模塊中的函數，傳入正則表達式和需要處理的字符串；一種是先通過re模塊的compile函數創建正則表達式對象，然後再通過對象調用方法並傳入需要處理的字符串。如果一個正則表達式被頻繁的使用，我們推薦用re.compile函數創建正則表達式對象，這樣會減少頻繁編譯同一個正則表達式所造成的開銷。
match方法是從字符串的起始位置進行正則表達式匹配，返回Match對象或None。search方法會掃描整個字符串來找尋匹配的模式，同樣也是返回Match對象或None。
題目010：下面這段代碼的執行結果是什麼。
def multiply():
return [lambda x: i * x for i in range(4)]
print([m(100) for m in multiply()])
1
2
3
4
5
運行結果：
[300, 300, 300, 300]
1
2
上面代碼的運行結果很容易被誤判爲[0, 100, 200, 300]。首先需要注意的是multiply函數用生成式語法返回了一個列表，列表中保存了4個Lambda函數，這4個Lambda函數會返回傳入的參數乘以i的結果。需要注意的是這裏有閉包（closure）現象，multiply函數中的局部變量i的生命週期被延展了，由於i最終的值是3，所以通過m(100)調列表中的Lambda函數時會返回300，而且4個調用都是如此。
如果想得到[0, 100, 200, 300]這個結果，可以按照下面幾種方式來修改multiply函數。
方法一：使用生成器，讓函數獲得i的當前值。
def multiply():
return (lambda x: i * x for i in range(4))
print([m(100) for m in multiply()])
1
2
3
4
5
或者
def multiply():
for i in range(4):
yield lambda x: x * i
print([m(100) for m in multiply()])
1
2
3
4
5
6
方法二：使用偏函數，徹底避開閉包。
from functools import partial
from operator import __mul__
def multiply():
return [partial(__mul__, i) for i in range(4)]
print([m(100) for m in multiply()])
1
2
3
4
5
6
7
8
題目011：Python中爲什麼沒有函數重載？
點評：C++、Java、C#等諸多編程語言都支持函數重載，所謂函數重載指的是在同一個作用域中有多個同名函數，它們擁有不同的參數列表（參數個數不同或參數類型不同或二者皆不同），可以相互區分。重載也是一種多態性，因爲通常是在編譯時通過參數的個數和類型來確定到底調用哪個重載函數，所以也被稱爲編譯時多態性或者叫前綁定。這個問題的潛臺詞其實是問面試者是否有其他編程語言的經驗，是否理解Python是動態類型語言，是否知道Python中函數的可變參數、關鍵字參數這些概念。
首先Python是解釋型語言，函數重載現象通常出現在編譯型語言中。其次Python是動態類型語言，函數的參數沒有類型約束，也就無法根據參數類型來區分重載。再者Python中函數的參數可以有默認值，可以使用可變參數和關鍵字參數，因此即便沒有函數重載，也要可以讓一個函數根據調用者傳入的參數產生不同的行爲。
題目012：用Python代碼實現Python內置函數max。
點評：這個題目看似簡單，但實際上還是比較考察面試者的功底。因爲Python內置的max函數既可以傳入可迭代對象找出最大，又可以傳入兩個或多個參數找出最大；最爲關鍵的是還可以通過命名關鍵字參數key來指定一個用於元素比較的函數，還可以通過default命名關鍵字參數來指定當可迭代對象爲空時返回的默認值。
下面的代碼僅供參考：
def my_max(*args, key=None, default=None):
"""
獲取可迭代對象中最大的元素或兩個及以上實參中最大的元素
:param args: 一個可迭代對象或多個元素
:param key: 提取用於元素比較的特徵值的函數，默認爲None
:param default: 如果可迭代對象爲空則返回該默認值，如果沒有給默認值則引發ValueError異常
:return: 返回可迭代對象或多個元素中的最大元素
"""
if len(args) == 1 and len(args[0]) == 0:
if default:
return default
else:
raise ValueError('max() arg is an empty sequence')
items = args[0] if len(args) == 1 else args
max_elem, max_value = items[0], items[0]
if key:
max_value = key(max_value)
for item in items:
value = item
if key:
value = key(item)
if value > max_value:
max_elem, max_value = item, value
return max_elem
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
題目013：寫一個函數統計傳入的列表中每個數字出現的次數並返回對應的字典。
點評：送人頭的題目，不解釋。
def count_letters(items):
result = {}
for item in items:
if isinstance(item, (int, float)):
result[item] = result.get(item, 0) + 1
return result
1
2
3
4
5
6
7
也可以直接使用Python標準庫中collections模塊的Counter類來解決這個問題，Counter是dict的子類，它會將傳入的序列中的每個元素作爲鍵，元素出現的次數作爲值來構造字典。
from collections import Counter
def count_letters(items):
counter = Counter(items)
return {key: value for key, value in counter.items() \
if isinstance(key, (int, float))}
1
2
3
4
5
6
7
題目014：使用Python代碼實現遍歷一個文件夾的操作。
點評：基本也是送人頭的題目，只要用過os模塊就應該知道怎麼做。
Python標準庫os模塊的walk函數提供了遍歷一個文件夾的功能，它返回一個生成器。
import os
g = os.walk('/Users/Hao/Downloads/')
for path, dir_list, file_list in g:
for dir_name in dir_list:
print(os.path.join(path, dir_name))
for file_name in file_list:
print(os.path.join(path, file_name))
1
2
3
4
5
6
7
8
9
說明：os.path模塊提供了很多進行路徑操作的工具函數，在項目開發中也是經常會用到的。如果題目明確要求不能使用os.walk函數，那麼可以使用os.listdir函數來獲取指定目錄下的文件和文件夾，然後再通過循環遍歷用os.isdir函數判斷哪些是文件夾，對於文件夾可以通過遞歸調用進行遍歷，這樣也可以實現遍歷一個文件夾的操作。
題目015：現有2元、3元、5元共三種面額的貨幣，如果需要找零99元，一共有多少種找零的方式？
點評：還有一個非常類似的題目：“一個小朋友走樓梯，一次可以走1個臺階、2個臺階或3個臺階，問走完10個臺階一共有多少種走法？”，這兩個題目的思路是一樣，如果用遞歸函數來寫的話非常簡單。
from functools import lru_cache
@lru_cache()
def change_money(total):
if total == 0:
return 1
if total < 0:
return 0
return change_money(total - 2) + change_money(total - 3) + \
change_money(total - 5)
1
2
3
4
5
6
7
8
9
10
11
12
說明：在上面的代碼中，我們用lru_cache裝飾器裝飾了遞歸函數change_money，如果不做這個優化，上面代碼的漸近時間複雜度將會是，而如果參數total的值是99，這個運算量是非常巨大的。lru_cache裝飾器會緩存函數的執行結果，這樣就可以減少重複運算所造成的開銷，這是空間換時間的策略，也是動態規劃的編程思想。
題目016：寫一個函數，給定矩陣的階數`n`，輸出一個螺旋式數字矩陣。
例如：n = 2，返回：
1 2
4 3
1
2
3
例如：n = 3，返回：
1 2 3
8 9 4
7 6 5
1
2
3
4
這個題目本身並不複雜，下面的代碼僅供參考。
def show_spiral_matrix(n):
matrix = [[0] * n for _ in range(n)]
row, col = 0, 0
num, direction = 1, 0
while num <= n ** 2:
if matrix[row][col] == 0:
matrix[row][col] = num
num += 1
if direction == 0:
if col < n - 1 and matrix[row][col + 1] == 0:
col += 1
else:
direction += 1
elif direction == 1:
if row < n - 1 and matrix[row + 1][col] == 0:
row += 1
else:
direction += 1
elif direction == 2:
if col > 0 and matrix[row][col - 1] == 0:
col -= 1
else:
direction += 1
else:
if row > 0 and matrix[row - 1][col] == 0:
row -= 1
else:
direction += 1
direction %= 4
for x in matrix:
for y in x:
print(y, end='\t')
print()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
題目017：閱讀下面的代碼，寫出程序的運行結果。
items = [1, 2, 3, 4]
print([i for i in items if i > 2])
print([i for i in items if i % 2])
print([(x, y) for x, y in zip('abcd', (1, 2, 3, 4, 5))])
print({x: f'item{x ** 2}' for x in (2, 4, 6)})
print(len({x for x in 'hello world' if x not in 'abcdefg'}))
1
2
3
4
5
6
7
點評：生成式（推導式）屬於Python的特色語法之一，幾乎是面試必考內容。Python中通過生成式字面量語法，可以創建出列表、集合、字典。
[3, 4]
[1, 3]
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
{2: 'item4', 4: 'item16', 6: 'item36'}
6
1
2
3
4
5
6
題目018：說出下面代碼的運行結果。
class Parent:
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
點評：運行上面的代碼首先輸出1 1 1，這一點大家應該沒有什麼疑問。接下來，通過Child1.x = 2給類Child1重新綁定了屬性x並賦值爲2，所以Child1.x會輸出2，而Parent和Child2並不受影響。執行Parent.x = 3會重新給Parent類的x屬性賦值爲3，由於Child2的x屬性繼承自Parent，所以Child2.x的值也是3；而之前我們爲Child1重新綁定了x屬性，那麼它的x屬性值不會受到Parent.x = 3的影響，還是之前的值2。
1 1 1
1 2 1
3 2 3
1
2
3
4
題目19：說說你用過Python標準庫中的哪些模塊。
點評：Python標準庫中的模塊非常多，建議大家根據自己過往的項目經歷來介紹你用過的標準庫和三方庫，因爲這些是你最爲熟悉的，經得起面試官深挖的。
模塊名 介紹
sys 跟Python解釋器相關的變量和函數，例如：sys.version、sys.exit()
os 和操作系統相關的功能，例如：os.listdir()、os.remove()
re 和正則表達式相關的功能，例如：re.compile()、re.search()
math 和數學運算相關的功能，例如：math.pi、math.e、math.cos
logging 和日誌系統相關的類和函數，例如：logging.Logger、logging.Handler
json / pickle 實現對象序列化和反序列的模塊，例如：json.loads、json.dumps
hashlib 封裝了多種哈希摘要算法的模塊，例如：hashlib.md5、hashlib.sha1
urllib 包含了和URL相關的子模塊，例如：urllib.request、urllib.parse
itertools 提供各種迭代器的模塊，例如：itertools.cycle、itertools.product
functools 函數相關工具模塊，例如：functools.partial、functools.lru_cache
collections / heapq 封裝了常用數據結構和算法的模塊，例如：collections.deque
threading / multiprocessing 多線程/多進程相關類和函數的模塊，例如：threading.Thread
concurrent.futures / asyncio 併發編程/異步編程相關的類和函數的模塊，例如：ThreadPoolExecutor
base64 提供BASE-64編碼相關函數的模塊，例如：bas64.encode
csv 和讀寫CSV文件相關的模塊，例如：csv.reader、csv.writer
profile / cProfile / pstats 和代碼性能剖析相關的模塊，例如：cProfile.run、pstats.Stats
unittest 和單元測試相關的模塊，例如：unittest.TestCase
題目20：`init__`和`__new`方法有什麼區別？
Python中調用構造器創建對象屬於兩階段構造過程，首先執行__new__方法獲得保存對象所需的內存空間，再通過__init__執行對內存空間數據的填充（對象屬性的初始化）。__new__方法的返回值是創建好的Python對象（的引用），而__init__方法的第一個參數就是這個對象（的引用），所以在__init__中可以完成對對象的初始化操作。__new__是類方法，它的第一個參數是類，__init__是對象方法，它的第一個參數是對象。
題目21：輸入年月日，判斷這個日期是這一年的第幾天。
方法一：不使用標準庫中的模塊和函數。
def is_leap_year(year):
"""判斷指定的年份是不是閏年，平年返回False，閏年返回True"""
return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
def which_day(year, month, date):
"""計算傳入的日期是這一年的第幾天"""
# 用嵌套的列表保存平年和閏年每個月的天數
days_of_month = [
[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
[31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
]
days = days_of_month[is_leap_year(year)][:month - 1]
return sum(days) + date
1
2
3
4
5
6
7
8
9
10
11
12
13
14
方法二：使用標準庫中的datetime模塊。
import datetime
def which_day(year, month, date):
end = datetime.date(year, month, date)
start = datetime.date(year, 1, 1)
return (end - start).days + 1
1
2
3
4
5
6
7
題目22：平常工作中用什麼工具進行靜態代碼分析。
點評：靜態代碼分析工具可以從代碼中提煉出各種靜態屬性，這使得開發者可以對代碼的複雜性、可維護性和可讀性有更好的瞭解，這裏所說的靜態屬性包括：
代碼是否符合編碼規範，例如：PEP-8。
代碼中潛在的問題，包括：語法錯誤、縮進問題、導入缺失、變量覆蓋等。
代碼中的壞味道。
代碼的複雜度。
代碼的邏輯問題。
工作中靜態代碼分析主要用到的是Pylint和Flake8。Pylint可以檢查出代碼錯誤、壞味道、不規範的代碼等問題，較新的版本中還提供了代碼複雜度統計數據，可以生成檢查報告。Flake8封裝了Pyflakes（檢查代碼邏輯錯誤）、McCabe（檢查代碼複雜性）和Pycodestyle（檢查代碼是否符合PEP-8規範）工具，它可以執行這三個工具提供的檢查。
題目23：說一下你知道的Python中的魔術方法。
點評：魔術方法也稱爲魔法方法，是Python中的特色語法，也是面試中的高頻問題。
魔術方法 作用
__new__、__init__、__del__ 創建和銷燬對象相關
__add__、__sub__、__mul__、__div__、__floordiv__、__mod__ 算術運算符相關
__eq__、__ne__、__lt__、__gt__、__le__、__ge__ 關係運算符相關
__pos__、__neg__、__invert__ 一元運算符相關
__lshift__、__rshift__、__and__、__or__、__xor__ 位運算相關
__enter__、__exit__ 上下文管理器協議
__iter__、__next__、__reversed__ 迭代器協議
__int__、__long__、__float__、__oct__、__hex__ 類型/進制轉換相關
__str__、__repr__、__hash__、__dir__ 對象表述相關
__len__、__getitem__、__setitem__、__contains__、__missing__ 序列相關
__copy__、__deepcopy__ 對象拷貝相關
__call__、__setattr__、__getattr__、__delattr__ 其他魔術方法
題目24：函數參數`arg`和`*kwargs`分別代表什麼？
Python中，函數的參數分爲位置參數、可變參數、關鍵字參數、命名關鍵字參數。*args代表可變參數，可以接收0個或任意多個參數，當不確定調用者會傳入多少個位置參數時，就可以使用可變參數，它會將傳入的參數打包成一個元組。**kwargs代表關鍵字參數，可以接收用參數名=參數值的方式傳入的參數，傳入的參數的會打包成一個字典。定義函數時如果同時使用*args和**kwargs，那麼函數可以接收任意參數。
題目25：寫一個記錄函數執行時間的裝飾器。
點評：高頻面試題，也是最簡單的裝飾器，面試者必須要掌握的內容。
方法一：用函數實現裝飾器。
from functools import wraps
from time import time
def record_time(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time()
result = func(*args, **kwargs)
print(f'{func.__name__}執行時間: {time() - start}秒')
return result
return wrapper
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
方法二：用類實現裝飾器。類有__call__魔術方法，該類對象就是可調用對象，可以當做裝飾器來使用。
from functools import wraps
from time import time
class Record:
def __call__(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time()
result = func(*args, **kwargs)
print(f'{func.__name__}執行時間: {time() - start}秒')
return result
return wrapper
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
說明：裝飾器可以用來裝飾類或函數，爲其提供額外的能力，屬於設計模式中的代理模式。
擴展：裝飾器本身也可以參數化，例如上面的例子中，如果不希望在終端中顯示函數的執行時間而是希望由調用者來決定如何輸出函數的執行時間，可以通過參數化裝飾器的方式來做到，代碼如下所示。
from functools import wraps
from time import time
def record_time(output):
"""可以參數化的裝飾器"""
def decorate(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time()
result = func(*args, **kwargs)
output(func.__name__, time() - start)
return result
return wrapper
return decorate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
題目26：什麼是鴨子類型（duck typing）？
鴨子類型是動態類型語言判斷一個對象是不是某種類型時使用的方法，也叫做鴨子判定法。簡單的說，鴨子類型是指判斷一隻鳥是不是鴨子，我們只關心它游泳像不像鴨子、叫起來像不像鴨子、走路像不像鴨子就足夠了。換言之，如果對象的行爲跟我們的預期是一致的（能夠接受某些消息），我們就認定它是某種類型的對象。
在Python語言中，有很多bytes-like對象（如：bytes、bytearray、array.array、memoryview）、file-like對象（如：StringIO、BytesIO、GzipFile、socket）、path-like對象（如：str、bytes），其中file-like對象都能支持read和write操作，可以像文件一樣讀寫，這就是所謂的對象有鴨子的行爲就可以判定爲鴨子的判定方法。再比如Python中列表的extend方法，它需要的參數並不一定要是列表，只要是可迭代對象就沒有問題。
說明：動態語言的鴨子類型使得設計模式的應用被大大簡化。
題目27：說一下Python中變量的作用域。
Python中有四種作用域，分別是局部作用域（Local）、嵌套作用域（Embedded）、全局作用域（Global）、內置作用域（Built-in），搜索一個標識符時，會按照LEGB的順序進行搜索，如果所有的作用域中都沒有找到這個標識符，就會引發NameError異常。
題目28：說一下你對閉包的理解。
閉包是支持一等函數的編程語言（Python、JavaScript等）中實現詞法綁定的一種技術。當捕捉閉包的時候，它的自由變量（在函數外部定義但在函數內部使用的變量）會在捕捉時被確定，這樣即便脫離了捕捉時的上下文，它也能照常運行。簡單的說，可以將閉包理解爲能夠讀取其他函數內部變量的函數。正在情況下，函數的局部變量在函數調用結束之後就結束了生命週期，但是閉包使得局部變量的生命週期得到了延展。使用閉包的時候需要注意，閉包會使得函數中創建的對象不會被垃圾回收，可能會導致很大的內存開銷，所以閉包一定不能濫用。
題目29：說一下Python中的多線程和多進程的應用場景和優缺點。
線程是操作系統分配CPU的基本單位，進程是操作系統分配內存的基本單位。通常我們運行的程序會包含一個或多個進程，而每個進程中又包含一個或多個線程。多線程的優點在於多個線程可以共享進程的內存空間，所以進程間的通信非常容易實現；但是如果使用官方的CPython解釋器，多線程受制於GIL（全局解釋器鎖），並不能利用CPU的多核特性，這是一個很大的問題。使用多進程可以充分利用CPU的多核特性，但是進程間通信相對比較麻煩，需要使用IPC機制（管道、套接字等）。
多線程適合那些會花費大量時間在I/O操作上，但沒有太多並行計算需求且不需佔用太多內存的I/O密集型應用。多進程適合執行計算密集型任務（如：視頻編碼解碼、數據處理、科學計算等）、可以分解爲多個並行子任務並能合併子任務執行結果的任務以及在內存使用方面沒有任何限制且不強依賴於I/O操作的任務。
擴展：Python中實現併發編程通常有多線程、多進程和異步編程三種選擇。異步編程實現了協作式併發，通過多個相互協作的子程序的用戶態切換，實現對CPU的高效利用，這種方式也是非常適合I/O密集型應用的。
題目30：說一下Python 2和Python 3的區別。
點評：這種問題千萬不要背所謂的參考答案，說一些自己最熟悉的就足夠了。
Python 2中的print和exec都是關鍵字，在Python 3中變成了函數。
Python 3中沒有long類型，整數都是int類型。
Python 2中的不等號<>在Python 3中被廢棄，統一使用!=。
Python 2中的xrange函數在Python 3中被range函數取代。
Python 3對Python 2中不安全的input函數做出了改進，廢棄了raw_input函數。
Python 2中的file函數被Python 3中的open函數取代。
Python 2中的/運算對於int類型是整除，在Python 3中要用//來做整除除法。
Python 3中改進了Python 2捕獲異常的代碼，很明顯Python 3的寫法更合理。
Python 3生成式中循環變量的作用域得到了更好的控制，不會影響到生成式之外的同名變量。
Python 3中的round函數可以返回int或float類型，Python 2中的round函數返回float類型。
Python 3的str類型是Unicode字符串，Python 2的str類型是字節串，相當於Python 3中的bytes。
Python 3中的比較運算符必須比較同類對象。
Python 3中定義類的都是新式類，Python 2中定義的類有新式類（顯式繼承自object的類）和舊式類（經典類）之分，新式類和舊式類在MRO問題上有非常顯著的區別，新式類可以使用**class__`屬性獲取自身類型，新式類可以使用`__slots**魔法。
Python 3對代碼縮進的要求更加嚴格，如果混用空格和製表鍵會引發TabError。
Python 3中字典的keys、values、items方法都不再返回list對象，而是返回view object，內置的map、filter等函數也不再返回list對象，而是返回迭代器對象。
Python 3標準庫中某些模塊的名字跟Python 2是有區別的；而在三方庫方面，有些三方庫只支持Python 2，有些只能支持Python 3。
題目31：談談你對“猴子補丁”（monkey patching）的理解。
“猴子補丁”是動態類型語言的一個特性，代碼運行時在不修改源代碼的前提下改變代碼中的方法、屬性、函數等以達到熱補丁（hot patch）的效果。很多系統的安全補丁也是通過猴子補丁的方式來實現的，但實際開發中應該避免對猴子補丁的使用，以免造成代碼行爲不一致的問題。
在使用gevent庫的時候，我們會在代碼開頭的地方執行gevent.monkey.patch_all()，這行代碼的作用是把標準庫中的socket模塊給替換掉，這樣我們在使用socket的時候，不用修改任何代碼就可以實現對代碼的協程化，達到提升性能的目的，這就是對猴子補丁的應用。
另外，如果希望用ujson三方庫替換掉標準庫中的json，也可以使用猴子補丁的方式，代碼如下所示。
import json, ujson
json.__name__ = 'ujson'
json.dumps = ujson.dumps
json.loads = ujson.loads
1
2
3
4
5
6
單元測試中的Mock技術也是對猴子補丁的應用，Python中的unittest.mock模塊就是解決單元測試中用Mock對象替代被測對象所依賴的對象的模塊。
題目32：閱讀下面的代碼說出運行結果。
class A:
def who(self):
print('A', end='')
class B(A):
def who(self):
super(B, self).who()
print('B', end='')
class C(A):
def who(self):
super(C, self).who()
print('C', end='')
class D(B, C):
def who(self):
super(D, self).who()
print('D', end='')
item = D()
item.who()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
點評：這道題考查到了兩個知識點：
Python中的MRO（方法解析順序）。在沒有多重繼承的情況下，向對象發出一個消息，如果對象沒有對應的方法，那麼向上（父類）搜索的順序是非常清晰的。如果向上追溯到object類（所有類的父類）都沒有找到對應的方法，那麼將會引發AttributeError異常。但是有多重繼承尤其是出現菱形繼承（鑽石繼承）的時候，向上追溯到底應該找到那個方法就得確定MRO。Python 3中的類以及Python 2中的新式類使用C3算法來確定MRO，它是一種類似於廣度優先搜索的方法；Python 2中的舊式類（經典類）使用深度優先搜索來確定MRO。在搞不清楚MRO的情況下，可以使用類的mro方法或**mro**屬性來獲得類的MRO列表。
super()函數的使用。在使用super函數時，可以通過super(類型, 對象)來指定對哪個對象以哪個類爲起點向上搜索父類方法。所以上面B類代碼中的super(B, self).who()表示以B類爲起點，向上搜索self（D類對象）的who方法，所以會找到C類中的who方法，因爲D類對象的MRO列表是D --> B --> C --> A --> object。
ACBD
1
2
題目33：編寫一個函數實現對逆波蘭表達式求值，不能使用Python的內置函數。
點評：逆波蘭表達式也稱爲“後綴表達式”，相較於平常我們使用的“中綴表達式”，逆波蘭表達式不需要括號來確定運算的優先級，例如5 * (2 + 3)對應的逆波蘭表達式是5 2 3 + *。逆波蘭表達式求值需要藉助棧結構，掃描表達式遇到運算數就入棧，遇到運算符就出棧兩個元素做運算，將運算結果入棧。表達式掃描結束後，棧中只有一個數，這個數就是最終的運算結果，直接出棧即可。
import operator
class Stack:
"""棧（FILO）"""
def __init__(self):
self.elems = []
def push(self, elem):
"""入棧"""
self.elems.append(elem)
def pop(self):
"""出棧"""
return self.elems.pop()
@property
def is_empty(self):
"""檢查棧是否爲空"""
return len(self.elems) == 0
def eval_suffix(expr):
"""逆波蘭表達式求值"""
operators = {
'+': operator.add,
'-': operator.sub,
'*': operator.mul,
'/': operator.truediv
}
stack = Stack()
for item in expr.split():
if item.isdigit():
stack.push(float(item))
else:
num2 = stack.pop()
num1 = stack.pop()
stack.push(operators[item](num1, num2))
return stack.pop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
題目34：Python中如何實現字符串替換操作？
Python中實現字符串替換大致有兩類方法：字符串的replace方法和正則表達式的sub方法。
方法一：使用字符串的replace方法。
message = 'hello, world!'
print(message.replace('o', 'O').replace('l', 'L').replace('he', 'HE'))
1
2
3
方法二：使用正則表達式的sub方法。
import re
message = 'hello, world!'
pattern = re.compile('[aeiou]')
print(pattern.sub('#', message))
1
2
3
4
5
6
擴展：還有一個相關的面試題，對保存文件名的列表排序，要求文件名按照字母表和數字大小進行排序，例如對於列表filenames = ['a12.txt', 'a8.txt', 'b10.txt', 'b2.txt', 'b19.txt', 'a3.txt']，排序的結果是['a3.txt', 'a8.txt', 'a12.txt', 'b2.txt', 'b10.txt', 'b19.txt']。提示一下，可以通過字符串替換的方式爲文件名補位，根據補位後的文件名用sorted函數來排序，大家可以思考下這個問題如何解決。
題目35：如何剖析Python代碼的執行性能？
剖析代碼性能可以使用Python標準庫中的cProfile和pstats模塊，cProfile的run函數可以執行代碼並收集統計信息，創建出Stats對象並打印簡單的剖析報告。Stats是pstats模塊中的類，它是一個統計對象。當然，也可以使用三方工具line_profiler和memory_profiler來剖析每一行代碼耗費的時間和內存，這兩個三方工具都會用非常友好的方式輸出剖析結構。如果使用PyCharm，可以利用“Run”菜單的“Profile”菜單項對代碼進行性能分析，PyCharm中可以用表格或者調用圖（Call Graph）的方式來顯示性能剖析的結果。
下面是使用cProfile剖析代碼性能的例子。
example.py
import cProfile
def is_prime(num):
for factor in range(2, int(num ** 0.5) + 1):
if num % factor == 0:
return False
return True
class PrimeIter:
def __init__(self, total):
self.counter = 0
self.current = 1
self.total = total
def __iter__(self):
return self
def __next__(self):
if self.counter < self.total:
self.current += 1
while not is_prime(self.current):
self.current += 1
self.counter += 1
return self.current
raise StopIteration()
cProfile.run('list(PrimeIter(10000))')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
如果使用line_profiler三方工具，可以直接剖析is_prime函數每行代碼的性能，需要給is_prime函數添加一個profiler裝飾器，代碼如下所示。
@profiler
def is_prime(num):
for factor in range(2, int(num ** 0.5) + 1):
if num % factor == 0:
return False
return True
1
2
3
4
5
6
7
安裝line_profiler。
pip install line_profiler
1
2
使用line_profiler。
kernprof -lv example.py
1
2
運行結果如下所示。
Line # Hits Time Per Hit % Time Line Contents
==============================================================
1 @profile
2 def is_prime(num):
3 86624 48420.0 0.6 50.5 for factor in range(2, int(num ** 0.5) + 1):
4 85624 44000.0 0.5 45.9 if num % factor == 0:
5 6918 3080.0 0.4 3.2 return False
6 1000 430.0 0.4 0.4 return True
1
2
3
4
5
6
7
8
9
題目36：如何使用`random`模塊生成隨機數、實現隨機亂序和隨機抽樣？
點評：送人頭的題目，因爲Python標準庫中的常用模塊應該是Python開發者都比較熟悉的內容，這個問題回如果答不上來，整個面試基本也就砸鍋了。
random.random()函數可以生成[0.0, 1.0)之間的隨機浮點數。
random.uniform(a, b)函數可以生成[a, b]或[b, a]之間的隨機浮點數。
random.randint(a, b)函數可以生成[a, b]或[b, a]之間的隨機整數。
random.shuffle(x)函數可以實現對序列x的原地隨機亂序。
random.choice(seq)函數可以從非空序列中取出一個隨機元素。
random.choices(population, weights=None, *, cum_weights=None, k=1)函數可以從總體中隨機抽取（有放回抽樣）出容量爲k的樣本並返回樣本的列表，可以通過參數指定個體的權重，如果沒有指定權重，個體被選中的概率均等。
random.sample(population, k)函數可以從總體中隨機抽取（無放回抽樣）出容量爲k的樣本並返回樣本的列表。
擴展：random模塊提供的函數除了生成均勻分佈的隨機數外，還可以生成其他分佈的隨機數，例如random.gauss(mu, sigma)函數可以生成高斯分佈（正態分佈）的隨機數；random.paretovariate(alpha)函數會生成帕累託分佈的隨機數；random.gammavariate(alpha, beta)函數會生成伽馬分佈的隨機數。
題目37：解釋一下線程池的工作原理。
點評：池化技術就是一種典型空間換時間的策略，我們使用的數據庫連接池、線程池等都是池化技術的應用，Python標準庫currrent.futures模塊的ThreadPoolExecutor就是線程池的實現，如果要弄清楚它的工作原理，可以參考下面的內容。
線程池是一種用於減少線程本身創建和銷燬造成的開銷的技術，屬於典型的空間換時間操作。如果應用程序需要頻繁的將任務派發到線程中執行，線程池就是必選項，因爲創建和釋放線程涉及到大量的系統底層操作，開銷較大，如果能夠在應用程序工作期間，將創建和釋放線程的操作變成預創建和借還操作，將大大減少底層開銷。線程池在應用程序啓動後，立即創建一定數量的線程，放入空閒隊列中。這些線程最開始都處於阻塞狀態，不會消耗CPU資源，但會佔用少量的內存空間。當任務到來後，從隊列中取出一個空閒線程，把任務派發到這個線程中運行，並將該線程標記爲已佔用。當線程池中所有的線程都被佔用後，可以選擇自動創建一定數量的新線程，用於處理更多的任務，也可以選擇讓任務排隊等待直到有空閒的線程可用。在任務執行完畢後，線程並不退出結束，而是繼續保持在池中等待下一次的任務。當系統比較空閒時，大部分線程長時間處於閒置狀態時，線程池可以自動銷燬一部分線程，回收系統資源。基於這種預創建技術，線程池將線程創建和銷燬本身所帶來的開銷分攤到了各個具體的任務上，執行次數越多，每個任務所分擔到的線程本身開銷則越小。
一般線程池都必須具備下面幾個組成部分：
線程池管理器：用於創建並管理線程池。
工作線程和線程隊列：線程池中實際執行的線程以及保存這些線程的容器。
任務接口：將線程執行的任務抽象出來，形成任務接口，確保線程池與具體的任務無關。
任務隊列：線程池中保存等待被執行的任務的容器。
題目38：舉例說明什麼情況下會出現`KeyError`、`TypeError`、`ValueError`。
舉一個簡單的例子，變量a是一個字典，執行int(a['x'])這個操作就有可能引發上述三種類型的異常。如果字典中沒有鍵x，會引發KeyError；如果鍵x對應的值不是str、float、int、bool以及bytes-like類型，在調用int函數構造int類型的對象時，會引發TypeError；如果a[x]是一個字符串或者字節串，而對應的內容又無法處理成int時，將引發ValueError。
題目39：說出下面代碼的運行結果。
def extend_list(val, items=[]):
items.append(val)
return items
list1 = extend_list(10)
list2 = extend_list(123, [])
list3 = extend_list('a')
print(list1)
print(list2)
print(list3)
1
2
3
4
5
6
7
8
9
10
11
點評：Python函數在定義的時候，默認參數items的值就被計算出來了，即[]。因爲默認參數items引用了對象[]，每次調用該函數，如果對items引用的列表進行了操作，下次調用時，默認參數還是引用之前的那個列表而不是重新賦值爲[]，所以列表中會有之前添加的元素。如果通過傳參的方式爲items重新賦值，那麼items將引用到新的列表對象，而不再引用默認的那個列表對象。這個題在面試中經常被問到，通常不建議使用容器類型的默認參數，像PyLint這樣的代碼檢查工具也會對這種代碼提出質疑和警告。
[10, 'a']
[123]
[10, 'a']
1
2
3
4
題目40：如何讀取大文件，例如內存只有4G，如何讀取一個大小爲8G的文件？
很顯然4G內存要一次性的加載大小爲8G的文件是不現實的，遇到這種情況必須要考慮多次讀取和分批次處理。在Python中讀取文件可以先通過open函數獲取文件對象，在讀取文件時，可以通過read方法的size參數指定讀取的大小，也可以通過seek方法的offset參數指定讀取的位置，這樣就可以控制單次讀取數據的字節數和總字節數。除此之外，可以使用內置函數iter將文件對象處理成迭代器對象，每次只讀取少量的數據進行處理，代碼大致寫法如下所示。
with open('...', 'rb') as file:
for data in iter(lambda: file.read(2097152), b''):
pass
1
2
3
4
在Linux系統上，可以通過split命令將大文件切割爲小片，然後通過讀取切割後的小文件對數據進行處理。例如下面的命令將名爲filename的大文件切割爲大小爲512M的多個文件。
split -b 512m filename
1
2
如果願意， 也可以將名爲filename的文件切割爲10個文件，命令如下所示。
split -n 10 filename
1
2
擴展：外部排序跟上述的情況非常類似，由於處理的數據不能一次裝入內存，只能放在讀寫較慢的外存儲器（通常是硬盤）上。“排序-歸併算法”就是一種常用的外部排序策略。在排序階段，先讀入能放在內存中的數據量，將其排序輸出到一個臨時文件，依此進行，將待排序數據組織爲多個有序的臨時文件，然後在歸併階段將這些臨時文件組合爲一個大的有序文件，這個大的有序文件就是排序的結果。
題目41：說一下你對Python中模塊和包的理解。
每個Python文件就是一個模塊，而保存這些文件的文件夾就是一個包，但是這個作爲Python包的文件夾必須要有一個名爲__init__.py的文件，否則無法導入這個包。通常一個文件夾下還可以有子文件夾，這也就意味着一個包下還可以有子包，子包中的__init__.py並不是必須的。模塊和包解決了Python中命名衝突的問題，不同的包下可以有同名的模塊，不同的模塊下可以有同名的變量、函數或類。在Python中可以使用import或from ... import ...來導入包和模塊，在導入的時候還可以使用as關鍵字對包、模塊、類、函數、變量等進行別名，從而徹底解決編程中尤其是多人協作團隊開發時的命名衝突問題。
題目42：說一下你知道的Python編碼規範。
點評：企業的Python編碼規範基本上是參照PEP-8或谷歌開源項目風格指南來制定的，後者還提到了可以使用Lint工具來檢查代碼的規範程度，面試的時候遇到這類問題，可以先說下這兩個參照標準，然後挑重點說一下Python編碼的注意事項。
空格的使用
使用空格來表示縮進而不要用製表符（Tab）。
和語法相關的每一層縮進都用4個空格來表示。
每行的字符數不要超過79個字符，如果表達式因太長而佔據了多行，除了首行之外的其餘各行都應該在正常的縮進寬度上再加上4個空格。
函數和類的定義，代碼前後都要用兩個空行進行分隔。
在同一個類中，各個方法之間應該用一個空行進行分隔。
二元運算符的左右兩側應該保留一個空格，而且只要一個空格就好。
標識符命名
變量、函數和屬性應該使用小寫字母來拼寫，如果有多個單詞就使用下劃線進行連接。
類中受保護的實例屬性，應該以一個下劃線開頭。
類中私有的實例屬性，應該以兩個下劃線開頭。
類和異常的命名，應該每個單詞首字母大寫。
模塊級別的常量，應該採用全大寫字母，如果有多個單詞就用下劃線進行連接。
類的實例方法，應該把第一個參數命名爲self以表示對象自身。
類的類方法，應該把第一個參數命名爲cls以表示該類自身。
表達式和語句
採用內聯形式的否定詞，而不要把否定詞放在整個表達式的前面。例如：if a is not b就比if not a is b更容易讓人理解。
不要用檢查長度的方式來判斷字符串、列表等是否爲None或者沒有元素，應該用if not x這樣的寫法來檢查它。
就算if分支、for循環、except異常捕獲等中只有一行代碼，也不要將代碼和if、for、except等寫在一起，分開寫纔會讓代碼更清晰。
import語句總是放在文件開頭的地方。
引入模塊的時候，from math import sqrt比import math更好。
如果有多個import語句，應該將其分爲三部分，從上到下分別是Python標準模塊、第三方模塊和自定義模塊，每個部分內部應該按照模塊名稱的字母表順序來排列。
題目43：運行下面的代碼是否會報錯，如果報錯請說明哪裏有什麼樣的錯，如果不報錯請說出代碼的執行結果。
class A:
def __init__(self, value):
self.__value = value
@property
def value(self):
return self.__value
obj = A(1)
obj.__value = 2
print(obj.value)
print(obj.__value)
1
2
3
4
5
6
7
8
9
10
11
12
13
點評：這道題有兩個考察點，一個考察點是對_和__開頭的對象屬性訪問權限以及@property裝飾器的瞭解，另外一個考察的點是對動態語言的理解，不需要過多的解釋。
1
2
1
2
3
擴展：如果不希望代碼運行時動態的給對象添加新屬性，可以在定義類時使用__slots__魔法。例如，我們可以在上面的A中添加一行__slots__ = ('__value', )，再次運行上面的代碼，將會在原來的第10行處產生AttributeError錯誤。
題目44：對下面給出的字典按值從大到小對鍵進行排序。
prices = {
'AAPL': 191.88,
'GOOG': 1186.96,
'IBM': 149.24,
'ORCL': 48.44,
'ACN': 166.89,
'FB': 208.09,
'SYMC': 21.29
}
1
2
3
4
5
6
7
8
9
10
點評：sorted函數的高階用法在面試的時候經常出現，key參數可以傳入一個函數名或一個Lambda函數，該函數的返回值代表了在排序時比較元素的依據。
sorted(prices, key=lambda x: prices[x], reverse=True)
1
題目45：說一下`namedtuple`的用法和作用。
點評：Python標準庫的collections模塊提供了很多有用的數據結構，這些內容並不是每個開發者都清楚，就比如題目問到的namedtuple，在我參加過的面試中，90%的面試者都不能準確的說出它的作用和應用場景。此外，deque也是一個非常有用但又經常被忽視的類，還有Counter、OrderedDict 、defaultdict 、UserDict等類，大家清楚它們的用法嗎？
在使用面向對象編程語言的時候，定義類是最常見的一件事情，有的時候，我們會用到只有屬性沒有方法的類，這種類的對象通常只用於組織數據，並不能接收消息，所以我們把這種類稱爲數據類或者退化的類，就像C語言中的結構體那樣。我們並不建議使用這種退化的類，在Python中可以用namedtuple（命名元組）來替代這種類。
from collections import namedtuple
Card = namedtuple('Card', ('suite', 'face'))
card1 = Card('紅桃', 13)
card2 = Card('草花', 5)
print(f'{card1.suite}{card1.face}')
print(f'{card2.suite}{card2.face}')
1
2
3
4
5
6
7
8
命名元組與普通元組一樣是不可變容器，一旦將數據存儲在namedtuple的頂層屬性中，數據就不能再修改了，也就意味着對象上的所有屬性都遵循“一次寫入，多次讀取”的原則。和普通元組不同的是，命名元組中的數據有訪問名稱，可以通過名稱而不是索引來獲取保存的數據，不僅在操作上更加簡單，代碼的可讀性也會更好。
命名元組的本質就是一個類，所以它還可以作爲父類創建子類。除此之外，命名元組內置了一系列的方法，例如，可以通過_asdict方法將命名元組處理成字典，也可以通過_replace方法創建命名元組對象的淺拷貝。
class MyCard(Card):
def show(self):
faces = ['', 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
return f'{self.suite}{faces[self.face]}'
print(Card) # <class '__main__.Card'>
card3 = MyCard('方塊', 12)
print(card3.show()) # 方塊Q
print(dict(card1._asdict())) # {'suite': '紅桃', 'face': 13}
print(card2._replace(suite='方塊')) # Card(suite='方塊', face=5)
1
2
3
4
5
6
7
8
9
10
11
12
13
總而言之，命名元組能更好的組織數據結構，讓代碼更加清晰和可讀，在很多場景下是元組、字典和數據類的替代品。在需要創建佔用空間更少的不可變類時，命名元組就是很好的選擇。
題目46：按照題目要求寫出對應的函數。
要求：寫一個函數，傳入一個有若干個整數的列表，該列表中某個元素出現的次數超過了50%，返回這個元素。
def more_than_half(items):
temp, times = None, 0
for item in items:
if times == 0:
temp = item
times += 1
else:
if item == temp:
times += 1
else:
times -= 1
return temp
1
2
3
4
5
6
7
8
9
10
11
12
13
點評：LeetCode上的題目，在Python面試中出現過，利用元素出現次數超過了50%這一特徵，出現和temp相同的元素就將計數值加1，出現和temp不同的元素就將計數值減1。如果計數值爲0，說明之前出現的元素已經對最終的結果沒有影響，用temp記下當前元素並將計數值置爲1。最終，出現次數超過了50%的這個元素一定會被賦值給變量temp。
題目47：按照題目要求寫出對應的函數。
要求：寫一個函數，傳入的參數是一個列表（列表中的元素可能也是一個列表），返回該列表最大的嵌套深度。例如：列表[1, 2, 3]的嵌套深度爲1，列表[[1], [2, [3]]]的嵌套深度爲3。
def list_depth(items):
if isinstance(items, list):
max_depth = 1
for item in items:
max_depth = max(list_depth(item) + 1, max_depth)
return max_depth
return 0
1
2
3
4
5
6
7
8
點評：看到題目應該能夠比較自然的想到使用遞歸的方式檢查列表中的每個元素。
題目48：按照題目要求寫出對應的裝飾器。
要求：有一個通過網絡獲取數據的函數（可能會因爲網絡原因出現異常），寫一個裝飾器讓這個函數在出現指定異常時可以重試指定的次數，並在每次重試之前隨機延遲一段時間，最長延遲時間可以通過參數進行控制。
方法一：
from functools import wraps
from random import random
from time import sleep
def retry(*, retry_times=3, max_wait_secs=5, errors=(Exception, )):
def decorate(func):
@wraps(func)
def wrapper(*args, **kwargs):
for _ in range(retry_times):
try:
return func(*args, **kwargs)
except errors:
sleep(random() * max_wait_secs)
return None
return wrapper
return decorate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
方法二：
from functools import wraps
from random import random
from time import sleep
class Retry(object):
def __init__(self, *, retry_times=3, max_wait_secs=5, errors=(Exception, )):
self.retry_times = retry_times
self.max_wait_secs = max_wait_secs
self.errors = errors
def __call__(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
for _ in range(self.retry_times):
try:
return func(*args, **kwargs)
except self.errors:
sleep(random() * self.max_wait_secs)
return None
return wrapper
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
點評：我們不止一次強調過，裝飾器幾乎是Python面試必問內容，這個題目比之前的題目稍微複雜一些，它需要的是一個參數化的裝飾器。
題目49：寫一個函數實現字符串反轉，儘可能寫出你知道的所有方法。
點評：爛大街的題目，基本上算是送人頭的題目。
方法一：反向切片
def reverse_string(content):
return content[::-1]
1
2
3
方法二：反轉拼接
def reverse_string(content):
return ''.join(reversed(content))
1
2
3
方法三：遞歸調用
def reverse_string(content):
if len(content) <= 1:
return content
return reverse_string(content[1:]) + content[0]
1
2
3
4
5
方法四：雙端隊列
from collections import deque
def reverse_string(content):
q = deque()
q.extendleft(content)
return ''.join(q)
1
2
3
4
5
6
7
方法五：反向組裝
from io import StringIO
def reverse_string(content):
buffer = StringIO()
for i in range(len(content) - 1, -1, -1):
buffer.write(content[i])
return buffer.getvalue()
1
2
3
4
5
6
7
8
方法六：反轉拼接
def reverse_string(content):
return ''.join([content[i] for i in range(len(content) - 1, -1, -1)])
1
2
3
方法七：半截交換
def reverse_string(content):
length, content= len(content), list(content)
for i in range(length // 2):
content[i], content[length - 1 - i] = content[length - 1 - i], content[i]
return ''.join(content)
1
2
3
4
5
6
方法八：對位交換
def reverse_string(content):
length, content= len(content), list(content)
for i, j in zip(range(length // 2), range(length - 1, length // 2 - 1, -1)):
content[i], content[j] = content[j], content[i]
return ''.join(content)
1
2
3
4
5
6
擴展：這些方法其實都是大同小異的，面試的時候能夠給出幾種有代表性的就足夠了。給大家留一個思考題，上面這些方法，哪些做法的性能較好呢？我們之前提到過剖析代碼性能的方法，大家可以用這些方法來檢驗下你給出的答案是否正確。
題目50：按照題目要求寫出對應的函數。
要求：列表中有1000000個元素，取值範圍是[1000, 10000)，設計一個函數找出列表中的重複元素。
def find_dup(items: list):
dups = [0] * 9000
for item in items:
dups[item - 1000] += 1
for idx, val in enumerate(dups):
if val > 1:
yield idx + 1000
1
2
3
4
5
6
7
8
點評：這道題的解法和計數排序的原理一致，雖然元素的數量非常多，但是取值範圍[1000, 10000)並不是很大，只有9000個可能的取值，所以可以用一個能夠保存9000個元素的dups列表來記錄每個元素出現的次數，dups列表所有元素的初始值都是0，通過對items列表中元素的遍歷，當出現某個元素時，將dups列表對應位置的值加1，最後dups列表中值大於1的元素對應的就是items列表中重複出現過的元素。
題目001: 在Python中如何實現單例模式。
點評：單例模式是指讓一個類只能創建出唯一的實例，這個題目在面試中出現的頻率極高，因爲它考察的不僅僅是單例模式，更是對Python語言到底掌握到何種程度，建議大家用裝飾器和元類這兩種方式來實現單例模式，因爲這兩種方式的通用性最強，而且也可以順便展示自己對裝飾器和元類中兩個關鍵知識點的理解。
方法一：使用裝飾器實現單例模式。
from functools import wraps
def singleton(cls):
"""單例類裝飾器"""
instances = {}
@wraps(cls)
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton
class President:
pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
擴展：裝飾器是Python中非常有特色的語法，用一個函數去裝飾另一個函數或類，爲其添加額外的能力。通常通過裝飾來實現的功能都屬橫切關注功能，也就是跟正常的業務邏輯沒有必然聯繫，可以動態添加或移除的功能。裝飾器可以爲代碼提供緩存、代理、上下文環境等服務，它是對設計模式中代理模式的踐行。在寫裝飾器的時候，帶裝飾功能的函數（上面代碼中的wrapper函數）通常都會用functools模塊中的wraps再加以裝飾，這個裝飾器最重要的作用是給被裝飾的類或函數動態添加一個__wrapped__屬性，這個屬性會將被裝飾之前的類或函數保留下來，這樣在我們不需要裝飾功能的時候，可以通過它來取消裝飾器，例如可以使用President = President.__wrapped__來取消對President類做的單例處理。需要提醒大家的是：上面的單例並不是線程安全的，如果要做到線程安全，需要對創建對象的代碼進行加鎖的處理。在Python中可以使用threading模塊的RLock對象來提供鎖，可以使用鎖對象的acquire和release方法來實現加鎖和解鎖的操作。當然，更爲簡便的做法是使用鎖對象的with上下文語法來進行隱式的加鎖和解鎖操作。
方法二：使用元類實現單例模式。
class SingletonMeta(type):
"""自定義單例元類"""
def __init__(cls, *args, **kwargs):
cls.__instance = None
super().__init__(*args, **kwargs)
def __call__(cls, *args, **kwargs):
if cls.__instance is None:
cls.__instance = super().__call__(*args, **kwargs)
return cls.__instance
class President(metaclass=SingletonMeta):
pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
擴展：Python是面向對象的編程語言，在面向對象的世界中，一切皆爲對象。對象是通過類來創建的，而類本身也是對象，類這樣的對象是通過元類來創建的。我們在定義類時，如果沒有給一個類指定父類，那麼默認的父類是object，如果沒有給一個類指定元類，那麼默認的元類是type。通過自定義的元類，我們可以改變一個類默認的行爲，就如同上面的代碼中，我們通過元類的__call__魔術方法，改變了President類的構造器那樣。
補充：關於單例模式，在面試中還有可能被問到它的應用場景。通常一個對象的狀態是被其他對象共享的，就可以將其設計爲單例，例如項目中使用的數據庫連接池對象和配置對象通常都是單例，這樣才能保證所有地方獲取到的數據庫連接和配置信息是完全一致的；而且由於對象只有唯一的實例，因此從根本上避免了重複創建對象造成的時間和空間上的開銷，也避免了對資源的多重佔用。再舉個例子，項目中的日誌操作通常也會使用單例模式，這是因爲共享的日誌文件一直處於打開狀態，只能有一個實例去操作它，否則在寫入日誌的時候會產生混亂。
題目002：不使用中間變量，交換兩個變量`a`和`b`的值。
點評：典型的送人頭的題目，通常交換兩個變量需要藉助一箇中間變量，如果不允許使用中間變量，在其他編程語言中可以使用異或運算的方式來實現交換兩個變量的值，但是Python中有更爲簡單明瞭的做法。
方法一：
a = a ^ b
b = a ^ b
a = a ^ b
1
2
3
4
方法二：
a, b = b, a
1
2
擴展：需要注意，a, b = b, a這種做法其實並不是元組解包，雖然很多人都這樣認爲。Python字節碼指令中有ROT_TWO指令來支持這個操作，類似的還有ROT_THREE，對於3個以上的元素，如a, b, c, d = b, c, d, a，纔會用到創建元組和元組解包。想知道你的代碼對應的字節碼指令，可以使用Python標準庫中dis模塊的dis函數來反彙編你的Python代碼。
題目003：寫一個刪除列表中重複元素的函數，要求去重後元素相對位置保持不變。
點評：這個題目在初中級Python崗位面試的時候經常出現，題目源於《Python Cookbook》這本書第一章的第10個問題，有很多面試題其實都是這本書上的原題，所以建議大家有時間好好研讀一下這本書。
def dedup(items):
no_dup_items = []
seen = set()
for item in items:
if item not in seen:
no_dup_items.append(item)
seen.add(item)
return no_dup_items
1
2
3
4
5
6
7
8
9
如果願意也可以把上面的函數改造成一個生成器，代碼如下所示。
def dedup(items):
seen = set()
for item in items:
if item not in seen:
yield item
seen.add(item)
1
2
3
4
5
6
7
擴展：由於Python中的集合底層使用哈希存儲，所以集合的in和not in成員運算在性能上遠遠優於列表，所以上面的代碼我們使用了集合來保存已經出現過的元素。集合中的元素必須是hashable對象，因此上面的代碼在列表元素不是hashable對象時會失效，要解決這個問題可以給函數增加一個參數，該參數可以設計爲返回哈希碼或hashable對象的函數。
題目004：假設你使用的是官方的CPython，說出下面代碼的運行結果。
點評：下面的程序對實際開發並沒有什麼意義，但卻是CPython中的一個大坑，這道題旨在考察面試者對官方的Python解釋器到底瞭解到什麼程度。
a, b, c, d = 1, 1, 1000, 1000
print(a is b, c is d)
def foo():
e = 1000
f = 1000
print(e is f, e is d)
g = 1
print(g is a)
foo()
1
2
3
4
5
6
7
8
9
10
11
12
運行結果：
True False
True False
True
1
2
3
4
上面代碼中a is b的結果是True但c is d的結果是False，這一點的確讓人費解。CPython解釋器出於性能優化的考慮，把頻繁使用的整數對象用一個叫small_ints的對象池緩存起來造成的。small_ints緩存的整數值被設定爲[-5, 256]這個區間，也就是說，在任何引用這些整數的地方，都不需要重新創建int對象，而是直接引用緩存池中的對象。如果整數不在該範圍內，那麼即便兩個整數的值相同，它們也是不同的對象。
CPython底層爲了進一步提升性能還做了另一個設定，對於同一個代碼塊中值不在small_ints緩存範圍內的整數，如果同一個代碼塊中已經存在一個值與其相同的整數對象，那麼就直接引用該對象，否則創建新的int對象。需要大家注意的是，這條規則對數值型適用，但對字符串則需要考慮字符串的長度，這一點大家可以自行證明。
擴展：如果你用PyPy（另一種Python解釋器實現，支持JIT，對CPython的缺點進行了改良，在性能上優於CPython，但對三方庫的支持略差）來運行上面的代碼，你會發現所有的輸出都是True。
題目005：Lambda函數是什麼，舉例說明的它的應用場景。
點評：這個題目主要想考察的是Lambda函數的應用場景，潛臺詞是問你在項目中有沒有使用過Lambda函數，具體在什麼場景下會用到Lambda函數，藉此來判斷你寫代碼的能力。因爲Lambda函數通常用在高階函數中，主要的作用是通過向函數傳入函數或讓函數返回函數最終實現代碼的解耦合。
Lambda函數也叫匿名函數，它是功能簡單用一行代碼就能實現的小型函數。Python中的Lambda函數只能寫一個表達式，這個表達式的執行結果就是函數的返回值，不用寫return關鍵字。Lambda函數因爲沒有名字，所以也不會跟其他函數發生命名衝突的問題。
擴展：面試的時候有可能還會考你用Lambda函數來實現一些功能，也就是用一行代碼來實現題目要求的功能，例如：用一行代碼實現求階乘的函數，用一行代碼實現求最大公約數的函數等。
fac = lambda x: __import__('functools').reduce(int.__mul__, range(1, x + 1), 1)
gcd = lambda x, y: y % x and gcd(y % x, x) or x
1
2
3
Lambda函數其實最爲主要的用途是把一個函數傳入另一個高階函數（如Python內置的filter、map等）中來爲函數做解耦合，增強函數的靈活性和通用性。下面的例子通過使用filter和map函數，實現了從列表中篩選出奇數並求平方構成新列表的操作，因爲用到了高階函數，過濾和映射數據的規則都是函數的調用者通過另外一個函數傳入的，因此這filter和map函數沒有跟特定的過濾和映射數據的規則耦合在一起。
items = [12, 5, 7, 10, 8, 19]
items = list(map(lambda x: x ** 2, filter(lambda x: x % 2, items)))
print(items) # [25, 49, 361]
1
2
3
4
擴展：用列表的生成式來實現上面的代碼會更加簡單明瞭，代碼如下所示。
items = [12, 5, 7, 10, 8, 19]
items = [x ** 2 for x in items if x % 2]
print(items) # [25, 49, 361]
1
2
3
4
題目006：說說Python中的淺拷貝和深拷貝。
點評：這個題目本身出現的頻率非常高，但是就題論題而言沒有什麼技術含量。對於這種面試題，在回答的時候一定要讓你的答案能夠超出面試官的預期，這樣才能獲得更好的印象分。所以回答這個題目的要點不僅僅是能夠說出淺拷貝和深拷貝的區別，深拷貝的時候可能遇到的兩大問題，還要說出Python標準庫對淺拷貝和深拷貝的支持，然後可以說說列表、字典如何實現拷貝操作以及如何通過序列化和反序列的方式實現深拷貝，最後還可以提到設計模式中的原型模式以及它在項目中的應用。
淺拷貝通常只複製對象本身，而深拷貝不僅會複製對象，還會遞歸的複製對象所關聯的對象。深拷貝可能會遇到兩個問題：一是一個對象如果直接或間接的引用了自身，會導致無休止的遞歸拷貝；二是深拷貝可能對原本設計爲多個對象共享的數據也進行拷貝。Python通過copy模塊中的copy和deepcopy函數來實現淺拷貝和深拷貝操作，其中deepcopy可以通過memo字典來保存已經拷貝過的對象，從而避免剛纔所說的自引用遞歸問題；此外，可以通過copyreg模塊的pickle函數來定製指定類型對象的拷貝行爲。
deepcopy函數的本質其實就是對象的一次序列化和一次返回序列化，面試題中還考過用自定義函數實現對象的深拷貝操作，顯然我們可以使用pickle模塊的dumps和loads來做到，代碼如下所示。
import pickle
my_deep_copy = lambda obj: pickle.loads(pickle.dumps(obj))
1
2
3
4
列表的切片操作[:]相當於實現了列表對象的淺拷貝，而字典的copy方法可以實現字典對象的淺拷貝。對象拷貝其實是更爲快捷的創建對象的方式。在Python中，通過構造器創建對象屬於兩階段構造，首先是分配內存空間，然後是初始化。在創建對象時，我們也可以基於“原型”對象來創建新對象，通過對原型對象的拷貝（複製內存）就完成了對象的創建和初始化，這種做法更加高效，這也就是設計模式中的原型模式。在Python中，我們可以通過元類的方式來實現原型模式，代碼如下所示。
import copy
class PrototypeMeta(type):
"""實現原型模式的元類"""
def __init__(cls, *args, **kwargs):
super().__init__(*args, **kwargs)
# 爲對象綁定clone方法來實現對象拷貝
cls.clone = lambda self, is_deep=True: \
copy.deepcopy(self) if is_deep else copy.copy(self)
class Person(metaclass=PrototypeMeta):
pass
p1 = Person()
p2 = p1.clone() # 深拷貝
p3 = p1.clone(is_deep=False) # 淺拷貝
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
題目007：Python是如何實現內存管理的？
點評：當面試官問到這個問題的時候，一個展示自己的機會就擺在面前了。你要先反問面試官：“你說的是官方的CPython解釋器嗎？”。這個反問可以展示出你瞭解過Python解釋器的不同的實現版本，而且你也知道面試官想問的是CPython。當然，很多面試官對不同的Python解釋器底層實現到底有什麼差別也沒有概念。所以，千萬不要覺得面試官一定比你強，懷揣着這份自信可以讓你更好的完成面試。
Python提供了自動化的內存管理，也就是說內存空間的分配與釋放都是由Python解釋器在運行時自動進行的，自動管理內存功能極大的減輕程序員的工作負擔，也能夠幫助程序員在一定程度上解決內存泄露的問題。以CPython解釋器爲例，它的內存管理有三個關鍵點：引用計數、標記清理、分代收集。
引用計數：對於CPython解釋器來說，Python中的每一個對象其實就是PyObject結構體，它的內部有一個名爲ob_refcnt 的引用計數器成員變量。程序在運行的過程中ob_refcnt的值會被更新並藉此來反映引用有多少個變量引用到該對象。當對象的引用計數值爲0時，它的內存就會被釋放掉。
typedef struct _object {
_PyObject_HEAD_EXTRA
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
} PyObject;
1
2
3
4
5
6
以下情況會導致引用計數加1：
對象被創建
對象被引用
對象作爲參數傳入到一個函數中
對象作爲元素存儲到一個容器中
以下情況會導致引用計數減1：
用del語句顯示刪除對象引用
對象引用被重新賦值其他對象
一個對象離開它所在的作用域
持有該對象的容器自身被銷燬
持有該對象的容器刪除該對象
可以通過sys模塊的getrefcount函數來獲得對象的引用計數。引用計數的內存管理方式在遇到循環引用的時候就會出現致命傷，因此需要其他的垃圾回收算法對其進行補充。
標記清理：CPython使用了“標記-清理”（Mark and Sweep）算法解決容器類型可能產生的循環引用問題。該算法在垃圾回收時分爲兩個階段：標記階段，遍歷所有的對象，如果對象是可達的（被其他對象引用），那麼就標記該對象爲可達；清除階段，再次遍歷對象，如果發現某個對象沒有標記爲可達，則就將其回收。CPython底層維護了兩個雙端鏈表，一個鏈表存放着需要被掃描的容器對象（姑且稱之爲鏈表A），另一個鏈表存放着臨時不可達對象（姑且稱之爲鏈表B）。爲了實現“標記-清理”算法，鏈表中的每個節點除了有記錄當前引用計數的ref_count變量外，還有一個gc_ref變量，這個gc_ref是ref_count的一個副本，所以初始值爲ref_count的大小。執行垃圾回收時，首先遍歷鏈表A中的節點，並且將當前對象所引用的所有對象的gc_ref減1，這一步主要作用是解除循環引用對引用計數的影響。再次遍歷鏈表A中的節點，如果節點的gc_ref值爲0，那麼這個對象就被標記爲“暫時不可達”（GC_TENTATIVELY_UNREACHABLE）並被移動到鏈表B中；如果節點的gc_ref不爲0，那麼這個對象就會被標記爲“可達“（GC_REACHABLE），對於”可達“對象，還要遞歸的將該節點可以到達的節點標記爲”可達“；鏈表B中被標記爲”可達“的節點要重新放回到鏈表A中。在兩次遍歷之後，鏈表B中的節點就是需要釋放內存的節點。
分代回收：在循環引用對象的回收中，整個應用程序會被暫停，爲了減少應用程序暫停的時間，Python 通過分代回收（空間換時間）的方法提高垃圾回收效率。分代回收的基本思想是：對象存在的時間越長，是垃圾的可能性就越小，應該儘量不對這樣的對象進行垃圾回收。CPython將對象分爲三種世代分別記爲0、1、2，每一個新生對象都在第0代中，如果該對象在一輪垃圾回收掃描中存活下來，那麼它將被移到第1代中，存在於第1代的對象將較少的被垃圾回收掃描到；如果在對第1代進行垃圾回收掃描時，這個對象又存活下來，那麼它將被移至第2代中，在那裏它被垃圾回收掃描的次數將會更少。分代回收掃描的門限值可以通過gc模塊的get_threshold函數來獲得，該函數返回一個三元組，分別表示多少次內存分配操作後會執行0代垃圾回收，多少次0代垃圾回收後會執行1代垃圾回收，多少次1代垃圾回收後會執行2代垃圾回收。需要說明的是，如果執行一次2代垃圾回收，那麼比它年輕的代都要執行垃圾回收。如果想修改這幾個門限值，可以通過gc模塊的set_threshold函數來做到。
題目008：說一下你對Python中迭代器和生成器的理解。
點評：很多人面試者都會寫迭代器和生成器，但是卻無法準確的解釋什麼是迭代器和生成器。如果你也有同樣的困惑，可以參考下面的回答。
迭代器是實現了迭代器協議的對象。跟其他編程語言不通，Python中沒有用於定義協議或表示約定的關鍵字，像interface、protocol這些單詞並不在Python語言的關鍵字列表中。Python語言通過魔法方法來表示約定，也就是我們所說的協議，而__next__和__iter__這兩個魔法方法就代表了迭代器協議。可以通過for-in循環從迭代器對象中取出值，也可以使用next函數取出迭代器對象中的下一個值。生成器是迭代器的語法升級版本，可以用更爲簡單的代碼來實現一個迭代器。
擴展：面試中經常讓寫生成斐波那契數列的迭代器，大家可以參考下面的代碼。
class Fib(object):
def __init__(self, num):
self.num = num
self.a, self.b = 0, 1
self.idx = 0
def __iter__(self):
return self
def __next__(self):
if self.idx < self.num:
self.a, self.b = self.b, self.a + self.b
self.idx += 1
return self.a
raise StopIteration()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
如果用生成器的語法來改寫上面的代碼，代碼會簡單優雅很多。
def fib(num):
a, b = 0, 1
for _ in range(num):
a, b = b, a + b
yield a
1
2
3
4
5
6
題目009：正則表達式的match方法和search方法有什麼區別？
點評：正則表達式是字符串處理的重要工具，所以也是面試中經常考察的知識點。在Python中，使用正則表達式有兩種方式，一種是直接調用re模塊中的函數，傳入正則表達式和需要處理的字符串；一種是先通過re模塊的compile函數創建正則表達式對象，然後再通過對象調用方法並傳入需要處理的字符串。如果一個正則表達式被頻繁的使用，我們推薦用re.compile函數創建正則表達式對象，這樣會減少頻繁編譯同一個正則表達式所造成的開銷。
match方法是從字符串的起始位置進行正則表達式匹配，返回Match對象或None。search方法會掃描整個字符串來找尋匹配的模式，同樣也是返回Match對象或None。
題目010：下面這段代碼的執行結果是什麼。
def multiply():
return [lambda x: i * x for i in range(4)]
print([m(100) for m in multiply()])
1
2
3
4
5
運行結果：
[300, 300, 300, 300]
1
2
上面代碼的運行結果很容易被誤判爲[0, 100, 200, 300]。首先需要注意的是multiply函數用生成式語法返回了一個列表，列表中保存了4個Lambda函數，這4個Lambda函數會返回傳入的參數乘以i的結果。需要注意的是這裏有閉包（closure）現象，multiply函數中的局部變量i的生命週期被延展了，由於i最終的值是3，所以通過m(100)調列表中的Lambda函數時會返回300，而且4個調用都是如此。
如果想得到[0, 100, 200, 300]這個結果，可以按照下面幾種方式來修改multiply函數。
方法一：使用生成器，讓函數獲得i的當前值。
def multiply():
return (lambda x: i * x for i in range(4))
print([m(100) for m in multiply()])
1
2
3
4
5
或者
def multiply():
for i in range(4):
yield lambda x: x * i
print([m(100) for m in multiply()])
1
2
3
4
5
6
方法二：使用偏函數，徹底避開閉包。
from functools import partial
from operator import __mul__
def multiply():
return [partial(__mul__, i) for i in range(4)]
print([m(100) for m in multiply()])
1
2
3
4
5
6
7
8
題目011：Python中爲什麼沒有函數重載？
點評：C++、Java、C#等諸多編程語言都支持函數重載，所謂函數重載指的是在同一個作用域中有多個同名函數，它們擁有不同的參數列表（參數個數不同或參數類型不同或二者皆不同），可以相互區分。重載也是一種多態性，因爲通常是在編譯時通過參數的個數和類型來確定到底調用哪個重載函數，所以也被稱爲編譯時多態性或者叫前綁定。這個問題的潛臺詞其實是問面試者是否有其他編程語言的經驗，是否理解Python是動態類型語言，是否知道Python中函數的可變參數、關鍵字參數這些概念。
首先Python是解釋型語言，函數重載現象通常出現在編譯型語言中。其次Python是動態類型語言，函數的參數沒有類型約束，也就無法根據參數類型來區分重載。再者Python中函數的參數可以有默認值，可以使用可變參數和關鍵字參數，因此即便沒有函數重載，也要可以讓一個函數根據調用者傳入的參數產生不同的行爲。
題目012：用Python代碼實現Python內置函數max。
點評：這個題目看似簡單，但實際上還是比較考察面試者的功底。因爲Python內置的max函數既可以傳入可迭代對象找出最大，又可以傳入兩個或多個參數找出最大；最爲關鍵的是還可以通過命名關鍵字參數key來指定一個用於元素比較的函數，還可以通過default命名關鍵字參數來指定當可迭代對象爲空時返回的默認值。
下面的代碼僅供參考：
def my_max(*args, key=None, default=None):
"""
獲取可迭代對象中最大的元素或兩個及以上實參中最大的元素
:param args: 一個可迭代對象或多個元素
:param key: 提取用於元素比較的特徵值的函數，默認爲None
:param default: 如果可迭代對象爲空則返回該默認值，如果沒有給默認值則引發ValueError異常
:return: 返回可迭代對象或多個元素中的最大元素
"""
if len(args) == 1 and len(args[0]) == 0:
if default:
return default
else:
raise ValueError('max() arg is an empty sequence')
items = args[0] if len(args) == 1 else args
max_elem, max_value = items[0], items[0]
if key:
max_value = key(max_value)
for item in items:
value = item
if key:
value = key(item)
if value > max_value:
max_elem, max_value = item, value
return max_elem
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
題目013：寫一個函數統計傳入的列表中每個數字出現的次數並返回對應的字典。
點評：送人頭的題目，不解釋。
def count_letters(items):
result = {}
for item in items:
if isinstance(item, (int, float)):
result[item] = result.get(item, 0) + 1
return result
1
2
3
4
5
6
7
也可以直接使用Python標準庫中collections模塊的Counter類來解決這個問題，Counter是dict的子類，它會將傳入的序列中的每個元素作爲鍵，元素出現的次數作爲值來構造字典。
from collections import Counter
def count_letters(items):
counter = Counter(items)
return {key: value for key, value in counter.items() \
if isinstance(key, (int, float))}
1
2
3
4
5
6
7
題目014：使用Python代碼實現遍歷一個文件夾的操作。
點評：基本也是送人頭的題目，只要用過os模塊就應該知道怎麼做。
Python標準庫os模塊的walk函數提供了遍歷一個文件夾的功能，它返回一個生成器。
import os
g = os.walk('/Users/Hao/Downloads/')
for path, dir_list, file_list in g:
for dir_name in dir_list:
print(os.path.join(path, dir_name))
for file_name in file_list:
print(os.path.join(path, file_name))
1
2
3
4
5
6
7
8
9
說明：os.path模塊提供了很多進行路徑操作的工具函數，在項目開發中也是經常會用到的。如果題目明確要求不能使用os.walk函數，那麼可以使用os.listdir函數來獲取指定目錄下的文件和文件夾，然後再通過循環遍歷用os.isdir函數判斷哪些是文件夾，對於文件夾可以通過遞歸調用進行遍歷，這樣也可以實現遍歷一個文件夾的操作。
題目015：現有2元、3元、5元共三種面額的貨幣，如果需要找零99元，一共有多少種找零的方式？
點評：還有一個非常類似的題目：“一個小朋友走樓梯，一次可以走1個臺階、2個臺階或3個臺階，問走完10個臺階一共有多少種走法？”，這兩個題目的思路是一樣，如果用遞歸函數來寫的話非常簡單。
from functools import lru_cache
@lru_cache()
def change_money(total):
if total == 0:
return 1
if total < 0:
return 0
return change_money(total - 2) + change_money(total - 3) + \
change_money(total - 5)
1
2
3
4
5
6
7
8
9
10
11
12
說明：在上面的代碼中，我們用lru_cache裝飾器裝飾了遞歸函數change_money，如果不做這個優化，上面代碼的漸近時間複雜度將會是，而如果參數total的值是99，這個運算量是非常巨大的。lru_cache裝飾器會緩存函數的執行結果，這樣就可以減少重複運算所造成的開銷，這是空間換時間的策略，也是動態規劃的編程思想。
題目016：寫一個函數，給定矩陣的階數`n`，輸出一個螺旋式數字矩陣。
例如：n = 2，返回：
1 2
4 3
1
2
3
例如：n = 3，返回：
1 2 3
8 9 4
7 6 5
1
2
3
4
這個題目本身並不複雜，下面的代碼僅供參考。
def show_spiral_matrix(n):
matrix = [[0] * n for _ in range(n)]
row, col = 0, 0
num, direction = 1, 0
while num <= n ** 2:
if matrix[row][col] == 0:
matrix[row][col] = num
num += 1
if direction == 0:
if col < n - 1 and matrix[row][col + 1] == 0:
col += 1
else:
direction += 1
elif direction == 1:
if row < n - 1 and matrix[row + 1][col] == 0:
row += 1
else:
direction += 1
elif direction == 2:
if col > 0 and matrix[row][col - 1] == 0:
col -= 1
else:
direction += 1
else:
if row > 0 and matrix[row - 1][col] == 0:
row -= 1
else:
direction += 1
direction %= 4
for x in matrix:
for y in x:
print(y, end='\t')
print()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
題目017：閱讀下面的代碼，寫出程序的運行結果。
items = [1, 2, 3, 4]
print([i for i in items if i > 2])
print([i for i in items if i % 2])
print([(x, y) for x, y in zip('abcd', (1, 2, 3, 4, 5))])
print({x: f'item{x ** 2}' for x in (2, 4, 6)})
print(len({x for x in 'hello world' if x not in 'abcdefg'}))
1
2
3
4
5
6
7
點評：生成式（推導式）屬於Python的特色語法之一，幾乎是面試必考內容。Python中通過生成式字面量語法，可以創建出列表、集合、字典。
[3, 4]
[1, 3]
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
{2: 'item4', 4: 'item16', 6: 'item36'}
6
1
2
3
4
5
6
題目018：說出下面代碼的運行結果。
class Parent:
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
點評：運行上面的代碼首先輸出1 1 1，這一點大家應該沒有什麼疑問。接下來，通過Child1.x = 2給類Child1重新綁定了屬性x並賦值爲2，所以Child1.x會輸出2，而Parent和Child2並不受影響。執行Parent.x = 3會重新給Parent類的x屬性賦值爲3，由於Child2的x屬性繼承自Parent，所以Child2.x的值也是3；而之前我們爲Child1重新綁定了x屬性，那麼它的x屬性值不會受到Parent.x = 3的影響，還是之前的值2。
1 1 1
1 2 1
3 2 3
1
2
3
4
題目19：說說你用過Python標準庫中的哪些模塊。
點評：Python標準庫中的模塊非常多，建議大家根據自己過往的項目經歷來介紹你用過的標準庫和三方庫，因爲這些是你最爲熟悉的，經得起面試官深挖的。
模塊名 介紹
sys 跟Python解釋器相關的變量和函數，例如：sys.version、sys.exit()
os 和操作系統相關的功能，例如：os.listdir()、os.remove()
re 和正則表達式相關的功能，例如：re.compile()、re.search()
math 和數學運算相關的功能，例如：math.pi、math.e、math.cos
logging 和日誌系統相關的類和函數，例如：logging.Logger、logging.Handler
json / pickle 實現對象序列化和反序列的模塊，例如：json.loads、json.dumps
hashlib 封裝了多種哈希摘要算法的模塊，例如：hashlib.md5、hashlib.sha1
urllib 包含了和URL相關的子模塊，例如：urllib.request、urllib.parse
itertools 提供各種迭代器的模塊，例如：itertools.cycle、itertools.product
functools 函數相關工具模塊，例如：functools.partial、functools.lru_cache
collections / heapq 封裝了常用數據結構和算法的模塊，例如：collections.deque
threading / multiprocessing 多線程/多進程相關類和函數的模塊，例如：threading.Thread
concurrent.futures / asyncio 併發編程/異步編程相關的類和函數的模塊，例如：ThreadPoolExecutor
base64 提供BASE-64編碼相關函數的模塊，例如：bas64.encode
csv 和讀寫CSV文件相關的模塊，例如：csv.reader、csv.writer
profile / cProfile / pstats 和代碼性能剖析相關的模塊，例如：cProfile.run、pstats.Stats
unittest 和單元測試相關的模塊，例如：unittest.TestCase
題目20：`init__`和`__new`方法有什麼區別？
Python中調用構造器創建對象屬於兩階段構造過程，首先執行__new__方法獲得保存對象所需的內存空間，再通過__init__執行對內存空間數據的填充（對象屬性的初始化）。__new__方法的返回值是創建好的Python對象（的引用），而__init__方法的第一個參數就是這個對象（的引用），所以在__init__中可以完成對對象的初始化操作。__new__是類方法，它的第一個參數是類，__init__是對象方法，它的第一個參數是對象。
題目21：輸入年月日，判斷這個日期是這一年的第幾天。
方法一：不使用標準庫中的模塊和函數。
def is_leap_year(year):
"""判斷指定的年份是不是閏年，平年返回False，閏年返回True"""
return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
def which_day(year, month, date):
"""計算傳入的日期是這一年的第幾天"""
# 用嵌套的列表保存平年和閏年每個月的天數
days_of_month = [
[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
[31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
]
days = days_of_month[is_leap_year(year)][:month - 1]
return sum(days) + date
1
2
3
4
5
6
7
8
9
10
11
12
13
14
方法二：使用標準庫中的datetime模塊。
import datetime
def which_day(year, month, date):
end = datetime.date(year, month, date)
start = datetime.date(year, 1, 1)
return (end - start).days + 1
1
2
3
4
5
6
7
題目22：平常工作中用什麼工具進行靜態代碼分析。
點評：靜態代碼分析工具可以從代碼中提煉出各種靜態屬性，這使得開發者可以對代碼的複雜性、可維護性和可讀性有更好的瞭解，這裏所說的靜態屬性包括：
代碼是否符合編碼規範，例如：PEP-8。
代碼中潛在的問題，包括：語法錯誤、縮進問題、導入缺失、變量覆蓋等。
代碼中的壞味道。
代碼的複雜度。
代碼的邏輯問題。
工作中靜態代碼分析主要用到的是Pylint和Flake8。Pylint可以檢查出代碼錯誤、壞味道、不規範的代碼等問題，較新的版本中還提供了代碼複雜度統計數據，可以生成檢查報告。Flake8封裝了Pyflakes（檢查代碼邏輯錯誤）、McCabe（檢查代碼複雜性）和Pycodestyle（檢查代碼是否符合PEP-8規範）工具，它可以執行這三個工具提供的檢查。
題目23：說一下你知道的Python中的魔術方法。
點評：魔術方法也稱爲魔法方法，是Python中的特色語法，也是面試中的高頻問題。
魔術方法 作用
__new__、__init__、__del__ 創建和銷燬對象相關
__add__、__sub__、__mul__、__div__、__floordiv__、__mod__ 算術運算符相關
__eq__、__ne__、__lt__、__gt__、__le__、__ge__ 關係運算符相關
__pos__、__neg__、__invert__ 一元運算符相關
__lshift__、__rshift__、__and__、__or__、__xor__ 位運算相關
__enter__、__exit__ 上下文管理器協議
__iter__、__next__、__reversed__ 迭代器協議
__int__、__long__、__float__、__oct__、__hex__ 類型/進制轉換相關
__str__、__repr__、__hash__、__dir__ 對象表述相關
__len__、__getitem__、__setitem__、__contains__、__missing__ 序列相關
__copy__、__deepcopy__ 對象拷貝相關
__call__、__setattr__、__getattr__、__delattr__ 其他魔術方法
題目24：函數參數`arg`和`*kwargs`分別代表什麼？
Python中，函數的參數分爲位置參數、可變參數、關鍵字參數、命名關鍵字參數。*args代表可變參數，可以接收0個或任意多個參數，當不確定調用者會傳入多少個位置參數時，就可以使用可變參數，它會將傳入的參數打包成一個元組。**kwargs代表關鍵字參數，可以接收用參數名=參數值的方式傳入的參數，傳入的參數的會打包成一個字典。定義函數時如果同時使用*args和**kwargs，那麼函數可以接收任意參數。
題目25：寫一個記錄函數執行時間的裝飾器。
點評：高頻面試題，也是最簡單的裝飾器，面試者必須要掌握的內容。
方法一：用函數實現裝飾器。
from functools import wraps
from time import time
def record_time(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time()
result = func(*args, **kwargs)
print(f'{func.__name__}執行時間: {time() - start}秒')
return result
return wrapper
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
方法二：用類實現裝飾器。類有__call__魔術方法，該類對象就是可調用對象，可以當做裝飾器來使用。
from functools import wraps
from time import time
class Record:
def __call__(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time()
result = func(*args, **kwargs)
print(f'{func.__name__}執行時間: {time() - start}秒')
return result
return wrapper
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
說明：裝飾器可以用來裝飾類或函數，爲其提供額外的能力，屬於設計模式中的代理模式。
擴展：裝飾器本身也可以參數化，例如上面的例子中，如果不希望在終端中顯示函數的執行時間而是希望由調用者來決定如何輸出函數的執行時間，可以通過參數化裝飾器的方式來做到，代碼如下所示。
from functools import wraps
from time import time
def record_time(output):
"""可以參數化的裝飾器"""
def decorate(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time()
result = func(*args, **kwargs)
output(func.__name__, time() - start)
return result
return wrapper
return decorate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
題目26：什麼是鴨子類型（duck typing）？
鴨子類型是動態類型語言判斷一個對象是不是某種類型時使用的方法，也叫做鴨子判定法。簡單的說，鴨子類型是指判斷一隻鳥是不是鴨子，我們只關心它游泳像不像鴨子、叫起來像不像鴨子、走路像不像鴨子就足夠了。換言之，如果對象的行爲跟我們的預期是一致的（能夠接受某些消息），我們就認定它是某種類型的對象。
在Python語言中，有很多bytes-like對象（如：bytes、bytearray、array.array、memoryview）、file-like對象（如：StringIO、BytesIO、GzipFile、socket）、path-like對象（如：str、bytes），其中file-like對象都能支持read和write操作，可以像文件一樣讀寫，這就是所謂的對象有鴨子的行爲就可以判定爲鴨子的判定方法。再比如Python中列表的extend方法，它需要的參數並不一定要是列表，只要是可迭代對象就沒有問題。
說明：動態語言的鴨子類型使得設計模式的應用被大大簡化。
題目27：說一下Python中變量的作用域。
Python中有四種作用域，分別是局部作用域（Local）、嵌套作用域（Embedded）、全局作用域（Global）、內置作用域（Built-in），搜索一個標識符時，會按照LEGB的順序進行搜索，如果所有的作用域中都沒有找到這個標識符，就會引發NameError異常。
題目28：說一下你對閉包的理解。
閉包是支持一等函數的編程語言（Python、JavaScript等）中實現詞法綁定的一種技術。當捕捉閉包的時候，它的自由變量（在函數外部定義但在函數內部使用的變量）會在捕捉時被確定，這樣即便脫離了捕捉時的上下文，它也能照常運行。簡單的說，可以將閉包理解爲能夠讀取其他函數內部變量的函數。正在情況下，函數的局部變量在函數調用結束之後就結束了生命週期，但是閉包使得局部變量的生命週期得到了延展。使用閉包的時候需要注意，閉包會使得函數中創建的對象不會被垃圾回收，可能會導致很大的內存開銷，所以閉包一定不能濫用。
題目29：說一下Python中的多線程和多進程的應用場景和優缺點。
線程是操作系統分配CPU的基本單位，進程是操作系統分配內存的基本單位。通常我們運行的程序會包含一個或多個進程，而每個進程中又包含一個或多個線程。多線程的優點在於多個線程可以共享進程的內存空間，所以進程間的通信非常容易實現；但是如果使用官方的CPython解釋器，多線程受制於GIL（全局解釋器鎖），並不能利用CPU的多核特性，這是一個很大的問題。使用多進程可以充分利用CPU的多核特性，但是進程間通信相對比較麻煩，需要使用IPC機制（管道、套接字等）。
多線程適合那些會花費大量時間在I/O操作上，但沒有太多並行計算需求且不需佔用太多內存的I/O密集型應用。多進程適合執行計算密集型任務（如：視頻編碼解碼、數據處理、科學計算等）、可以分解爲多個並行子任務並能合併子任務執行結果的任務以及在內存使用方面沒有任何限制且不強依賴於I/O操作的任務。
擴展：Python中實現併發編程通常有多線程、多進程和異步編程三種選擇。異步編程實現了協作式併發，通過多個相互協作的子程序的用戶態切換，實現對CPU的高效利用，這種方式也是非常適合I/O密集型應用的。
題目30：說一下Python 2和Python 3的區別。
點評：這種問題千萬不要背所謂的參考答案，說一些自己最熟悉的就足夠了。
Python 2中的print和exec都是關鍵字，在Python 3中變成了函數。
Python 3中沒有long類型，整數都是int類型。
Python 2中的不等號<>在Python 3中被廢棄，統一使用!=。
Python 2中的xrange函數在Python 3中被range函數取代。
Python 3對Python 2中不安全的input函數做出了改進，廢棄了raw_input函數。
Python 2中的file函數被Python 3中的open函數取代。
Python 2中的/運算對於int類型是整除，在Python 3中要用//來做整除除法。
Python 3中改進了Python 2捕獲異常的代碼，很明顯Python 3的寫法更合理。
Python 3生成式中循環變量的作用域得到了更好的控制，不會影響到生成式之外的同名變量。
Python 3中的round函數可以返回int或float類型，Python 2中的round函數返回float類型。
Python 3的str類型是Unicode字符串，Python 2的str類型是字節串，相當於Python 3中的bytes。
Python 3中的比較運算符必須比較同類對象。
Python 3中定義類的都是新式類，Python 2中定義的類有新式類（顯式繼承自object的類）和舊式類（經典類）之分，新式類和舊式類在MRO問題上有非常顯著的區別，新式類可以使用**class__`屬性獲取自身類型，新式類可以使用`__slots**魔法。
Python 3對代碼縮進的要求更加嚴格，如果混用空格和製表鍵會引發TabError。
Python 3中字典的keys、values、items方法都不再返回list對象，而是返回view object，內置的map、filter等函數也不再返回list對象，而是返回迭代器對象。
Python 3標準庫中某些模塊的名字跟Python 2是有區別的；而在三方庫方面，有些三方庫只支持Python 2，有些只能支持Python 3。
題目31：談談你對“猴子補丁”（monkey patching）的理解。
“猴子補丁”是動態類型語言的一個特性，代碼運行時在不修改源代碼的前提下改變代碼中的方法、屬性、函數等以達到熱補丁（hot patch）的效果。很多系統的安全補丁也是通過猴子補丁的方式來實現的，但實際開發中應該避免對猴子補丁的使用，以免造成代碼行爲不一致的問題。
在使用gevent庫的時候，我們會在代碼開頭的地方執行gevent.monkey.patch_all()，這行代碼的作用是把標準庫中的socket模塊給替換掉，這樣我們在使用socket的時候，不用修改任何代碼就可以實現對代碼的協程化，達到提升性能的目的，這就是對猴子補丁的應用。
另外，如果希望用ujson三方庫替換掉標準庫中的json，也可以使用猴子補丁的方式，代碼如下所示。
import json, ujson
json.__name__ = 'ujson'
json.dumps = ujson.dumps
json.loads = ujson.loads
1
2
3
4
5
6
單元測試中的Mock技術也是對猴子補丁的應用，Python中的unittest.mock模塊就是解決單元測試中用Mock對象替代被測對象所依賴的對象的模塊。
題目32：閱讀下面的代碼說出運行結果。
class A:
def who(self):
print('A', end='')
class B(A):
def who(self):
super(B, self).who()
print('B', end='')
class C(A):
def who(self):
super(C, self).who()
print('C', end='')
class D(B, C):
def who(self):
super(D, self).who()
print('D', end='')
item = D()
item.who()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
點評：這道題考查到了兩個知識點：
Python中的MRO（方法解析順序）。在沒有多重繼承的情況下，向對象發出一個消息，如果對象沒有對應的方法，那麼向上（父類）搜索的順序是非常清晰的。如果向上追溯到object類（所有類的父類）都沒有找到對應的方法，那麼將會引發AttributeError異常。但是有多重繼承尤其是出現菱形繼承（鑽石繼承）的時候，向上追溯到底應該找到那個方法就得確定MRO。Python 3中的類以及Python 2中的新式類使用C3算法來確定MRO，它是一種類似於廣度優先搜索的方法；Python 2中的舊式類（經典類）使用深度優先搜索來確定MRO。在搞不清楚MRO的情況下，可以使用類的mro方法或**mro**屬性來獲得類的MRO列表。
super()函數的使用。在使用super函數時，可以通過super(類型, 對象)來指定對哪個對象以哪個類爲起點向上搜索父類方法。所以上面B類代碼中的super(B, self).who()表示以B類爲起點，向上搜索self（D類對象）的who方法，所以會找到C類中的who方法，因爲D類對象的MRO列表是D --> B --> C --> A --> object。
ACBD
1
2
題目33：編寫一個函數實現對逆波蘭表達式求值，不能使用Python的內置函數。
點評：逆波蘭表達式也稱爲“後綴表達式”，相較於平常我們使用的“中綴表達式”，逆波蘭表達式不需要括號來確定運算的優先級，例如5 * (2 + 3)對應的逆波蘭表達式是5 2 3 + *。逆波蘭表達式求值需要藉助棧結構，掃描表達式遇到運算數就入棧，遇到運算符就出棧兩個元素做運算，將運算結果入棧。表達式掃描結束後，棧中只有一個數，這個數就是最終的運算結果，直接出棧即可。
import operator
class Stack:
"""棧（FILO）"""
def __init__(self):
self.elems = []
def push(self, elem):
"""入棧"""
self.elems.append(elem)
def pop(self):
"""出棧"""
return self.elems.pop()
@property
def is_empty(self):
"""檢查棧是否爲空"""
return len(self.elems) == 0
def eval_suffix(expr):
"""逆波蘭表達式求值"""
operators = {
'+': operator.add,
'-': operator.sub,
'*': operator.mul,
'/': operator.truediv
}
stack = Stack()
for item in expr.split():
if item.isdigit():
stack.push(float(item))
else:
num2 = stack.pop()
num1 = stack.pop()
stack.push(operators[item](num1, num2))
return stack.pop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
題目34：Python中如何實現字符串替換操作？
Python中實現字符串替換大致有兩類方法：字符串的replace方法和正則表達式的sub方法。
方法一：使用字符串的replace方法。
message = 'hello, world!'
print(message.replace('o', 'O').replace('l', 'L').replace('he', 'HE'))
1
2
3
方法二：使用正則表達式的sub方法。
import re
message = 'hello, world!'
pattern = re.compile('[aeiou]')
print(pattern.sub('#', message))
1
2
3
4
5
6
擴展：還有一個相關的面試題，對保存文件名的列表排序，要求文件名按照字母表和數字大小進行排序，例如對於列表filenames = ['a12.txt', 'a8.txt', 'b10.txt', 'b2.txt', 'b19.txt', 'a3.txt']，排序的結果是['a3.txt', 'a8.txt', 'a12.txt', 'b2.txt', 'b10.txt', 'b19.txt']。提示一下，可以通過字符串替換的方式爲文件名補位，根據補位後的文件名用sorted函數來排序，大家可以思考下這個問題如何解決。
題目35：如何剖析Python代碼的執行性能？
剖析代碼性能可以使用Python標準庫中的cProfile和pstats模塊，cProfile的run函數可以執行代碼並收集統計信息，創建出Stats對象並打印簡單的剖析報告。Stats是pstats模塊中的類，它是一個統計對象。當然，也可以使用三方工具line_profiler和memory_profiler來剖析每一行代碼耗費的時間和內存，這兩個三方工具都會用非常友好的方式輸出剖析結構。如果使用PyCharm，可以利用“Run”菜單的“Profile”菜單項對代碼進行性能分析，PyCharm中可以用表格或者調用圖（Call Graph）的方式來顯示性能剖析的結果。
下面是使用cProfile剖析代碼性能的例子。
example.py
import cProfile
def is_prime(num):
for factor in range(2, int(num ** 0.5) + 1):
if num % factor == 0:
return False
return True
class PrimeIter:
def __init__(self, total):
self.counter = 0
self.current = 1
self.total = total
def __iter__(self):
return self
def __next__(self):
if self.counter < self.total:
self.current += 1
while not is_prime(self.current):
self.current += 1
self.counter += 1
return self.current
raise StopIteration()
cProfile.run('list(PrimeIter(10000))')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
如果使用line_profiler三方工具，可以直接剖析is_prime函數每行代碼的性能，需要給is_prime函數添加一個profiler裝飾器，代碼如下所示。
@profiler
def is_prime(num):
for factor in range(2, int(num ** 0.5) + 1):
if num % factor == 0:
return False
return True
1
2
3
4
5
6
7
安裝line_profiler。
pip install line_profiler
1
2
使用line_profiler。
kernprof -lv example.py
1
2
運行結果如下所示。
Line # Hits Time Per Hit % Time Line Contents
==============================================================
1 @profile
2 def is_prime(num):
3 86624 48420.0 0.6 50.5 for factor in range(2, int(num ** 0.5) + 1):
4 85624 44000.0 0.5 45.9 if num % factor == 0:
5 6918 3080.0 0.4 3.2 return False
6 1000 430.0 0.4 0.4 return True
1
2
3
4
5
6
7
8
9
題目36：如何使用`random`模塊生成隨機數、實現隨機亂序和隨機抽樣？
點評：送人頭的題目，因爲Python標準庫中的常用模塊應該是Python開發者都比較熟悉的內容，這個問題回如果答不上來，整個面試基本也就砸鍋了。
random.random()函數可以生成[0.0, 1.0)之間的隨機浮點數。
random.uniform(a, b)函數可以生成[a, b]或[b, a]之間的隨機浮點數。
random.randint(a, b)函數可以生成[a, b]或[b, a]之間的隨機整數。
random.shuffle(x)函數可以實現對序列x的原地隨機亂序。
random.choice(seq)函數可以從非空序列中取出一個隨機元素。
random.choices(population, weights=None, *, cum_weights=None, k=1)函數可以從總體中隨機抽取（有放回抽樣）出容量爲k的樣本並返回樣本的列表，可以通過參數指定個體的權重，如果沒有指定權重，個體被選中的概率均等。
random.sample(population, k)函數可以從總體中隨機抽取（無放回抽樣）出容量爲k的樣本並返回樣本的列表。
擴展：random模塊提供的函數除了生成均勻分佈的隨機數外，還可以生成其他分佈的隨機數，例如random.gauss(mu, sigma)函數可以生成高斯分佈（正態分佈）的隨機數；random.paretovariate(alpha)函數會生成帕累託分佈的隨機數；random.gammavariate(alpha, beta)函數會生成伽馬分佈的隨機數。
題目37：解釋一下線程池的工作原理。
點評：池化技術就是一種典型空間換時間的策略，我們使用的數據庫連接池、線程池等都是池化技術的應用，Python標準庫currrent.futures模塊的ThreadPoolExecutor就是線程池的實現，如果要弄清楚它的工作原理，可以參考下面的內容。
線程池是一種用於減少線程本身創建和銷燬造成的開銷的技術，屬於典型的空間換時間操作。如果應用程序需要頻繁的將任務派發到線程中執行，線程池就是必選項，因爲創建和釋放線程涉及到大量的系統底層操作，開銷較大，如果能夠在應用程序工作期間，將創建和釋放線程的操作變成預創建和借還操作，將大大減少底層開銷。線程池在應用程序啓動後，立即創建一定數量的線程，放入空閒隊列中。這些線程最開始都處於阻塞狀態，不會消耗CPU資源，但會佔用少量的內存空間。當任務到來後，從隊列中取出一個空閒線程，把任務派發到這個線程中運行，並將該線程標記爲已佔用。當線程池中所有的線程都被佔用後，可以選擇自動創建一定數量的新線程，用於處理更多的任務，也可以選擇讓任務排隊等待直到有空閒的線程可用。在任務執行完畢後，線程並不退出結束，而是繼續保持在池中等待下一次的任務。當系統比較空閒時，大部分線程長時間處於閒置狀態時，線程池可以自動銷燬一部分線程，回收系統資源。基於這種預創建技術，線程池將線程創建和銷燬本身所帶來的開銷分攤到了各個具體的任務上，執行次數越多，每個任務所分擔到的線程本身開銷則越小。
一般線程池都必須具備下面幾個組成部分：
線程池管理器：用於創建並管理線程池。
工作線程和線程隊列：線程池中實際執行的線程以及保存這些線程的容器。
任務接口：將線程執行的任務抽象出來，形成任務接口，確保線程池與具體的任務無關。
任務隊列：線程池中保存等待被執行的任務的容器。
題目38：舉例說明什麼情況下會出現`KeyError`、`TypeError`、`ValueError`。
舉一個簡單的例子，變量a是一個字典，執行int(a['x'])這個操作就有可能引發上述三種類型的異常。如果字典中沒有鍵x，會引發KeyError；如果鍵x對應的值不是str、float、int、bool以及bytes-like類型，在調用int函數構造int類型的對象時，會引發TypeError；如果a[x]是一個字符串或者字節串，而對應的內容又無法處理成int時，將引發ValueError。
題目39：說出下面代碼的運行結果。
def extend_list(val, items=[]):
items.append(val)
return items
list1 = extend_list(10)
list2 = extend_list(123, [])
list3 = extend_list('a')
print(list1)
print(list2)
print(list3)
1
2
3
4
5
6
7
8
9
10
11
點評：Python函數在定義的時候，默認參數items的值就被計算出來了，即[]。因爲默認參數items引用了對象[]，每次調用該函數，如果對items引用的列表進行了操作，下次調用時，默認參數還是引用之前的那個列表而不是重新賦值爲[]，所以列表中會有之前添加的元素。如果通過傳參的方式爲items重新賦值，那麼items將引用到新的列表對象，而不再引用默認的那個列表對象。這個題在面試中經常被問到，通常不建議使用容器類型的默認參數，像PyLint這樣的代碼檢查工具也會對這種代碼提出質疑和警告。
[10, 'a']
[123]
[10, 'a']
1
2
3
4
題目40：如何讀取大文件，例如內存只有4G，如何讀取一個大小爲8G的文件？
很顯然4G內存要一次性的加載大小爲8G的文件是不現實的，遇到這種情況必須要考慮多次讀取和分批次處理。在Python中讀取文件可以先通過open函數獲取文件對象，在讀取文件時，可以通過read方法的size參數指定讀取的大小，也可以通過seek方法的offset參數指定讀取的位置，這樣就可以控制單次讀取數據的字節數和總字節數。除此之外，可以使用內置函數iter將文件對象處理成迭代器對象，每次只讀取少量的數據進行處理，代碼大致寫法如下所示。
with open('...', 'rb') as file:
for data in iter(lambda: file.read(2097152), b''):
pass
1
2
3
4
在Linux系統上，可以通過split命令將大文件切割爲小片，然後通過讀取切割後的小文件對數據進行處理。例如下面的命令將名爲filename的大文件切割爲大小爲512M的多個文件。
split -b 512m filename
1
2
如果願意， 也可以將名爲filename的文件切割爲10個文件，命令如下所示。
split -n 10 filename
1
2
擴展：外部排序跟上述的情況非常類似，由於處理的數據不能一次裝入內存，只能放在讀寫較慢的外存儲器（通常是硬盤）上。“排序-歸併算法”就是一種常用的外部排序策略。在排序階段，先讀入能放在內存中的數據量，將其排序輸出到一個臨時文件，依此進行，將待排序數據組織爲多個有序的臨時文件，然後在歸併階段將這些臨時文件組合爲一個大的有序文件，這個大的有序文件就是排序的結果。
題目41：說一下你對Python中模塊和包的理解。
每個Python文件就是一個模塊，而保存這些文件的文件夾就是一個包，但是這個作爲Python包的文件夾必須要有一個名爲__init__.py的文件，否則無法導入這個包。通常一個文件夾下還可以有子文件夾，這也就意味着一個包下還可以有子包，子包中的__init__.py並不是必須的。模塊和包解決了Python中命名衝突的問題，不同的包下可以有同名的模塊，不同的模塊下可以有同名的變量、函數或類。在Python中可以使用import或from ... import ...來導入包和模塊，在導入的時候還可以使用as關鍵字對包、模塊、類、函數、變量等進行別名，從而徹底解決編程中尤其是多人協作團隊開發時的命名衝突問題。
題目42：說一下你知道的Python編碼規範。
點評：企業的Python編碼規範基本上是參照PEP-8或谷歌開源項目風格指南來制定的，後者還提到了可以使用Lint工具來檢查代碼的規範程度，面試的時候遇到這類問題，可以先說下這兩個參照標準，然後挑重點說一下Python編碼的注意事項。
空格的使用
使用空格來表示縮進而不要用製表符（Tab）。
和語法相關的每一層縮進都用4個空格來表示。
每行的字符數不要超過79個字符，如果表達式因太長而佔據了多行，除了首行之外的其餘各行都應該在正常的縮進寬度上再加上4個空格。
函數和類的定義，代碼前後都要用兩個空行進行分隔。
在同一個類中，各個方法之間應該用一個空行進行分隔。
二元運算符的左右兩側應該保留一個空格，而且只要一個空格就好。
標識符命名
變量、函數和屬性應該使用小寫字母來拼寫，如果有多個單詞就使用下劃線進行連接。
類中受保護的實例屬性，應該以一個下劃線開頭。
類中私有的實例屬性，應該以兩個下劃線開頭。
類和異常的命名，應該每個單詞首字母大寫。
模塊級別的常量，應該採用全大寫字母，如果有多個單詞就用下劃線進行連接。
類的實例方法，應該把第一個參數命名爲self以表示對象自身。
類的類方法，應該把第一個參數命名爲cls以表示該類自身。
表達式和語句
採用內聯形式的否定詞，而不要把否定詞放在整個表達式的前面。例如：if a is not b就比if not a is b更容易讓人理解。
不要用檢查長度的方式來判斷字符串、列表等是否爲None或者沒有元素，應該用if not x這樣的寫法來檢查它。
就算if分支、for循環、except異常捕獲等中只有一行代碼，也不要將代碼和if、for、except等寫在一起，分開寫纔會讓代碼更清晰。
import語句總是放在文件開頭的地方。
引入模塊的時候，from math import sqrt比import math更好。
如果有多個import語句，應該將其分爲三部分，從上到下分別是Python標準模塊、第三方模塊和自定義模塊，每個部分內部應該按照模塊名稱的字母表順序來排列。
題目43：運行下面的代碼是否會報錯，如果報錯請說明哪裏有什麼樣的錯，如果不報錯請說出代碼的執行結果。
class A:
def __init__(self, value):
self.__value = value
@property
def value(self):
return self.__value
obj = A(1)
obj.__value = 2
print(obj.value)
print(obj.__value)
1
2
3
4
5
6
7
8
9
10
11
12
13
點評：這道題有兩個考察點，一個考察點是對_和__開頭的對象屬性訪問權限以及@property裝飾器的瞭解，另外一個考察的點是對動態語言的理解，不需要過多的解釋。
1
2
1
2
3
擴展：如果不希望代碼運行時動態的給對象添加新屬性，可以在定義類時使用__slots__魔法。例如，我們可以在上面的A中添加一行__slots__ = ('__value', )，再次運行上面的代碼，將會在原來的第10行處產生AttributeError錯誤。
題目44：對下面給出的字典按值從大到小對鍵進行排序。
prices = {
'AAPL': 191.88,
'GOOG': 1186.96,
'IBM': 149.24,
'ORCL': 48.44,
'ACN': 166.89,
'FB': 208.09,
'SYMC': 21.29
}
1
2
3
4
5
6
7
8
9
10
點評：sorted函數的高階用法在面試的時候經常出現，key參數可以傳入一個函數名或一個Lambda函數，該函數的返回值代表了在排序時比較元素的依據。
sorted(prices, key=lambda x: prices[x], reverse=True)
1
題目45：說一下`namedtuple`的用法和作用。
點評：Python標準庫的collections模塊提供了很多有用的數據結構，這些內容並不是每個開發者都清楚，就比如題目問到的namedtuple，在我參加過的面試中，90%的面試者都不能準確的說出它的作用和應用場景。此外，deque也是一個非常有用但又經常被忽視的類，還有Counter、OrderedDict 、defaultdict 、UserDict等類，大家清楚它們的用法嗎？
在使用面向對象編程語言的時候，定義類是最常見的一件事情，有的時候，我們會用到只有屬性沒有方法的類，這種類的對象通常只用於組織數據，並不能接收消息，所以我們把這種類稱爲數據類或者退化的類，就像C語言中的結構體那樣。我們並不建議使用這種退化的類，在Python中可以用namedtuple（命名元組）來替代這種類。
from collections import namedtuple
Card = namedtuple('Card', ('suite', 'face'))
card1 = Card('紅桃', 13)
card2 = Card('草花', 5)
print(f'{card1.suite}{card1.face}')
print(f'{card2.suite}{card2.face}')
1
2
3
4
5
6
7
8
命名元組與普通元組一樣是不可變容器，一旦將數據存儲在namedtuple的頂層屬性中，數據就不能再修改了，也就意味着對象上的所有屬性都遵循“一次寫入，多次讀取”的原則。和普通元組不同的是，命名元組中的數據有訪問名稱，可以通過名稱而不是索引來獲取保存的數據，不僅在操作上更加簡單，代碼的可讀性也會更好。
命名元組的本質就是一個類，所以它還可以作爲父類創建子類。除此之外，命名元組內置了一系列的方法，例如，可以通過_asdict方法將命名元組處理成字典，也可以通過_replace方法創建命名元組對象的淺拷貝。
class MyCard(Card):
def show(self):
faces = ['', 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
return f'{self.suite}{faces[self.face]}'
print(Card) # <class '__main__.Card'>
card3 = MyCard('方塊', 12)
print(card3.show()) # 方塊Q
print(dict(card1._asdict())) # {'suite': '紅桃', 'face': 13}
print(card2._replace(suite='方塊')) # Card(suite='方塊', face=5)
1
2
3
4
5
6
7
8
9
10
11
12
13
總而言之，命名元組能更好的組織數據結構，讓代碼更加清晰和可讀，在很多場景下是元組、字典和數據類的替代品。在需要創建佔用空間更少的不可變類時，命名元組就是很好的選擇。
題目46：按照題目要求寫出對應的函數。
要求：寫一個函數，傳入一個有若干個整數的列表，該列表中某個元素出現的次數超過了50%，返回這個元素。
def more_than_half(items):
temp, times = None, 0
for item in items:
if times == 0:
temp = item
times += 1
else:
if item == temp:
times += 1
else:
times -= 1
return temp
1
2
3
4
5
6
7
8
9
10
11
12
13
點評：LeetCode上的題目，在Python面試中出現過，利用元素出現次數超過了50%這一特徵，出現和temp相同的元素就將計數值加1，出現和temp不同的元素就將計數值減1。如果計數值爲0，說明之前出現的元素已經對最終的結果沒有影響，用temp記下當前元素並將計數值置爲1。最終，出現次數超過了50%的這個元素一定會被賦值給變量temp。
題目47：按照題目要求寫出對應的函數。
要求：寫一個函數，傳入的參數是一個列表（列表中的元素可能也是一個列表），返回該列表最大的嵌套深度。例如：列表[1, 2, 3]的嵌套深度爲1，列表[[1], [2, [3]]]的嵌套深度爲3。
def list_depth(items):
if isinstance(items, list):
max_depth = 1
for item in items:
max_depth = max(list_depth(item) + 1, max_depth)
return max_depth
return 0
1
2
3
4
5
6
7
8
點評：看到題目應該能夠比較自然的想到使用遞歸的方式檢查列表中的每個元素。
題目48：按照題目要求寫出對應的裝飾器。
要求：有一個通過網絡獲取數據的函數（可能會因爲網絡原因出現異常），寫一個裝飾器讓這個函數在出現指定異常時可以重試指定的次數，並在每次重試之前隨機延遲一段時間，最長延遲時間可以通過參數進行控制。
方法一：
from functools import wraps
from random import random
from time import sleep
def retry(*, retry_times=3, max_wait_secs=5, errors=(Exception, )):
def decorate(func):
@wraps(func)
def wrapper(*args, **kwargs):
for _ in range(retry_times):
try:
return func(*args, **kwargs)
except errors:
sleep(random() * max_wait_secs)
return None
return wrapper
return decorate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
方法二：
from functools import wraps
from random import random
from time import sleep
class Retry(object):
def __init__(self, *, retry_times=3, max_wait_secs=5, errors=(Exception, )):
self.retry_times = retry_times
self.max_wait_secs = max_wait_secs
self.errors = errors
def __call__(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
for _ in range(self.retry_times):
try:
return func(*args, **kwargs)
except self.errors:
sleep(random() * self.max_wait_secs)
return None
return wrapper
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
點評：我們不止一次強調過，裝飾器幾乎是Python面試必問內容，這個題目比之前的題目稍微複雜一些，它需要的是一個參數化的裝飾器。
題目49：寫一個函數實現字符串反轉，儘可能寫出你知道的所有方法。
點評：爛大街的題目，基本上算是送人頭的題目。
方法一：反向切片
def reverse_string(content):
return content[::-1]
1
2
3
方法二：反轉拼接
def reverse_string(content):
return ''.join(reversed(content))
1
2
3
方法三：遞歸調用
def reverse_string(content):
if len(content) <= 1:
return content
return reverse_string(content[1:]) + content[0]
1
2
3
4
5
方法四：雙端隊列
from collections import deque
def reverse_string(content):
q = deque()
q.extendleft(content)
return ''.join(q)
1
2
3
4
5
6
7
方法五：反向組裝
from io import StringIO
def reverse_string(content):
buffer = StringIO()
for i in range(len(content) - 1, -1, -1):
buffer.write(content[i])
return buffer.getvalue()
1
2
3
4
5
6
7
8
方法六：反轉拼接
def reverse_string(content):
return ''.join([content[i] for i in range(len(content) - 1, -1, -1)])
1
2
3
方法七：半截交換
def reverse_string(content):
length, content= len(content), list(content)
for i in range(length // 2):
content[i], content[length - 1 - i] = content[length - 1 - i], content[i]
return ''.join(content)
1
2
3
4
5
6
方法八：對位交換
def reverse_string(content):
length, content= len(content), list(content)
for i, j in zip(range(length // 2), range(length - 1, length // 2 - 1, -1)):
content[i], content[j] = content[j], content[i]
return ''.join(content)
1
2
3
4
5
6
擴展：這些方法其實都是大同小異的，面試的時候能夠給出幾種有代表性的就足夠了。給大家留一個思考題，上面這些方法，哪些做法的性能較好呢？我們之前提到過剖析代碼性能的方法，大家可以用這些方法來檢驗下你給出的答案是否正確。
題目50：按照題目要求寫出對應的函數。
要求：列表中有1000000個元素，取值範圍是[1000, 10000)，設計一個函數找出列表中的重複元素。
def find_dup(items: list):
dups = [0] * 9000
for item in items:
dups[item - 1000] += 1
for idx, val in enumerate(dups):
if val > 1:
yield idx + 1000
1
2
3
4
5
6
7
8
點評：這道題的解法和計數排序的原理一致，雖然元素的數量非常多，但是取值範圍[1000, 10000)並不是很大，只有9000個可能的取值，所以可以用一個能夠保存9000個元素的dups列表來記錄每個元素出現的次數，dups列表所有元素的初始值都是0，通過對items列表中元素的遍歷，當出現某個元素時，將dups列表對應位置的值加1，最後dups列表中值大於1的元素對應的就是items列表中重複出現過的元素。
---------------------------END---------------------------
轉自
Python面試50題！面試鞏固必看!-CSDN博客
https://blog.csdn.net/Saki_Python/article/details/131956794