目錄

• • 題目001: 在Python中如何實現(xiàn)單例模式。
  • 題目002：不使用中間變量，交換兩個變量`a`和`b`的值。
  • 題目003：寫一個刪除列表中重復元素的函數(shù)，要求去重后元素相對位置保持不變。
  • 題目004：假設你使用的是官方的CPython，說出下面代碼的運行結果。
  • 題目005：Lambda函數(shù)是什么，舉例說明的它的應用場景。
  • 題目006：說說Python中的淺拷貝和深拷貝。
  • 題目007：Python是如何實現(xiàn)內存管理的？
  • 題目008：說一下你對Python中迭代器和生成器的理解。
  • 題目009：正則表達式的match方法和search方法有什么區(qū)別？
  • 題目010：下面這段代碼的執(zhí)行結果是什么。
  • 題目011：Python中為什么沒有函數(shù)重載？
  • 題目012：用Python代碼實現(xiàn)Python內置函數(shù)max。
  • 題目013：寫一個函數(shù)統(tǒng)計傳入的列表中每個數(shù)字出現(xiàn)的次數(shù)并返回對應的字典。
  • 題目014：使用Python代碼實現(xiàn)遍歷一個文件夾的操作。
  • 題目015：現(xiàn)有2元、3元、5元共三種面額的貨幣，如果需要找零99元，一共有多少種找零的方式？
  • 題目016：寫一個函數(shù)，給定矩陣的階數(shù)`n`，輸出一個螺旋式數(shù)字矩陣。
  • 題目017：閱讀下面的代碼，寫出程序的運行結果。
  • 題目018：說出下面代碼的運行結果。
  • 題目19：說說你用過Python標準庫中的哪些模塊。
  • 題目20：`init__`和`__new`方法有什么區(qū)別？
  • 題目21：輸入年月日，判斷這個日期是這一年的第幾天。
  • 題目22：平常工作中用什么工具進行靜態(tài)代碼分析。
  • 題目23：說一下你知道的Python中的魔術方法。
  • 題目24：函數(shù)參數(shù)`arg`和`*kwargs`分別代表什么？
  • 題目25：寫一個記錄函數(shù)執(zhí)行時間的裝飾器。
  • 題目26：什么是鴨子類型（duck typing）？
  • 題目27：說一下Python中變量的作用域。
  • 題目28：說一下你對閉包的理解。
  • 題目29：說一下Python中的多線程和多進程的應用場景和優(yōu)缺點。
  • 題目30：說一下Python 2和Python 3的區(qū)別。
  • 題目31：談談你對“猴子補丁”（monkey patching）的理解。
  • 題目32：閱讀下面的代碼說出運行結果。
  • 題目33：編寫一個函數(shù)實現(xiàn)對逆波蘭表達式求值，不能使用Python的內置函數(shù)。
  • 題目34：Python中如何實現(xiàn)字符串替換操作？
  • 題目35：如何剖析Python代碼的執(zhí)行性能？
  • 題目36：如何使用`random`模塊生成隨機數(shù)、實現(xiàn)隨機亂序和隨機抽樣？
  • 題目37：解釋一下線程池的工作原理。
  • 題目38：舉例說明什么情況下會出現(xiàn)`KeyError`、`TypeError`、`ValueError`。
  • 題目39：說出下面代碼的運行結果。
  • 題目40：如何讀取大文件，例如內存只有4G，如何讀取一個大小為8G的文件？
  • 題目41：說一下你對Python中模塊和包的理解。
  • 題目42：說一下你知道的Python編碼規(guī)范。
  • 題目43：運行下面的代碼是否會報錯，如果報錯請說明哪里有什么樣的錯，如果不報錯請說出代碼的執(zhí)行結果。
  • 題目44：對下面給出的字典按值從大到小對鍵進行排序。
  • 題目45：說一下`namedtuple`的用法和作用。
  • 題目46：按照題目要求寫出對應的函數(shù)。
  • 題目47：按照題目要求寫出對應的函數(shù)。
  • 題目48：按照題目要求寫出對應的裝飾器。
  • 題目49：寫一個函數(shù)實現(xiàn)字符串反轉，盡可能寫出你知道的所有方法。
  • 題目50：按照題目要求寫出對應的函數(shù)。

題目001: 在Python中如何實現(xiàn)單例模式。

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

方法一：使用裝飾器實現(xiàn)單例模式。

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中非常有特色的語法，用一個函數(shù)去裝飾另一個函數(shù)或類，為其添加額外的能力。通常通過裝飾來實現(xiàn)的功能都屬橫切關注功能，也就是跟正常的業(yè)務邏輯沒有必然聯(lián)系，可以動態(tài)添加或移除的功能。裝飾器可以為代碼提供緩存、代理、上下文環(huán)境等服務，它是對設計模式中代理模式的踐行。在寫裝飾器的時候，帶裝飾功能的函數(shù)（上面代碼中的wrapper函數(shù)）通常都會用functools模塊中的wraps再加以裝飾，這個裝飾器最重要的作用是給被裝飾的類或函數(shù)動態(tài)添加一個__wrapped__屬性，這個屬性會將被裝飾之前的類或函數(shù)保留下來，這樣在我們不需要裝飾功能的時候，可以通過它來取消裝飾器，例如可以使用President = President.__wrapped__來取消對President類做的單例處理。需要提醒大家的是：上面的單例并不是線程安全的，如果要做到線程安全，需要對創(chuàng)建對象的代碼進行加鎖的處理。在Python中可以使用threading模塊的RLock對象來提供鎖，可以使用鎖對象的acquire和release方法來實現(xiàn)加鎖和解鎖的操作。當然，更為簡便的做法是使用鎖對象的with上下文語法來進行隱式的加鎖和解鎖操作。

方法二：使用元類實現(xiàn)單例模式。

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

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

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

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

方法一：

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

方法二：

a, b = b, a

擴展：需要注意，a, b = b, a這種做法其實并不是元組解包，雖然很多人都這樣認為。Python字節(jié)碼指令中有ROT_TWO指令來支持這個操作，類似的還有ROT_THREE，對于3個以上的元素，如a, b, c, d = b, c, d, a，才會用到創(chuàng)建元組和元組解包。想知道你的代碼對應的字節(jié)碼指令，可以使用Python標準庫中dis模塊的dis函數(shù)來反匯編你的Python代碼。

題目003：寫一個刪除列表中重復元素的函數(shù)，要求去重后元素相對位置保持不變。

點評：這個題目在初中級Python崗位面試的時候經(jīng)常出現(xiàn)，題目源于《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

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

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

擴展：由于Python中的集合底層使用哈希存儲，所以集合的in和not in成員運算在性能上遠遠優(yōu)于列表，所以上面的代碼我們使用了集合來保存已經(jīng)出現(xiàn)過的元素。集合中的元素必須是hashable對象，因此上面的代碼在列表元素不是hashable對象時會失效，要解決這個問題可以給函數(shù)增加一個參數(shù)，該參數(shù)可以設計為返回哈希碼或hashable對象的函數(shù)。

題目004：假設你使用的是官方的CPython，說出下面代碼的運行結果。

點評：下面的程序對實際開發(fā)并沒有什么意義，但卻是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解釋器出于性能優(yōu)化的考慮，把頻繁使用的整數(shù)對象用一個叫small_ints的對象池緩存起來造成的。small_ints緩存的整數(shù)值被設定為[-5, 256]這個區(qū)間，也就是說，在任何引用這些整數(shù)的地方，都不需要重新創(chuàng)建int對象，而是直接引用緩存池中的對象。如果整數(shù)不在該范圍內，那么即便兩個整數(shù)的值相同，它們也是不同的對象。

CPython底層為了進一步提升性能還做了另一個設定，對于同一個代碼塊中值不在small_ints緩存范圍內的整數(shù)，如果同一個代碼塊中已經(jīng)存在一個值與其相同的整數(shù)對象，那么就直接引用該對象，否則創(chuàng)建新的int對象。需要大家注意的是，這條規(guī)則對數(shù)值型適用，但對字符串則需要考慮字符串的長度，這一點大家可以自行證明。

擴展：如果你用PyPy（另一種Python解釋器實現(xiàn)，支持JIT，對CPython的缺點進行了改良，在性能上優(yōu)于CPython，但對三方庫的支持略差）來運行上面的代碼，你會發(fā)現(xiàn)所有的輸出都是True。

題目005：Lambda函數(shù)是什么，舉例說明的它的應用場景。

點評：這個題目主要想考察的是Lambda函數(shù)的應用場景，潛臺詞是問你在項目中有沒有使用過Lambda函數(shù)，具體在什么場景下會用到Lambda函數(shù)，借此來判斷你寫代碼的能力。因為Lambda函數(shù)通常用在高階函數(shù)中，主要的作用是通過向函數(shù)傳入函數(shù)或讓函數(shù)返回函數(shù)最終實現(xiàn)代碼的解耦合。

Lambda函數(shù)也叫匿名函數(shù)，它是功能簡單用一行代碼就能實現(xiàn)的小型函數(shù)。Python中的Lambda函數(shù)只能寫一個表達式，這個表達式的執(zhí)行結果就是函數(shù)的返回值，不用寫return關鍵字。Lambda函數(shù)因為沒有名字，所以也不會跟其他函數(shù)發(fā)生命名沖突的問題。

擴展：面試的時候有可能還會考你用Lambda函數(shù)來實現(xiàn)一些功能，也就是用一行代碼來實現(xiàn)題目要求的功能，例如：用一行代碼實現(xiàn)求階乘的函數(shù)，用一行代碼實現(xiàn)求最大公約數(shù)的函數(shù)等。

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函數(shù)其實最為主要的用途是把一個函數(shù)傳入另一個高階函數(shù)（如Python內置的filter、map等）中來為函數(shù)做解耦合，增強函數(shù)的靈活性和通用性。下面的例子通過使用filter和map函數(shù)，實現(xiàn)了從列表中篩選出奇數(shù)并求平方構成新列表的操作，因為用到了高階函數(shù)，過濾和映射數(shù)據(jù)的規(guī)則都是函數(shù)的調用者通過另外一個函數(shù)傳入的，因此這filter和map函數(shù)沒有跟特定的過濾和映射數(shù)據(jù)的規(guī)則耦合在一起。

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]

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

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

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

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

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

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

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

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

import copyclass PrototypeMeta(type):"""實現(xiàn)原型模式的元類"""def __init__(cls, *args, **kwargs):super().__init__(*args, **kwargs)# 為對象綁定clone方法來實現(xiàn)對象拷貝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是如何實現(xiàn)內存管理的？

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

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

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

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

以下情況會導致引用計數(shù)加1：

對象被創(chuàng)建

對象被引用

對象作為參數(shù)傳入到一個函數(shù)中

對象作為元素存儲到一個容器中

以下情況會導致引用計數(shù)減1：

用del語句顯示刪除對象引用

對象引用被重新賦值其他對象

一個對象離開它所在的作用域

持有該對象的容器自身被銷毀

持有該對象的容器刪除該對象

可以通過sys模塊的getrefcount函數(shù)來獲得對象的引用計數(shù)。引用計數(shù)的內存管理方式在遇到循環(huán)引用的時候就會出現(xiàn)致命傷，因此需要其他的垃圾回收算法對其進行補充。

標記清理：CPython使用了“標記-清理”（Mark and Sweep）算法解決容器類型可能產生的循環(huán)引用問題。該算法在垃圾回收時分為兩個階段：標記階段，遍歷所有的對象，如果對象是可達的（被其他對象引用），那么就標記該對象為可達；清除階段，再次遍歷對象，如果發(fā)現(xiàn)某個對象沒有標記為可達，則就將其回收。CPython底層維護了兩個雙端鏈表，一個鏈表存放著需要被掃描的容器對象（姑且稱之為鏈表A），另一個鏈表存放著臨時不可達對象（姑且稱之為鏈表B）。為了實現(xiàn)“標記-清理”算法，鏈表中的每個節(jié)點除了有記錄當前引用計數(shù)的ref_count變量外，還有一個gc_ref變量，這個gc_ref是ref_count的一個副本，所以初始值為ref_count的大小。執(zhí)行垃圾回收時，首先遍歷鏈表A中的節(jié)點，并且將當前對象所引用的所有對象的gc_ref減1，這一步主要作用是解除循環(huán)引用對引用計數(shù)的影響。再次遍歷鏈表A中的節(jié)點，如果節(jié)點的gc_ref值為0，那么這個對象就被標記為“暫時不可達”（GC_TENTATIVELY_UNREACHABLE）并被移動到鏈表B中；如果節(jié)點的gc_ref不為0，那么這個對象就會被標記為“可達“（GC_REACHABLE），對于”可達“對象，還要遞歸的將該節(jié)點可以到達的節(jié)點標記為”可達“；鏈表B中被標記為”可達“的節(jié)點要重新放回到鏈表A中。在兩次遍歷之后，鏈表B中的節(jié)點就是需要釋放內存的節(jié)點。

分代回收：在循環(huán)引用對象的回收中，整個應用程序會被暫停，為了減少應用程序暫停的時間，Python 通過分代回收（空間換時間）的方法提高垃圾回收效率。分代回收的基本思想是：對象存在的時間越長，是垃圾的可能性就越小，應該盡量不對這樣的對象進行垃圾回收。CPython將對象分為三種世代分別記為0、1、2，每一個新生對象都在第0代中，如果該對象在一輪垃圾回收掃描中存活下來，那么它將被移到第1代中，存在于第1代的對象將較少的被垃圾回收掃描到；如果在對第1代進行垃圾回收掃描時，這個對象又存活下來，那么它將被移至第2代中，在那里它被垃圾回收掃描的次數(shù)將會更少。分代回收掃描的門限值可以通過gc模塊的get_threshold函數(shù)來獲得，該函數(shù)返回一個三元組，分別表示多少次內存分配操作后會執(zhí)行0代垃圾回收，多少次0代垃圾回收后會執(zhí)行1代垃圾回收，多少次1代垃圾回收后會執(zhí)行2代垃圾回收。需要說明的是，如果執(zhí)行一次2代垃圾回收，那么比它年輕的代都要執(zhí)行垃圾回收。如果想修改這幾個門限值，可以通過gc模塊的set_threshold函數(shù)來做到。

題目008：說一下你對Python中迭代器和生成器的理解。

點評：很多人面試者都會寫迭代器和生成器，但是卻無法準確的解釋什么是迭代器和生成器。如果你也有同樣的困惑，可以參考下面的回答。

迭代器是實現(xiàn)了迭代器協(xié)議的對象。跟其他編程語言不通，Python中沒有用于定義協(xié)議或表示約定的關鍵字，像interface、protocol這些單詞并不在Python語言的關鍵字列表中。Python語言通過魔法方法來表示約定，也就是我們所說的協(xié)議，而__next__和__iter__這兩個魔法方法就代表了迭代器協(xié)議。可以通過for-in循環(huán)從迭代器對象中取出值，也可以使用next函數(shù)取出迭代器對象中的下一個值。生成器是迭代器的語法升級版本，可以用更為簡單的代碼來實現(xiàn)一個迭代器。

擴展：面試中經(jīng)常讓寫生成斐波那契數(shù)列的迭代器，大家可以參考下面的代碼。

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

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

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

題目009：正則表達式的match方法和search方法有什么區(qū)別？

點評：正則表達式是字符串處理的重要工具，所以也是面試中經(jīng)常考察的知識點。在Python中，使用正則表達式有兩種方式，一種是直接調用re模塊中的函數(shù)，傳入正則表達式和需要處理的字符串；一種是先通過re模塊的compile函數(shù)創(chuàng)建正則表達式對象，然后再通過對象調用方法并傳入需要處理的字符串。如果一個正則表達式被頻繁的使用，我們推薦用re.compile函數(shù)創(chuàng)建正則表達式對象，這樣會減少頻繁編譯同一個正則表達式所造成的開銷。

match方法是從字符串的起始位置進行正則表達式匹配，返回Match對象或None。search方法會掃描整個字符串來找尋匹配的模式，同樣也是返回Match對象或None。

題目010：下面這段代碼的執(zhí)行結果是什么。

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函數(shù)用生成式語法返回了一個列表，列表中保存了4個Lambda函數(shù)，這4個Lambda函數(shù)會返回傳入的參數(shù)乘以i的結果。需要注意的是這里有閉包（closure）現(xiàn)象，multiply函數(shù)中的局部變量i的生命周期被延展了，由于i最終的值是3，所以通過m(100)調列表中的Lambda函數(shù)時會返回300，而且4個調用都是如此。

如果想得到[0, 100, 200, 300]這個結果，可以按照下面幾種方式來修改multiply函數(shù)。

方法一：使用生成器，讓函數(shù)獲得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()])

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

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中為什么沒有函數(shù)重載？

點評：C++、Java、C#等諸多編程語言都支持函數(shù)重載，所謂函數(shù)重載指的是在同一個作用域中有多個同名函數(shù)，它們擁有不同的參數(shù)列表（參數(shù)個數(shù)不同或參數(shù)類型不同或二者皆不同），可以相互區(qū)分。重載也是一種多態(tài)性，因為通常是在編譯時通過參數(shù)的個數(shù)和類型來確定到底調用哪個重載函數(shù)，所以也被稱為編譯時多態(tài)性或者叫前綁定。這個問題的潛臺詞其實是問面試者是否有其他編程語言的經(jīng)驗，是否理解Python是動態(tài)類型語言，是否知道Python中函數(shù)的可變參數(shù)、關鍵字參數(shù)這些概念。

首先Python是解釋型語言，函數(shù)重載現(xiàn)象通常出現(xiàn)在編譯型語言中。其次Python是動態(tài)類型語言，函數(shù)的參數(shù)沒有類型約束，也就無法根據(jù)參數(shù)類型來區(qū)分重載。再者Python中函數(shù)的參數(shù)可以有默認值，可以使用可變參數(shù)和關鍵字參數(shù)，因此即便沒有函數(shù)重載，也要可以讓一個函數(shù)根據(jù)調用者傳入的參數(shù)產生不同的行為。

題目012：用Python代碼實現(xiàn)Python內置函數(shù)max。

點評：這個題目看似簡單，但實際上還是比較考察面試者的功底。因為Python內置的max函數(shù)既可以傳入可迭代對象找出最大，又可以傳入兩個或多個參數(shù)找出最大；最為關鍵的是還可以通過命名關鍵字參數(shù)key來指定一個用于元素比較的函數(shù)，還可以通過default命名關鍵字參數(shù)來指定當可迭代對象為空時返回的默認值。

下面的代碼僅供參考：

def my_max(*args, key=None, default=None):"""獲取可迭代對象中最大的元素或兩個及以上實參中最大的元素:param args: 一個可迭代對象或多個元素:param key: 提取用于元素比較的特征值的函數(shù)，默認為None:param default: 如果可迭代對象為空則返回該默認值，如果沒有給默認值則引發(fā)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：寫一個函數(shù)統(tǒng)計傳入的列表中每個數(shù)字出現(xiàn)的次數(shù)并返回對應的字典。

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

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的子類，它會將傳入的序列中的每個元素作為鍵，元素出現(xiàn)的次數(shù)作為值來構造字典。

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代碼實現(xiàn)遍歷一個文件夾的操作。

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

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

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模塊提供了很多進行路徑操作的工具函數(shù)，在項目開發(fā)中也是經(jīng)常會用到的。如果題目明確要求不能使用os.walk函數(shù)，那么可以使用os.listdir函數(shù)來獲取指定目錄下的文件和文件夾，然后再通過循環(huán)遍歷用os.isdir函數(shù)判斷哪些是文件夾，對于文件夾可以通過遞歸調用進行遍歷，這樣也可以實現(xiàn)遍歷一個文件夾的操作。

題目015：現(xiàn)有2元、3元、5元共三種面額的貨幣，如果需要找零99元，一共有多少種找零的方式？

點評：還有一個非常類似的題目：“一個小朋友走樓梯，一次可以走1個臺階、2個臺階或3個臺階，問走完10個臺階一共有多少種走法？”，這兩個題目的思路是一樣，如果用遞歸函數(shù)來寫的話非常簡單。

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裝飾器裝飾了遞歸函數(shù)change_money，如果不做這個優(yōu)化，上面代碼的漸近時間復雜度將會是圖片，而如果參數(shù)total的值是99，這個運算量是非常巨大的。lru_cache裝飾器會緩存函數(shù)的執(zhí)行結果，這樣就可以減少重復運算所造成的開銷，這是空間換時間的策略，也是動態(tài)規(guī)劃的編程思想。

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

例如：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中通過生成式字面量語法，可以創(chuàng)建出列表、集合、字典。

[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并不受影響。執(zhí)行Parent.x = 3會重新給Parent類的x屬性賦值為3，由于Child2的x屬性繼承自Parent，所以Child2.x的值也是3；而之前我們?yōu)镃hild1重新綁定了x屬性，那么它的x屬性值不會受到Parent.x = 3的影響，還是之前的值2。

1 1 1 1 2 1 3 2 3

題目19：說說你用過Python標準庫中的哪些模塊。

點評：Python標準庫中的模塊非常多，建議大家根據(jù)自己過往的項目經(jīng)歷來介紹你用過的標準庫和三方庫，因為這些是你最為熟悉的，經(jīng)得起面試官深挖的。

題目20：init__和__new方法有什么區(qū)別？

Python中調用構造器創(chuàng)建對象屬于兩階段構造過程，首先執(zhí)行__new__方法獲得保存對象所需的內存空間，再通過__init__執(zhí)行對內存空間數(shù)據(jù)的填充（對象屬性的初始化）。__new__方法的返回值是創(chuàng)建好的Python對象（的引用），而__init__方法的第一個參數(shù)就是這個對象（的引用），所以在__init__中可以完成對對象的初始化操作。__new__是類方法，它的第一個參數(shù)是類，__init__是對象方法，它的第一個參數(shù)是對象。

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

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

def is_leap_year(year):"""判斷指定的年份是不是閏年，平年返回False，閏年返回True"""return year % 4 == 0 and year % 100 != 0 or year % 400 == 0def which_day(year, month, date):"""計算傳入的日期是這一年的第幾天"""# 用嵌套的列表保存平年和閏年每個月的天數(shù)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：平常工作中用什么工具進行靜態(tài)代碼分析。

點評：靜態(tài)代碼分析工具可以從代碼中提煉出各種靜態(tài)屬性，這使得開發(fā)者可以對代碼的復雜性、可維護性和可讀性有更好的了解，這里所說的靜態(tài)屬性包括：

代碼是否符合編碼規(guī)范，例如：PEP-8。

代碼中潛在的問題，包括：語法錯誤、縮進問題、導入缺失、變量覆蓋等。

代碼中的壞味道。

代碼的復雜度。

代碼的邏輯問題。

工作中靜態(tài)代碼分析主要用到的是Pylint和Flake8。Pylint可以檢查出代碼錯誤、壞味道、不規(guī)范的代碼等問題，較新的版本中還提供了代碼復雜度統(tǒng)計數(shù)據(jù)，可以生成檢查報告。Flake8封裝了Pyflakes（檢查代碼邏輯錯誤）、McCabe（檢查代碼復雜性）和Pycodestyle（檢查代碼是否符合PEP-8規(guī)范）工具，它可以執(zhí)行這三個工具提供的檢查。

題目23：說一下你知道的Python中的魔術方法。

點評：魔術方法也稱為魔法方法，是Python中的特色語法，也是面試中的高頻問題。

題目24：函數(shù)參數(shù)arg和*kwargs分別代表什么？

Python中，函數(shù)的參數(shù)分為位置參數(shù)、可變參數(shù)、關鍵字參數(shù)、命名關鍵字參數(shù)。args代表可變參數(shù)，可以接收0個或任意多個參數(shù)，當不確定調用者會傳入多少個位置參數(shù)時，就可以使用可變參數(shù)，它會將傳入的參數(shù)打包成一個元組。**kwargs代表關鍵字參數(shù)，可以接收用參數(shù)名=參數(shù)值的方式傳入的參數(shù)，傳入的參數(shù)的會打包成一個字典。定義函數(shù)時如果同時使用args和**kwargs，那么函數(shù)可以接收任意參數(shù)。

題目25：寫一個記錄函數(shù)執(zhí)行時間的裝飾器。

點評：高頻面試題，也是最簡單的裝飾器，面試者必須要掌握的內容。

方法一：用函數(shù)實現(xiàn)裝飾器。

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__}執(zhí)行時間: {time() - start}秒')return resultreturn wrapper

方法二：用類實現(xiàn)裝飾器。類有__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__}執(zhí)行時間: {time() - start}秒')return resultreturn wrapper

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

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

from functools import wraps from time import timedef record_time(output):"""可以參數(shù)化的裝飾器"""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）？

鴨子類型是動態(tài)類型語言判斷一個對象是不是某種類型時使用的方法，也叫做鴨子判定法。簡單的說，鴨子類型是指判斷一只鳥是不是鴨子，我們只關心它游泳像不像鴨子、叫起來像不像鴨子、走路像不像鴨子就足夠了。換言之，如果對象的行為跟我們的預期是一致的（能夠接受某些消息），我們就認定它是某種類型的對象。

在Python語言中，有很多bytes-like對象（如：bytes、bytearray、array.array、memoryview）、file-like對象（如：StringIO、BytesIO、GzipFile、socket）、path-like對象（如：str、bytes），其中file-like對象都能支持read和write操作，可以像文件一樣讀寫，這就是所謂的對象有鴨子的行為就可以判定為鴨子的判定方法。再比如Python中列表的extend方法，它需要的參數(shù)并不一定要是列表，只要是可迭代對象就沒有問題。

說明：動態(tài)語言的鴨子類型使得設計模式的應用被大大簡化。

題目27：說一下Python中變量的作用域。

Python中有四種作用域，分別是局部作用域（Local）、嵌套作用域（Embedded）、全局作用域（Global）、內置作用域（Built-in），搜索一個標識符時，會按照LEGB的順序進行搜索，如果所有的作用域中都沒有找到這個標識符，就會引發(fā)NameError異常。

題目28：說一下你對閉包的理解。

閉包是支持一等函數(shù)的編程語言（Python、JavaScript等）中實現(xiàn)詞法綁定的一種技術。當捕捉閉包的時候，它的自由變量（在函數(shù)外部定義但在函數(shù)內部使用的變量）會在捕捉時被確定，這樣即便脫離了捕捉時的上下文，它也能照常運行。簡單的說，可以將閉包理解為能夠讀取其他函數(shù)內部變量的函數(shù)。正在情況下，函數(shù)的局部變量在函數(shù)調用結束之后就結束了生命周期，但是閉包使得局部變量的生命周期得到了延展。使用閉包的時候需要注意，閉包會使得函數(shù)中創(chuàng)建的對象不會被垃圾回收，可能會導致很大的內存開銷，所以閉包一定不能濫用。

題目29：說一下Python中的多線程和多進程的應用場景和優(yōu)缺點。

線程是操作系統(tǒng)分配CPU的基本單位，進程是操作系統(tǒng)分配內存的基本單位。通常我們運行的程序會包含一個或多個進程，而每個進程中又包含一個或多個線程。多線程的優(yōu)點在于多個線程可以共享進程的內存空間，所以進程間的通信非常容易實現(xiàn)；但是如果使用官方的CPython解釋器，多線程受制于GIL（全局解釋器鎖），并不能利用CPU的多核特性，這是一個很大的問題。使用多進程可以充分利用CPU的多核特性，但是進程間通信相對比較麻煩，需要使用IPC機制（管道、套接字等）。

多線程適合那些會花費大量時間在I/O操作上，但沒有太多并行計算需求且不需占用太多內存的I/O密集型應用。多進程適合執(zhí)行計算密集型任務（如：視頻編碼解碼、數(shù)據(jù)處理、科學計算等）、可以分解為多個并行子任務并能合并子任務執(zhí)行結果的任務以及在內存使用方面沒有任何限制且不強依賴于I/O操作的任務。

擴展：Python中實現(xiàn)并發(fā)編程通常有多線程、多進程和異步編程三種選擇。異步編程實現(xiàn)了協(xié)作式并發(fā)，通過多個相互協(xié)作的子程序的用戶態(tài)切換，實現(xiàn)對CPU的高效利用，這種方式也是非常適合I/O密集型應用的。

題目30：說一下Python 2和Python 3的區(qū)別。

點評：這種問題千萬不要背所謂的參考答案，說一些自己最熟悉的就足夠了。

Python 2中的print和exec都是關鍵字，在Python 3中變成了函數(shù)。

Python 3中沒有l(wèi)ong類型，整數(shù)都是int類型。

Python 2中的不等號<>在Python 3中被廢棄，統(tǒng)一使用!=。

Python 2中的xrange函數(shù)在Python 3中被range函數(shù)取代。

Python 3對Python 2中不安全的input函數(shù)做出了改進，廢棄了raw_input函數(shù)。

Python 2中的file函數(shù)被Python 3中的open函數(shù)取代。

Python 2中的/運算對于int類型是整除，在Python 3中要用//來做整除除法。

Python 3中改進了Python 2捕獲異常的代碼，很明顯Python 3的寫法更合理。

Python 3生成式中循環(huán)變量的作用域得到了更好的控制，不會影響到生成式之外的同名變量。

Python 3中的round函數(shù)可以返回int或float類型，Python 2中的round函數(shù)返回float類型。

Python 3的str類型是Unicode字符串，Python 2的str類型是字節(jié)串，相當于Python 3中的bytes。

Python 3中的比較運算符必須比較同類對象。

Python 3中定義類的都是新式類，Python 2中定義的類有新式類（顯式繼承自object的類）和舊式類（經(jīng)典類）之分，新式類和舊式類在MRO問題上有非常顯著的區(qū)別，新式類可以使用class__屬性獲取自身類型，新式類可以使用__slots魔法。

Python 3對代碼縮進的要求更加嚴格，如果混用空格和制表鍵會引發(fā)TabError。

Python 3中字典的keys、values、items方法都不再返回list對象，而是返回view object，內置的map、filter等函數(shù)也不再返回list對象，而是返回迭代器對象。

Python 3標準庫中某些模塊的名字跟Python 2是有區(qū)別的；而在三方庫方面，有些三方庫只支持Python 2，有些只能支持Python 3。

題目31：談談你對“猴子補丁”（monkey patching）的理解。

“猴子補丁”是動態(tài)類型語言的一個特性，代碼運行時在不修改源代碼的前提下改變代碼中的方法、屬性、函數(shù)等以達到熱補丁（hot patch）的效果。很多系統(tǒng)的安全補丁也是通過猴子補丁的方式來實現(xiàn)的，但實際開發(fā)中應該避免對猴子補丁的使用，以免造成代碼行為不一致的問題。

在使用gevent庫的時候，我們會在代碼開頭的地方執(zhí)行gevent.monkey.patch_all()，這行代碼的作用是把標準庫中的socket模塊給替換掉，這樣我們在使用socket的時候，不用修改任何代碼就可以實現(xiàn)對代碼的協(xié)程化，達到提升性能的目的，這就是對猴子補丁的應用。

另外，如果希望用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（方法解析順序）。在沒有多重繼承的情況下，向對象發(fā)出一個消息，如果對象沒有對應的方法，那么向上（父類）搜索的順序是非常清晰的。如果向上追溯到object類（所有類的父類）都沒有找到對應的方法，那么將會引發(fā)AttributeError異常。但是有多重繼承尤其是出現(xiàn)菱形繼承（鉆石繼承）的時候，向上追溯到底應該找到那個方法就得確定MRO。Python 3中的類以及Python 2中的新式類使用C3算法來確定MRO，它是一種類似于廣度優(yōu)先搜索的方法；Python 2中的舊式類（經(jīng)典類）使用深度優(yōu)先搜索來確定MRO。在搞不清楚MRO的情況下，可以使用類的mro方法或mro屬性來獲得類的MRO列表。

super()函數(shù)的使用。在使用super函數(shù)時，可以通過super(類型, 對象)來指定對哪個對象以哪個類為起點向上搜索父類方法。所以上面B類代碼中的super(B, self).who()表示以B類為起點，向上搜索self（D類對象）的who方法，所以會找到C類中的who方法，因為D類對象的MRO列表是D --> B --> C --> A --> object。

ACBD

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

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

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中如何實現(xiàn)字符串替換操作？

Python中實現(xiàn)字符串替換大致有兩類方法：字符串的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))

擴展：還有一個相關的面試題，對保存文件名的列表排序，要求文件名按照字母表和數(shù)字大小進行排序，例如對于列表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’]。提示一下，可以通過字符串替換的方式為文件名補位，根據(jù)補位后的文件名用sorted函數(shù)來排序，大家可以思考下這個問題如何解決。

題目35：如何剖析Python代碼的執(zhí)行性能？

剖析代碼性能可以使用Python標準庫中的cProfile和pstats模塊，cProfile的run函數(shù)可以執(zhí)行代碼并收集統(tǒng)計信息，創(chuàng)建出Stats對象并打印簡單的剖析報告。Stats是pstats模塊中的類，它是一個統(tǒng)計對象。當然，也可以使用三方工具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函數(shù)每行代碼的性能，需要給is_prime函數(shù)添加一個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模塊生成隨機數(shù)、實現(xiàn)隨機亂序和隨機抽樣？

點評：送人頭的題目，因為Python標準庫中的常用模塊應該是Python開發(fā)者都比較熟悉的內容，這個問題回如果答不上來，整個面試基本也就砸鍋了。

random.random()函數(shù)可以生成[0.0, 1.0)之間的隨機浮點數(shù)。

random.uniform(a, b)函數(shù)可以生成[a, b]或[b, a]之間的隨機浮點數(shù)。

random.randint(a, b)函數(shù)可以生成[a, b]或[b, a]之間的隨機整數(shù)。

random.shuffle(x)函數(shù)可以實現(xiàn)對序列x的原地隨機亂序。

random.choice(seq)函數(shù)可以從非空序列中取出一個隨機元素。

random.choices(population, weights=None, *, cum_weights=None, k=1)函數(shù)可以從總體中隨機抽取（有放回抽樣）出容量為k的樣本并返回樣本的列表，可以通過參數(shù)指定個體的權重，如果沒有指定權重，個體被選中的概率均等。

random.sample(population, k)函數(shù)可以從總體中隨機抽取（無放回抽樣）出容量為k的樣本并返回樣本的列表。

擴展：random模塊提供的函數(shù)除了生成均勻分布的隨機數(shù)外，還可以生成其他分布的隨機數(shù)，例如random.gauss(mu, sigma)函數(shù)可以生成高斯分布（正態(tài)分布）的隨機數(shù)；random.paretovariate(alpha)函數(shù)會生成帕累托分布的隨機數(shù)；random.gammavariate(alpha, beta)函數(shù)會生成伽馬分布的隨機數(shù)。

題目37：解釋一下線程池的工作原理。

點評：池化技術就是一種典型空間換時間的策略，我們使用的數(shù)據(jù)庫連接池、線程池等都是池化技術的應用，Python標準庫currrent.futures模塊的ThreadPoolExecutor就是線程池的實現(xiàn)，如果要弄清楚它的工作原理，可以參考下面的內容。

線程池是一種用于減少線程本身創(chuàng)建和銷毀造成的開銷的技術，屬于典型的空間換時間操作。如果應用程序需要頻繁的將任務派發(fā)到線程中執(zhí)行，線程池就是必選項，因為創(chuàng)建和釋放線程涉及到大量的系統(tǒng)底層操作，開銷較大，如果能夠在應用程序工作期間，將創(chuàng)建和釋放線程的操作變成預創(chuàng)建和借還操作，將大大減少底層開銷。線程池在應用程序啟動后，立即創(chuàng)建一定數(shù)量的線程，放入空閑隊列中。這些線程最開始都處于阻塞狀態(tài)，不會消耗CPU資源，但會占用少量的內存空間。當任務到來后，從隊列中取出一個空閑線程，把任務派發(fā)到這個線程中運行，并將該線程標記為已占用。當線程池中所有的線程都被占用后，可以選擇自動創(chuàng)建一定數(shù)量的新線程，用于處理更多的任務，也可以選擇讓任務排隊等待直到有空閑的線程可用。在任務執(zhí)行完畢后，線程并不退出結束，而是繼續(xù)保持在池中等待下一次的任務。當系統(tǒng)比較空閑時，大部分線程長時間處于閑置狀態(tài)時，線程池可以自動銷毀一部分線程，回收系統(tǒng)資源。基于這種預創(chuàng)建技術，線程池將線程創(chuàng)建和銷毀本身所帶來的開銷分攤到了各個具體的任務上，執(zhí)行次數(shù)越多，每個任務所分擔到的線程本身開銷則越小。

一般線程池都必須具備下面幾個組成部分：

線程池管理器：用于創(chuàng)建并管理線程池。

工作線程和線程隊列：線程池中實際執(zhí)行的線程以及保存這些線程的容器。

任務接口：將線程執(zhí)行的任務抽象出來，形成任務接口，確保線程池與具體的任務無關。

任務隊列：線程池中保存等待被執(zhí)行的任務的容器。

題目38：舉例說明什么情況下會出現(xiàn)KeyError、TypeError、ValueError。

舉一個簡單的例子，變量a是一個字典，執(zhí)行int(a[‘x’])這個操作就有可能引發(fā)上述三種類型的異常。如果字典中沒有鍵x，會引發(fā)KeyError；如果鍵x對應的值不是str、float、int、bool以及bytes-like類型，在調用int函數(shù)構造int類型的對象時，會引發(fā)TypeError；如果a[x]是一個字符串或者字節(jié)串，而對應的內容又無法處理成int時，將引發(fā)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函數(shù)在定義的時候，默認參數(shù)items的值就被計算出來了，即[]。因為默認參數(shù)items引用了對象[]，每次調用該函數(shù)，如果對items引用的列表進行了操作，下次調用時，默認參數(shù)還是引用之前的那個列表而不是重新賦值為[]，所以列表中會有之前添加的元素。如果通過傳參的方式為items重新賦值，那么items將引用到新的列表對象，而不再引用默認的那個列表對象。這個題在面試中經(jīng)常被問到，通常不建議使用容器類型的默認參數(shù)，像PyLint這樣的代碼檢查工具也會對這種代碼提出質疑和警告。

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

題目40：如何讀取大文件，例如內存只有4G，如何讀取一個大小為8G的文件？

很顯然4G內存要一次性的加載大小為8G的文件是不現(xiàn)實的，遇到這種情況必須要考慮多次讀取和分批次處理。在Python中讀取文件可以先通過open函數(shù)獲取文件對象，在讀取文件時，可以通過read方法的size參數(shù)指定讀取的大小，也可以通過seek方法的offset參數(shù)指定讀取的位置，這樣就可以控制單次讀取數(shù)據(jù)的字節(jié)數(shù)和總字節(jié)數(shù)。除此之外，可以使用內置函數(shù)iter將文件對象處理成迭代器對象，每次只讀取少量的數(shù)據(jù)進行處理，代碼大致寫法如下所示。

with open('...', 'rb') as file:for data in iter(lambda: file.read(2097152), b''):pass

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

split -b 512m filename

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

split -n 10 filename

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

題目41：說一下你對Python中模塊和包的理解。

每個Python文件就是一個模塊，而保存這些文件的文件夾就是一個包，但是這個作為Python包的文件夾必須要有一個名為__init__.py的文件，否則無法導入這個包。通常一個文件夾下還可以有子文件夾，這也就意味著一個包下還可以有子包，子包中的__init__.py并不是必須的。模塊和包解決了Python中命名沖突的問題，不同的包下可以有同名的模塊，不同的模塊下可以有同名的變量、函數(shù)或類。在Python中可以使用import或from … import …來導入包和模塊，在導入的時候還可以使用as關鍵字對包、模塊、類、函數(shù)、變量等進行別名，從而徹底解決編程中尤其是多人協(xié)作團隊開發(fā)時的命名沖突問題。

題目42：說一下你知道的Python編碼規(guī)范。

點評：企業(yè)的Python編碼規(guī)范基本上是參照PEP-8或谷歌開源項目風格指南來制定的，后者還提到了可以使用Lint工具來檢查代碼的規(guī)范程度，面試的時候遇到這類問題，可以先說下這兩個參照標準，然后挑重點說一下Python編碼的注意事項。

空格的使用

使用空格來表示縮進而不要用制表符（Tab）。

和語法相關的每一層縮進都用4個空格來表示。

每行的字符數(shù)不要超過79個字符，如果表達式因太長而占據(jù)了多行，除了首行之外的其余各行都應該在正常的縮進寬度上再加上4個空格。

函數(shù)和類的定義，代碼前后都要用兩個空行進行分隔。

在同一個類中，各個方法之間應該用一個空行進行分隔。

二元運算符的左右兩側應該保留一個空格，而且只要一個空格就好。

標識符命名

變量、函數(shù)和屬性應該使用小寫字母來拼寫，如果有多個單詞就使用下劃線進行連接。

類中受保護的實例屬性，應該以一個下劃線開頭。

類中私有的實例屬性，應該以兩個下劃線開頭。

類和異常的命名，應該每個單詞首字母大寫。

模塊級別的常量，應該采用全大寫字母，如果有多個單詞就用下劃線進行連接。

類的實例方法，應該把第一個參數(shù)命名為self以表示對象自身。

類的類方法，應該把第一個參數(shù)命名為cls以表示該類自身。

表達式和語句

采用內聯(lián)形式的否定詞，而不要把否定詞放在整個表達式的前面。例如：if a is not b就比if not a is b更容易讓人理解。

不要用檢查長度的方式來判斷字符串、列表等是否為None或者沒有元素，應該用if not x這樣的寫法來檢查它。

就算if分支、for循環(huán)、except異常捕獲等中只有一行代碼，也不要將代碼和if、for、except等寫在一起，分開寫才會讓代碼更清晰。

import語句總是放在文件開頭的地方。

引入模塊的時候，from math import sqrt比import math更好。

如果有多個import語句，應該將其分為三部分，從上到下分別是Python標準模塊、第三方模塊和自定義模塊，每個部分內部應該按照模塊名稱的字母表順序來排列。

題目43：運行下面的代碼是否會報錯，如果報錯請說明哪里有什么樣的錯，如果不報錯請說出代碼的執(zhí)行結果。

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裝飾器的了解，另外一個考察的點是對動態(tài)語言的理解，不需要過多的解釋。

1 2

擴展：如果不希望代碼運行時動態(tài)的給對象添加新屬性，可以在定義類時使用__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函數(shù)的高階用法在面試的時候經(jīng)常出現(xiàn)，key參數(shù)可以傳入一個函數(shù)名或一個Lambda函數(shù)，該函數(shù)的返回值代表了在排序時比較元素的依據(jù)。

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

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

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

在使用面向對象編程語言的時候，定義類是最常見的一件事情，有的時候，我們會用到只有屬性沒有方法的類，這種類的對象通常只用于組織數(shù)據(jù)，并不能接收消息，所以我們把這種類稱為數(shù)據(jù)類或者退化的類，就像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}')

命名元組與普通元組一樣是不可變容器，一旦將數(shù)據(jù)存儲在namedtuple的頂層屬性中，數(shù)據(jù)就不能再修改了，也就意味著對象上的所有屬性都遵循“一次寫入，多次讀取”的原則。和普通元組不同的是，命名元組中的數(shù)據(jù)有訪問名稱，可以通過名稱而不是索引來獲取保存的數(shù)據(jù)，不僅在操作上更加簡單，代碼的可讀性也會更好。

命名元組的本質就是一個類，所以它還可以作為父類創(chuàng)建子類。除此之外，命名元組內置了一系列的方法，例如，可以通過_asdict方法將命名元組處理成字典，也可以通過_replace方法創(chuàng)建命名元組對象的淺拷貝。

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)

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

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

要求：寫一個函數(shù)，傳入一個有若干個整數(shù)的列表，該列表中某個元素出現(xiàn)的次數(shù)超過了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面試中出現(xiàn)過，利用元素出現(xiàn)次數(shù)超過了50%這一特征，出現(xiàn)和temp相同的元素就將計數(shù)值加1，出現(xiàn)和temp不同的元素就將計數(shù)值減1。如果計數(shù)值為0，說明之前出現(xiàn)的元素已經(jīng)對最終的結果沒有影響，用temp記下當前元素并將計數(shù)值置為1。最終，出現(xiàn)次數(shù)超過了50%的這個元素一定會被賦值給變量temp。

題目47：按照題目要求寫出對應的函數(shù)。

要求：寫一個函數(shù)，傳入的參數(shù)是一個列表（列表中的元素可能也是一個列表），返回該列表最大的嵌套深度。例如：列表[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：按照題目要求寫出對應的裝飾器。

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

方法一：

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面試必問內容，這個題目比之前的題目稍微復雜一些，它需要的是一個參數(shù)化的裝飾器。

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

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

方法一：反向切片

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：按照題目要求寫出對應的函數(shù)。

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

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

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

總結

以上是生活随笔為你收集整理的面试整理：分享50道硬核Python编程题，面试前过一遍的全部內容，希望文章能夠幫你解決所遇到的問題。

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