Python面試50題！面試鞏固必看!【轉】

題目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列表中重複出現過的元素。