題目001: 在Python中如何實現單例模式。

點評：單例模式是指讓一個類只能創建出唯一的實例，這個題目在面試中出現的頻率極高，因為它考察的不僅僅是單例模式，更是對Python語言到底掌握到何種程度，建議大家用裝飾器和元類這兩種方式來實現單例模式，因為這兩種方式的通用性最強，而且也可以順便展示自己對裝飾器和元類中兩個關鍵知識點的理解。

方法一：使用裝飾器實現單例模式。

from?functools?import?wrapsdef?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

擴展：裝飾器是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?=?Nonesuper().__init__(*args,?**kwargs)def?__call__(cls,?*args,?**kwargs):if?cls.__instance?is?None:cls.__instance?=?super().__call__(*args,?**kwargs)return?cls.__instanceclass?President(metaclass=SingletonMeta):pass

擴展：Python是面向對象的編程語言，在面向對象的世界中，一切皆為對象。對象是通過類來創建的，而類本身也是對象，類這樣的對象是通過元類來創建的。我們在定義類時，如果沒有給一個類指定父類，那么默認的父類是object，如果沒有給一個類指定元類，那么默認的元類是type。通過自定義的元類，我們可以改變一個類默認的行為，就如同上面的代碼中，我們通過元類的__call__魔術方法，改變了President類的構造器那樣。

補充：關于單例模式，在面試中還有可能被問到它的應用場景。通常一個對象的狀態是被其他對象共享的，就可以將其設計為單例，例如項目中使用的數據庫連接池對象和配置對象通常都是單例，這樣才能保證所有地方獲取到的數據庫連接和配置信息是完全一致的；而且由于對象只有唯一的實例，因此從根本上避免了重復創建對象造成的時間和空間上的開銷，也避免了對資源的多重占用。再舉個例子，項目中的日志操作通常也會使用單例模式，這是因為共享的日志文件一直處于打開狀態，只能有一個實例去操作它，否則在寫入日志的時候會產生混亂。

題目002：不使用中間變量，交換兩個變量`a`和`b`的值。

點評：典型的送人頭的題目，通常交換兩個變量需要借助一個中間變量，如果不允許使用中間變量，在其他編程語言中可以使用異或運算的方式來實現交換兩個變量的值，但是Python中有更為簡單明了的做法。

方法一：

a?=?a?^?b b?=?a?^?b a?=?a?^?b

方法二：

a,?b?=?b,?a

擴展：需要注意，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

如果愿意也可以把上面的函數改造成一個生成器，代碼如下所示。

def?dedup(items):seen?=?set()for?item?in?items:if?item?not?in?seen:yield?itemseen.add(item)

擴展：由于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?=?1000f?=?1000print(e?is?f,?e?is?d)g?=?1print(g?is?a)foo()

運行結果：

True?False True?False True

上面代碼中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

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]

擴展：用列表的生成式來實現上面的代碼會更加簡單明了，代碼如下所示。

items?=?[12,?5,?7,?10,?8,?19] items?=?[x?**?2?for?x?in?items?if?x?%?2] print(items)????#?[25,?49,?361]

題目006：說說Python中的淺拷貝和深拷貝。

點評：這個題目本身出現的頻率非常高，但是就題論題而言沒有什么技術含量。對于這種面試題，在回答的時候一定要讓你的答案能夠超出面試官的預期，這樣才能獲得更好的印象分。所以回答這個題目的要點不僅僅是能夠說出淺拷貝和深拷貝的區別，深拷貝的時候可能遇到的兩大問題，還要說出Python標準庫對淺拷貝和深拷貝的支持，然后可以說說列表、字典如何實現拷貝操作以及如何通過序列化和反序列的方式實現深拷貝，最后還可以提到設計模式中的原型模式以及它在項目中的應用。

淺拷貝通常只復制對象本身，而深拷貝不僅會復制對象，還會遞歸的復制對象所關聯的對象。深拷貝可能會遇到兩個問題：一是一個對象如果直接或間接的引用了自身，會導致無休止的遞歸拷貝；二是深拷貝可能對原本設計為多個對象共享的數據也進行拷貝。Python通過copy模塊中的copy和deepcopy函數來實現淺拷貝和深拷貝操作，其中deepcopy可以通過memo字典來保存已經拷貝過的對象，從而避免剛才所說的自引用遞歸問題；此外，可以通過copyreg模塊的pickle函數來定制指定類型對象的拷貝行為。

deepcopy函數的本質其實就是對象的一次序列化和一次返回序列化，面試題中還考過用自定義函數實現對象的深拷貝操作，顯然我們可以使用pickle模塊的dumps和loads來做到，代碼如下所示。

import?picklemy_deep_copy?=?lambda?obj:?pickle.loads(pickle.dumps(obj))

列表的切片操作[:]相當于實現了列表對象的淺拷貝，而字典的copy方法可以實現字典對象的淺拷貝。對象拷貝其實是更為快捷的創建對象的方式。在Python中，通過構造器創建對象屬于兩階段構造，首先是分配內存空間，然后是初始化。在創建對象時，我們也可以基于“原型”對象來創建新對象，通過對原型對象的拷貝（復制內存）就完成了對象的創建和初始化，這種做法更加高效，這也就是設計模式中的原型模式。在Python中，我們可以通過元類的方式來實現原型模式，代碼如下所示。

import?copyclass?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):passp1?=?Person() p2?=?p1.clone()?????????????????#?深拷貝 p3?=?p1.clone(is_deep=False)????#?淺拷貝

題目007：Python是如何實現內存管理的？

點評：當面試官問到這個問題的時候，一個展示自己的機會就擺在面前了。你要先反問面試官：“你說的是官方的CPython解釋器嗎？”。這個反問可以展示出你了解過Python解釋器的不同的實現版本，而且你也知道面試官想問的是CPython。當然，很多面試官對不同的Python解釋器底層實現到底有什么差別也沒有概念。所以，千萬不要覺得面試官一定比你強，懷揣著這份自信可以讓你更好的完成面試。

Python提供了自動化的內存管理，也就是說內存空間的分配與釋放都是由Python解釋器在運行時自動進行的，自動管理內存功能極大的減輕程序員的工作負擔，也能夠幫助程序員在一定程度上解決內存泄露的問題。以CPython解釋器為例，它的內存管理有三個關鍵點：引用計數、標記清理、分代收集。

引用計數：對于CPython解釋器來說，Python中的每一個對象其實就是PyObject結構體，它的內部有一個名為ob_refcnt?的引用計數器成員變量。程序在運行的過程中ob_refcnt的值會被更新并藉此來反映引用有多少個變量引用到該對象。當對象的引用計數值為0時，它的內存就會被釋放掉。

typedef?struct?_object?{_PyObject_HEAD_EXTRAPy_ssize_t?ob_refcnt;struct?_typeobject?*ob_type; }?PyObject;

以下情況會導致引用計數加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?=?numself.a,?self.b?=?0,?1self.idx?=?0def?__iter__(self):return?selfdef?__next__(self):if?self.idx?<?self.num:self.a,?self.b?=?self.b,?self.a?+?self.bself.idx?+=?1return?self.araise?StopIteration() ?

如果用生成器的語法來改寫上面的代碼，代碼會簡單優雅很多。

def?fib(num):a,?b?=?0,?1for?_?in?range(num):a,?b?=?b,?a?+?byield?a

題目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()])

運行結果：

[300,?300,?300,?300]

上面代碼的運行結果很容易被誤判為[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()])

或者

def?multiply():for?i?in?range(4):yield?lambda?x:?x?*?iprint([m(100)?for?m?in?multiply()])

方法二：使用偏函數，徹底避開閉包。

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()])

題目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?defaultelse:raise?ValueError('max()?arg?is?an?empty?sequence')items?=?args[0]?if?len(args)?==?1?else?argsmax_elem,?max_value?=?items[0],?items[0]if?key:max_value?=?key(max_value)for?item?in?items:value?=?itemif?key:value?=?key(item)if?value?>?max_value:max_elem,?max_value?=?item,?valuereturn?max_elem

題目013：寫一個函數統計傳入的列表中每個數字出現的次數并返回對應的字典。

點評：送人頭的題目，不解釋。

def?count_letters(items):result?=?{}for?item?in?items:if?isinstance(item,?(int,?float)):result[item]?=?result.get(item,?0)?+?1return?result

也可以直接使用Python標準庫中collections模塊的Counter類來解決這個問題，Counter是dict的子類，它會將傳入的序列中的每個元素作為鍵，元素出現的次數作為值來構造字典。

from?collections?import?Counterdef?count_letters(items):counter?=?Counter(items)return?{key:?value?for?key,?value?in?counter.items()?\if?isinstance(key,?(int,?float))}

題目014：使用Python代碼實現遍歷一個文件夾的操作。

點評：基本也是送人頭的題目，只要用過os模塊就應該知道怎么做。

Python標準庫os模塊的walk函數提供了遍歷一個文件夾的功能，它返回一個生成器。

import?osg?=?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))

說明：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?1if?total?<?0:return?0return?change_money(total?-?2)?+?change_money(total?-?3)?+?\change_money(total?-?5)

說明：在上面的代碼中，我們用lru_cache裝飾器裝飾了遞歸函數change_money，如果不做這個優化，上面代碼的漸近時間復雜度將會是

，而如果參數total的值是99，這個運算量是非常巨大的。lru_cache裝飾器會緩存函數的執行結果，這樣就可以減少重復運算所造成的開銷，這是空間換時間的策略，也是動態規劃的編程思想。

題目016：寫一個函數，給定矩陣的階數`n`，輸出一個螺旋式數字矩陣。

例如：n = 2，返回：

1?2 4?3 ?

例如：n = 3，返回：

1?2?3 8?9?4 7?6?5

這個題目本身并不復雜，下面的代碼僅供參考。

def?show_spiral_matrix(n):matrix?=?[[0]?*?n?for?_?in?range(n)]row,?col?=?0,?0num,?direction?=?1,?0while?num?<=?n?**?2:if?matrix[row][col]?==?0:matrix[row][col]?=?numnum?+=?1if?direction?==?0:if?col?<?n?-?1?and?matrix[row][col?+?1]?==?0:col?+=?1else:direction?+=?1elif?direction?==?1:if?row?<?n?-?1?and?matrix[row?+?1][col]?==?0:row?+=?1else:direction?+=?1elif?direction?==?2:if?col?>?0?and?matrix[row][col?-?1]?==?0:col?-=?1else:direction?+=?1else:if?row?>?0?and?matrix[row?-?1][col]?==?0:row?-=?1else:direction?+=?1direction?%=?4for?x?in?matrix:for?y?in?x:print(y,?end='\t')print()

題目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'}))

點評：生成式（推導式）屬于Python的特色語法之一，幾乎是面試必考內容。Python中通過生成式字面量語法，可以創建出列表、集合、字典。

[3,?4] [1,?3] [('a',?1),?('b',?2),?('c',?3),?('d',?4)] {2:?'item4',?4:?'item16',?6:?'item36'} 6

題目018：說出下面代碼的運行結果。

class?Parent:x?=?1class?Child1(Parent):passclass?Child2(Parent):passprint(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 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

題目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__是對象方法，它的第一個參數是對象。

?

學習更多Python知識與技巧，關注與私信博主（222）還有課件，源碼，安裝包，還有最新大廠面試資料等等等

題目21：輸入年月日，判斷這個日期是這一年的第幾天。

方法一：不使用標準庫中的模塊和函數。

def?is_leap_year(year):"""判斷指定的年份是不是閏年，平年返回False，閏年返回True"""return?year?%?4?==?0?and?year?%?100?!=?0?or?year?%?400?==?0def?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

方法二：使用標準庫中的datetime模塊。

import?datetimedef?which_day(year,?month,?date):end?=?datetime.date(year,?month,?date)start?=?datetime.date(year,?1,?1)return?(end?-?start).days?+?1

題目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?timedef?record_time(func):@wraps(func)def?wrapper(*args,?**kwargs):start?=?time()result?=?func(*args,?**kwargs)print(f'{func.__name__}執行時間:?{time()?-?start}秒')return?resultreturn?wrapper

方法二：用類實現裝飾器。類有__call__魔術方法，該類對象就是可調用對象，可以當做裝飾器來使用。

from?functools?import?wraps from?time?import?timeclass?Record:def?__call__(self,?func):@wraps(func)def?wrapper(*args,?**kwargs):start?=?time()result?=?func(*args,?**kwargs)print(f'{func.__name__}執行時間:?{time()?-?start}秒')return?resultreturn?wrapper

說明：裝飾器可以用來裝飾類或函數，為其提供額外的能力，屬于設計模式中的代理模式。

擴展：裝飾器本身也可以參數化，例如上面的例子中，如果不希望在終端中顯示函數的執行時間而是希望由調用者來決定如何輸出函數的執行時間，可以通過參數化裝飾器的方式來做到，代碼如下所示。

from?functools?import?wraps from?time?import?timedef?record_time(output):"""可以參數化的裝飾器"""def?decorate(func):@wraps(func)def?wrapper(*args,?**kwargs):start?=?time()result?=?func(*args,?**kwargs)output(func.__name__,?time()?-?start)return?resultreturn?wrapperreturn?decorate

題目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中的不等號&lt;&gt;在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,?ujsonjson.__name__?=?'ujson' json.dumps?=?ujson.dumps json.loads?=?ujson.loads

單元測試中的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()

點評：這道題考查到了兩個知識點：

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 --&gt; B --&gt; C --&gt; A --&gt; object。

ACBD

題目33：編寫一個函數實現對逆波蘭表達式求值，不能使用Python的內置函數。

點評：逆波蘭表達式也稱為“后綴表達式”，相較于平常我們使用的“中綴表達式”，逆波蘭表達式不需要括號來確定運算的優先級，例如5 * (2 + 3)對應的逆波蘭表達式是5 2 3 + *。逆波蘭表達式求值需要借助棧結構，掃描表達式遇到運算數就入棧，遇到運算符就出棧兩個元素做運算，將運算結果入棧。表達式掃描結束后，棧中只有一個數，這個數就是最終的運算結果，直接出棧即可。

import?operatorclass?Stack:"""棧（FILO）"""def?__init__(self):self.elems?=?[]def?push(self,?elem):"""入棧"""self.elems.append(elem)def?pop(self):"""出棧"""return?self.elems.pop()@propertydef?is_empty(self):"""檢查棧是否為空"""return?len(self.elems)?==?0def?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()

題目34：Python中如何實現字符串替換操作？

Python中實現字符串替換大致有兩類方法：字符串的replace方法和正則表達式的sub方法。

方法一：使用字符串的replace方法。

message?=?'hello,?world!' print(message.replace('o',?'O').replace('l',?'L').replace('he',?'HE'))

方法二：使用正則表達式的sub方法。

import?remessage?=?'hello,?world!' pattern?=?re.compile('[aeiou]') print(pattern.sub('#',?message))

擴展：還有一個相關的面試題，對保存文件名的列表排序，要求文件名按照字母表和數字大小進行排序，例如對于列表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?cProfiledef?is_prime(num):for?factor?in?range(2,?int(num?**?0.5)?+?1):if?num?%?factor?==?0:return?Falsereturn?Trueclass?PrimeIter:def?__init__(self,?total):self.counter?=?0self.current?=?1self.total?=?totaldef?__iter__(self):return?selfdef?__next__(self):if?self.counter?<?self.total:self.current?+=?1while?not?is_prime(self.current):self.current?+=?1self.counter?+=?1return?self.currentraise?StopIteration()cProfile.run('list(PrimeIter(10000))')

如果使用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?Falsereturn?True

安裝line_profiler。

pip?install?line_profiler

使用line_profiler。

kernprof?-lv?example.py

運行結果如下所示。

Line?#????Hits????Time??????Per?Hit??%?Time??Line?Contents ==============================================================1???????????????????????????????????????@profile2???????????????????????????????????????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?False6????1000??????430.0???0.4???????0.4????????return?True

題目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?itemslist1?=?extend_list(10) list2?=?extend_list(123,?[]) list3?=?extend_list('a') print(list1) print(list2) print(list3)

點評：Python函數在定義的時候，默認參數items的值就被計算出來了，即[]。因為默認參數items引用了對象[]，每次調用該函數，如果對items引用的列表進行了操作，下次調用時，默認參數還是引用之前的那個列表而不是重新賦值為[]，所以列表中會有之前添加的元素。如果通過傳參的方式為items重新賦值，那么items將引用到新的列表對象，而不再引用默認的那個列表對象。這個題在面試中經常被問到，通常不建議使用容器類型的默認參數，像PyLint這樣的代碼檢查工具也會對這種代碼提出質疑和警告。

[10,?'a'] [123] [10,?'a']

題目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

在Linux系統上，可以通過split命令將大文件切割為小片，然后通過讀取切割后的小文件對數據進行處理。例如下面的命令將名為filename的大文件切割為大小為512M的多個文件。

split?-b?512m?filename

如果愿意， 也可以將名為filename的文件切割為10個文件，命令如下所示。

split?-n?10?filename

擴展：外部排序跟上述的情況非常類似，由于處理的數據不能一次裝入內存，只能放在讀寫較慢的外存儲器（通常是硬盤）上。“排序-歸并算法”就是一種常用的外部排序策略。在排序階段，先讀入能放在內存中的數據量，將其排序輸出到一個臨時文件，依此進行，將待排序數據組織為多個有序的臨時文件，然后在歸并階段將這些臨時文件組合為一個大的有序文件，這個大的有序文件就是排序的結果。

題目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@propertydef?value(self):return?self.__valueobj?=?A(1) obj.__value?=?2 print(obj.value) print(obj.__value)

點評：這道題有兩個考察點，一個考察點是對_和__開頭的對象屬性訪問權限以及@property裝飾器的了解，另外一個考察的點是對動態語言的理解，不需要過多的解釋。

1 2

擴展：如果不希望代碼運行時動態的給對象添加新屬性，可以在定義類時使用__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 }

點評：sorted函數的高階用法在面試的時候經常出現，key參數可以傳入一個函數名或一個Lambda函數，該函數的返回值代表了在排序時比較元素的依據。

sorted(prices,?key=lambda?x:?prices[x],?reverse=True)?

題目45：說一下`namedtuple`的用法和作用。

點評：Python標準庫的collections模塊提供了很多有用的數據結構，這些內容并不是每個開發者都清楚，就比如題目問到的namedtuple，在我參加過的面試中，90%的面試者都不能準確的說出它的作用和應用場景。此外，deque也是一個非常有用但又經常被忽視的類，還有Counter、OrderedDict?、defaultdict?、UserDict等類，大家清楚它們的用法嗎？

在使用面向對象編程語言的時候，定義類是最常見的一件事情，有的時候，我們會用到只有屬性沒有方法的類，這種類的對象通常只用于組織數據，并不能接收消息，所以我們把這種類稱為數據類或者退化的類，就像C語言中的結構體那樣。我們并不建議使用這種退化的類，在Python中可以用namedtuple（命名元組）來替代這種類。

from?collections?import?namedtupleCard?=?namedtuple('Card',?('suite',?'face')) card1?=?Card('紅桃',?13) card2?=?Card('草花',?5) print(f'{card1.suite}{card1.face}') print(f'{card2.suite}{card2.face}')

命名元組與普通元組一樣是不可變容器，一旦將數據存儲在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)

總而言之，命名元組能更好的組織數據結構，讓代碼更加清晰和可讀，在很多場景下是元組、字典和數據類的替代品。在需要創建占用空間更少的不可變類時，命名元組就是很好的選擇。

題目46：按照題目要求寫出對應的函數。

要求：寫一個函數，傳入一個有若干個整數的列表，該列表中某個元素出現的次數超過了50%，返回這個元素。

def?more_than_half(items):temp,?times?=?None,?0for?item?in?items:if?times?==?0:temp?=?itemtimes?+=?1else:if?item?==?temp:times?+=?1else:times?-=?1return?temp

點評：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?=?1for?item?in?items:max_depth?=?max(list_depth(item)?+?1,?max_depth)return?max_depthreturn?0

點評：看到題目應該能夠比較自然的想到使用遞歸的方式檢查列表中的每個元素。

題目48：按照題目要求寫出對應的裝飾器。

要求：有一個通過網絡獲取數據的函數（可能會因為網絡原因出現異常），寫一個裝飾器讓這個函數在出現指定異常時可以重試指定的次數，并在每次重試之前隨機延遲一段時間，最長延遲時間可以通過參數進行控制。

方法一：

from?functools?import?wraps from?random?import?random from?time?import?sleepdef?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?Nonereturn?wrapperreturn?decorate

方法二：

from?functools?import?wraps from?random?import?random from?time?import?sleepclass?Retry(object):def?__init__(self,?*,?retry_times=3,?max_wait_secs=5,?errors=(Exception,?)):self.retry_times?=?retry_timesself.max_wait_secs?=?max_wait_secsself.errors?=?errorsdef?__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?Nonereturn?wrapper

點評：我們不止一次強調過，裝飾器幾乎是Python面試必問內容，這個題目比之前的題目稍微復雜一些，它需要的是一個參數化的裝飾器。

題目49：寫一個函數實現字符串反轉，盡可能寫出你知道的所有方法。

點評：爛大街的題目，基本上算是送人頭的題目。

方法一：反向切片

def?reverse_string(content):return?content[::-1]

方法二：反轉拼接

def?reverse_string(content):return?''.join(reversed(content))

方法三：遞歸調用

def?reverse_string(content):if?len(content)?<=?1:return?contentreturn?reverse_string(content[1:])?+?content[0]

方法四：雙端隊列

from?collections?import?dequedef?reverse_string(content):q?=?deque()q.extendleft(content)return?''.join(q)

方法五：反向組裝

from?io?import?StringIOdef?reverse_string(content):buffer?=?StringIO()for?i?in?range(len(content)?-?1,?-1,?-1):buffer.write(content[i])return?buffer.getvalue()

方法六：反轉拼接

def?reverse_string(content):return?''.join([content[i]?for?i?in?range(len(content)?-?1,?-1,?-1)])

方法七：半截交換

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)

方法八：對位交換

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)

擴展：這些方法其實都是大同小異的，面試的時候能夠給出幾種有代表性的就足夠了。給大家留一個思考題，上面這些方法，哪些做法的性能較好呢？我們之前提到過剖析代碼性能的方法，大家可以用這些方法來檢驗下你給出的答案是否正確。

題目50：按照題目要求寫出對應的函數。

要求：列表中有1000000個元素，取值范圍是[1000, 10000)，設計一個函數找出列表中的重復元素。

def?find_dup(items:?list):dups?=?[0]?*?9000for?item?in?items:dups[item?-?1000]?+=?1for?idx,?val?in?enumerate(dups):if?val?>?1:yield?idx?+?1000

點評：這道題的解法和計數排序的原理一致，雖然元素的數量非常多，但是取值范圍[1000, 10000)并不是很大，只有9000個可能的取值，所以可以用一個能夠保存9000個元素的dups列表來記錄每個元素出現的次數，dups列表所有元素的初始值都是0，通過對items列表中元素的遍歷，當出現某個元素時，將dups列表對應位置的值加1，最后dups列表中值大于1的元素對應的就是items列表中重復出現過的元素。

?

學習更多Python知識與技巧，關注與私信博主（222）還有課件，源碼，安裝包，還有最新大廠面試資料等等等

?如果本文對你有幫助，別忘記給我個3連 ，點贊，轉發，評論，
咱們下期見。
收藏 等于白嫖，點贊才是真情。

?

總結

以上是生活随笔為你收集整理的【建议收藏】50 道硬核的 Python 面试题的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。