介紹
隨著人工智慧、機器學習、深度學習的發展，這個領域也正在不斷的進入人們的眼帘，並且帶來了很多、很大的工作機會，隨著這些機會的誕生，Python在這個機會中也在不斷的發展壯大，因為Python不像其他語言一樣複雜，Python簡單易學容易被人們接受。並且這並不是我一個人在這裡瞎說就可以證明的，在2019年6月PYPL流行程序設計語言中，Python排在第一位佔到了28.08%，是第二名Java和第三名Javascript的和,並且還在不斷的上漲中。
而且在另外一個程式語言TIOBE指數排行榜中，Python排在了第三位，排在第一位和第二位的是Java和C語言。並且排行榜還預測認為Python會在3-4年取代C和Java，而原因是軟體工程行業正在不斷的蓬勃發展，吸引了很多新人進入該領域，Java和C對於初學者來說一些困難，而Python相對於這兩種語言來說，太過於簡單了。
站在這裡，我認為現在正在看這篇文章的你想要找一份有關於Python的工作，不然你也不會點進來不是，你可能是一個Python的初學者，或者說已經在Python工作崗位上已經工作過了，但是如果你還需要找一份Python的工作的話，你可能需要證明你知道如何使用Python。以下是一些涉及與Python相關的基礎技能的問題。重點放在語言本身，而不是任何特定的包或框架。
某種程度上來說，我還沒有遇到過這麼難的面試，如果你能輕鬆的答對這些問題，找到正確的答案，那麼就快去找份工作吧。
本教程不是固定指南
本教程不打算涵蓋所有的工作場所因為不同的僱主會以不同的方式向你提出不同的問題; 他們會有各自的習慣; 他們重視的內容也是不同的。他們會以不同的方式測試你。有些老闆會讓你坐在電腦前，要求你解決簡單的問題; 有些會讓你在白板前站起來做類似的事; 有些人會給你一個需要讓你回家解決的問題，方便節省他們的時間;而還有些人會和你談談。
而對程式設計師的最佳測試實際上就是編程。使用簡單的教程測試是一件困難的事情。因此，為了面試過程中的加分，請確保你真的掌握了解決問題的方法。如果你真的很明白這些方法，那麼你就可以利用解決問題的方法，使你獲得勝利。
同樣的，對於軟體工程師的最有效的測試實際上是工程學。本教程是關於Python作為一種語言。能夠設計高效，有效，可維護的類層次結構來解決小眾問題是非常了不起的，並且是一項值得追求的技能，但是這就超出了本文的範圍。
本教程不符合PEP8標準。這是有意的，因為如前所述，不同的老闆將遵循不同的習慣。你需要適應公司的文化。因為實用性勝過一切。
本教程另一個不足之處是不夠簡潔。我不想只是向你提出問題和答案，而是希望有些事情可以解決。我希望你能夠理解，或者至少理解的足夠好，這樣你們對任何有問題的話題能夠進一步的去解釋
問題1
Python到底是什麼，你可以在回答中與其他技術進行比較（加分項）。
回答
以下是幾個要點：
Python是一種解釋型語言。這意味著，與C語言及其變體等語言不同，Python不需要在運行之前進行編譯。其他解釋語言包括PHP和Ruby。Python是動態類型的，這意味著當你聲明變量或類似的變量時，你不需要聲明變量的類型。你可以做先一些事情如：x=111，然後再將x="I'm a string"這樣並沒有錯誤Python非常適合面向對象的編程，因為它允許類的定義以及組合和繼承。Python沒有訪問修飾符（如C ++的public，private），對於這一點的理由是因為『我們都是成年人』在Python中，函數也是一個類對象。這意味著可以將它們分配給變量，從其他函數返回並傳遞給函數。類也是一個類對象編寫Python代碼可以很快，但運行它通常比編譯語言慢。但幸運的是，Python允許包含基於C的擴展，因此瓶頸可以被優化掉並且可以經常被優化。這個numpy包就是一個很好的例子，它真的非常快，因為它處理的很多數字運算實際上並不是由Python完成的Python可用於許多領域 - Web應用程式，自動化，科學建模，大數據應用程式等等。它也經常被用作「粘合」代碼，以使其他語言和組件發揮得很好。Python使得困難的事情變得容易，因此程式設計師可以專注於重寫算法和結構，而不是關注底層的低級細節。
為什麼這很重要：
如果你正在申請的是Python職位，你應該知道它是什麼以及為什麼它如此酷。
問題2
填寫遺漏的代碼：
def print_directory_contents(sPath):"""這個函數接受一個目錄的名稱 並且列印該目錄中的路徑文件包含目錄以及目錄中的任何文件這個函數類似於os.walk。但是請不要使用這個模塊系統。輸入你的答案我們對你使用嵌套結構的能力很感興趣"""fill_this_in
回答
def print_directory_contents(sPath):import os for sChild in os.listdir(sPath): sChildPath = os.path.join(sPath,sChild)if os.path.isdir(sChildPath):print_directory_contents(sChildPath)else:print(sChildPath)
特別注意
與你的命名約定保持一致。如果在任何示例代碼中都有明顯的命名約定，請堅持下去。即使它不是你通常使用的命名約定遞歸函數需要遞歸和終止。確認你真的了解這是如何發生的，這樣你就可以避免無底的調用堆棧我們使用該os模塊以跨平臺的方式與作業系統進行交互。你可以說，sChildPath = sPath + '/' + sChild但這不適用於Windows熟悉基本的軟體包是非常值得的，但是不要為了記住所有的東西而頭痛，百度or谷歌是你在工作中遇到需要包的問題的時候的朋友！如果你不理解代碼應該做什麼，請提出問題保持簡單，笨蛋！為什麼這很重要：
顯示你的基本作業系統交互內容方面的知識遞歸是非常有用的問題3
查看下面的代碼，寫下A0，A1，...An的最終值。
A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))A1 = range(10)A2 = sorted([i for i in A1 if i in A0])A3 = sorted([A0[s] for s in A0])A4 = [i for i in A1 if i in A3]A5 = {i:i*i for i in A1}A6 = [[i,i*i] for i in A1]
如果你不知道什麼是zip那麼不用緊張。沒有一個理智的僱主會要求你熟記標準庫。這是help(zip)的輸出。
zip(...)zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]Return a list of tuples, where each tuple contains the i-th elementfrom each of the argument sequences. The returned list is truncatedin length to the length of the shortest argument sequence.
如果這沒有任何意義，那麼就請你花幾分鐘去想清楚你要選擇的方式。
回答
A0 = {'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4} # the order may varyA1 = range(0, 10) # or [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] in python 2A2 = []A3 = [1, 2, 3, 4, 5]A4 = [1, 2, 3, 4, 5]A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]
為什麼這很重要
對於很多人來說，理解列表是一個很好的節省時間的方法，當然也是一個巨大的絆腳石如果你能讀懂它們，那麼你也可以寫下來這些代碼中的一部分是故意設計的很奇怪的。因為你可能需要在工作中與一些奇怪的人合作
問題4
多線程使用Python。這是個好主意嗎？列出一些方法可以讓一些Python代碼以並行方式運行。
回答
Python不允許真正意義上的多線程。它有一個多線程包，但如果你想使用多線程來加速你的代碼，那麼使用它通常不是一個好主意。Python有一個名為全局解釋器鎖(Global Interpreter Lock（GIL）)的結構。GIL確保每次只能執行一個「線程」。一個線程獲取GIL，做一點工作，然後將GIL傳遞到下一個線程。這種情況發生的很快，因此對於人眼看來，你的線程似乎是並行運行的，但它們實際上只是輪流使用相同的CPU核心。所有這些GIL傳遞都增加了運行的內存。這意味著如果你想讓代碼運行得更快，那麼使用線程包通常不是一個好主意。
使用Python的線程包也是有原因的。如果你想同時運行一些東西，並且效率不是一個問題，那麼它就完全沒問題了。或者，如果你正在運行需要等待某些事情的代碼（例如某些IO），那麼它可能會很有意義。但是線程庫不會讓你使用額外的CPU核心。
多線程可以外包到作業系統（通過多處理），一些調用Python代碼的外部應用程式（例如，Spark或Hadoop），或者Python代碼調用的一些代碼例如：你可以使用你的Python代碼調用一個C函數來完成昂貴的多線程事務。
為什麼這很重要
因為GIL是一個A-hole。在學習GIL之前，很多人花了很多的時間在他們的Python多線程中遇到了瓶頸。
問題5
如何跟蹤代碼的不同版本？
回答：
版本控制！此時，你應該表現的非常興奮，並告訴他們你如何使用Git（或任何你最喜歡的）來跟蹤與Granny的通信。Git是我首選的版本控制系統，但還有其他版本控制系統，例如subversion。
為什麼這很重要：
因為沒有版本控制的代碼就像沒有杯子的咖啡。有時我們需要編寫一次性丟棄的腳本，這沒關係，但是如果你正在處理大量的代碼，版本控制系統將是一個優勢。版本控制有助於跟蹤誰對代碼庫進行了哪些更改; 找出Bug是什麼時候引入代碼的; 跟蹤軟體的版本和發布版本; 在團隊成員之間分發原始碼; 部署和某些自動化。它允許你在破壞代碼之前將代碼轉回到自己的代碼之上。等等很多東西。這太棒了。
問題6
這段代碼輸出了什麼：
def f(x,l=[]):for i in range(x):l.append(i*i)print(l) f(2)f(3,[3,2,1])f(3)
回答
[0, 1][3, 2, 1, 0, 1, 4][0, 1, 0, 1, 4]
為什麼重要？
第一個函數調用應該相當明顯，循環將0和1附加到空列表中l.l是指向存儲在內存中的列表的變量的名稱。 第二個調用通過在新的內存塊中創建新列表開始。l然後指向這個新列表。然後它將0,1和4附加到這個新列表中。這太好了。 第三個函數調用是奇怪的。它使用存儲在原始內存塊中的原始列表。這就是它從0和1開始的原因。
如果你不明白，試試這個：
l_mem = []l = l_mem # the first callfor i in range(2):l.append(i*i)print(l) # [0, 1]l = [3,2,1] # the second callfor i in range(3):l.append(i*i)print(l) # [3, 2, 1, 0, 1, 4]l = l_mem # the third callfor i in range(3):l.append(i*i)print(l) # [0, 1, 0, 1, 4]
問題7
什麼是猴子補丁？，這是個好主意嗎？
回答
猴子補丁是在定義函數或對象已經定義後進行更改的行為。例如：
import datetimedatetime.datetime.now = lambda: datetime.datetime(2012, 12, 12)
大多數時候，這是一個非常糟糕的想法 - 如果事情以明確的方式運行，通常是最好的。猴子補丁的一個原因是測試。該模擬包對此還是非常有用的。
為什麼這很重要
它表明你對單元測試中的方法有所了解。你提到避免使用猴子補丁會表明你不是那些喜歡花哨的代碼而不喜歡可維護代碼的程式設計師（他們就在那裡，而且合作起來會非常糟糕）。它表明你對Python如何在較低層次上工作，如何實際存儲和調用函數等有所了解。
問題8
這是什麼東西的意思是：*args，**kwargs？我們為什麼要用它呢？
回答
當我們不確定要向函數傳遞多少參數時，或者我們想向函數傳遞已存儲的列表或參數元組時使用*args。**kwargs用於當我們不知道將多少關鍵字參數傳遞給函數時，或者它可以用用於關鍵字參數傳遞字典的值。標識符args和kwargs是一種約定，你也可以使用*bob，**billy但這不是明智的。
這是一個小示例：
def f(*args,**kwargs): print(args, kwargs)l = [1,2,3]t = (4,5,6)d = {'a':7,'b':8,'c':9}f()f(1,2,3) # (1, 2, 3) {}f(1,2,3,"groovy") # (1, 2, 3, 'groovy') {}f(a=1,b=2,c=3) # () {'a': 1, 'c': 3, 'b': 2}f(a=1,b=2,c=3,zzz="hi") # () {'a': 1, 'c': 3, 'b': 2, 'zzz': 'hi'}f(1,2,3,a=1,b=2,c=3) # (1, 2, 3) {'a': 1, 'c': 3, 'b': 2}f(*l,**d) # (1, 2, 3) {'a': 7, 'c': 9, 'b': 8}f(*t,**d) # (4, 5, 6) {'a': 7, 'c': 9, 'b': 8}f(1,2,*t) # (1, 2, 4, 5, 6) {}f(q="winning",**d) # () {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}f(1,2,*t,q="winning",**d) # (1, 2, 4, 5, 6) {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}def f2(arg1,arg2,*args,**kwargs): print(arg1,arg2, args, kwargs)f2(1,2,3) # 1 2 (3,) {}f2(1,2,3,"groovy") # 1 2 (3, 'groovy') {}f2(arg1=1,arg2=2,c=3) # 1 2 () {'c': 3}f2(arg1=1,arg2=2,c=3,zzz="hi") # 1 2 () {'c': 3, 'zzz': 'hi'}f2(1,2,3,a=1,b=2,c=3) # 1 2 (3,) {'a': 1, 'c': 3, 'b': 2}f2(*l,**d) # 1 2 (3,) {'a': 7, 'c': 9, 'b': 8}f2(*t,**d) # 4 5 (6,) {'a': 7, 'c': 9, 'b': 8}f2(1,2,*t) # 1 2 (4, 5, 6) {}f2(1,1,q="winning",**d) # 1 1 () {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}f2(1,2,*t,q="winning",**d) # 1 2 (4, 5, 6) {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
為什麼關心？
有時我們需要將未知數量的參數或關鍵字參數傳遞給函數。有時我們會想要存儲參數或關鍵字參數供以後使用。有時它只是節省時間。
問題9
這些對你來說意味著：@classmethod，@staticmethod，@property？
回答背景知識
這些是裝飾者。裝飾器是一種特殊的函數，它既可以獲取函數並可以返回一個函數，或者獲取一個類並返回一個類。該@符號只是語法糖，允許你以一種易於閱讀的方式裝飾一些東西。
@my_decoratordef my_func(stuff):do_things
相當於
def my_func(stuff):do_thingsmy_func = my_decorator(my_func)
實際答案
裝飾器@classmethod，@staticmethod和@property是在類中定義的函數的時候使用。以下是他們的行為方式：
class MyClass(object):def __init__(self):self._some_property = "properties are nice"self._some_other_property = "VERY nice"def normal_method(*args,**kwargs):print("calling normal_method({0},{1})".format(args,kwargs))@classmethoddef class_method(*args,**kwargs):print("calling class_method({0},{1})".format(args,kwargs))@staticmethoddef static_method(*args,**kwargs):print("calling static_method({0},{1})".format(args,kwargs))@propertydef some_property(self,*args,**kwargs):print("calling some_property getter({0},{1},{2})".format(self,args,kwargs))return self._some_property@some_property.setterdef some_property(self,*args,**kwargs):print("calling some_property setter({0},{1},{2})".format(self,args,kwargs))self._some_property = args[0]@propertydef some_other_property(self,*args,**kwargs):print("calling some_other_property getter({0},{1},{2})".format(self,args,kwargs))return self._some_other_propertyo = MyClass()#未修飾方法的工作原理與普通方法一樣，它們將當前實例(self)作為第一個參數o.normal_method # <bound method MyClass.normal_method of <__main__.MyClass instance at 0x7fdd2537ea28>>o.normal_method() # normal_method((<__main__.MyClass instance at 0x7fdd2537ea28>,),{})o.normal_method(1,2,x=3,y=4) # normal_method((<__main__.MyClass instance at 0x7fdd2537ea28>, 1, 2),{'y': 4, 'x': 3})# class methods always get the class as the first argumento.class_method# <bound method classobj.class_method of <class __main__.MyClass at 0x7fdd2536a390>>o.class_method()# class_method((<class __main__.MyClass at 0x7fdd2536a390>,),{})o.class_method(1,2,x=3,y=4)# class_method((<class __main__.MyClass at 0x7fdd2536a390>, 1, 2),{'y': 4, 'x': 3})# static methods have no arguments except the ones you pass in when you call themo.static_method# <function static_method at 0x7fdd25375848>o.static_method()# static_method((),{})o.static_method(1,2,x=3,y=4)# static_method((1, 2),{'y': 4, 'x': 3})# properties are a way of implementing getters and setters. It's an error to explicitly call them# "read only" attributes can be specified by creating a getter without a setter (as in some_other_property)o.some_property# calling some_property getter(<__main__.MyClass instance at 0x7fb2b70877e8>,(),{})# 'properties are nice'o.some_property()# calling some_property getter(<__main__.MyClass instance at 0x7fb2b70877e8>,(),{})# Traceback (most recent call last):# File "<stdin>", line 1, in <module># TypeError: 'str' object is not callableo.some_other_property# calling some_other_property getter(<__main__.MyClass instance at 0x7fb2b70877e8>,(),{})# 'VERY nice'# o.some_other_property()# calling some_other_property getter(<__main__.MyClass instance at 0x7fb2b70877e8>,(),{})# Traceback (most recent call last):# File "<stdin>", line 1, in <module># TypeError: 'str' object is not callableo.some_property = "groovy"# calling some_property setter(<__main__.MyClass object at 0x7fb2b7077890>,('groovy',),{})o.some_property# calling some_property getter(<__main__.MyClass object at 0x7fb2b7077890>,(),{})# 'groovy'o.some_other_property = "very groovy"# Traceback (most recent call last):# File "<stdin>", line 1, in <module># AttributeError: can't set attributeo.some_other_property# calling some_other_property getter(<__main__.MyClass object at 0x7fb2b7077890>,(),{})# 'VERY nice'
問題10
想想下面這串代碼，它將輸出什麼？
class A(object):def go(self):print("go A go!")def stop(self):print("stop A stop!")def pause(self):raise Exception("Not Implemented")class B(A):def go(self):super(B, self).go()print("go B go!")class C(A):def go(self):super(C, self).go()print("go C go!")def stop(self):super(C, self).stop()print("stop C stop!")class D(B,C):def go(self):super(D, self).go()print("go D go!")def stop(self):super(D, self).stop()print("stop D stop!")def pause(self):print("wait D wait!")class E(B,C): passa = A()b = B()c = C()d = D()e = E()# specify output from here onwardsa.go()b.go()c.go()d.go()e.go()a.stop()b.stop()c.stop()d.stop()e.stop()a.pause()b.pause()c.pause()d.pause()e.pause()
回答
輸出在以下段中的注釋中指定：
a.go()# go A go!b.go()# go A go!# go B go!c.go()# go A go!# go C go!d.go()# go A go!# go C go!# go B go!# go D go!e.go()# go A go!# go C go!# go B go!a.stop()# stop A stop!b.stop()# stop A stop!c.stop()# stop A stop!# stop C stop!d.stop()# stop A stop!# stop C stop!# stop D stop!e.stop()# stop A stop!a.pause()# ... Exception: Not Implementedb.pause()# ... Exception: Not Implementedc.pause()# ... Exception: Not Implementedd.pause()# wait D wait!e.pause()# ...Exception: Not Implemented
我們為什麼關心？
因為OO編程確實非常重要。真的。回答這個問題表明你對繼承的理解和Python 超函數功能的使用的理解。大多數情況下，解決順序無關緊要。有時它確實如此，這取決於你的選擇。
問題11
考慮以下代碼，它將輸出什麼？
class Node(object):def __init__(self,sName):self._lChildren = []self.sName = sNamedef __repr__(self):return "<Node '{}'>".format(self.sName)def append(self,*args,**kwargs):self._lChildren.append(*args,**kwargs)def print_all_1(self):print(self)for oChild in self._lChildren:oChild.print_all_1()def print_all_2(self):def gen(o):lAll = [o,]while lAll:oNext = lAll.pop(0)lAll.extend(oNext._lChildren)yield oNextfor oNode in gen(self):print(oNode)oRoot = Node("root")oChild1 = Node("child1")oChild2 = Node("child2")oChild3 = Node("child3")oChild4 = Node("child4")oChild5 = Node("child5")oChild6 = Node("child6")oChild7 = Node("child7")oChild8 = Node("child8")oChild9 = Node("child9")oChild10 = Node("child10")oRoot.append(oChild1)oRoot.append(oChild2)oRoot.append(oChild3)oChild1.append(oChild4)oChild1.append(oChild5)oChild2.append(oChild6)oChild4.append(oChild7)oChild3.append(oChild8)oChild3.append(oChild9)oChild6.append(oChild10)# specify output from here onwardsoRoot.print_all_1()oRoot.print_all_2()
回答
oRoot.print_all_1() 列印：
<Node 'root'><Node 'child1'><Node 'child4'><Node 'child7'><Node 'child5'><Node 'child2'><Node 'child6'><Node 'child10'><Node 'child3'><Node 'child8'><Node 'child9'>
oRoot.print_all_2() 列印：
<Node 'root'><Node 'child1'><Node 'child2'><Node 'child3'><Node 'child4'><Node 'child5'><Node 'child6'><Node 'child8'><Node 'child9'><Node 'child7'><Node 'child10'>
我們為什麼關心？
因為組合和對象構造是對象的全部。對象由東西組成的，需要以某種方式初始化。這也涉及一些關於遞歸和使用生成器的東西。
生成器是很棒的。你可以print_all_2通過構建一個很長的列表然後列印它的內容來實現類似的功能。關於生成器的一個好處是它們不需要在內存中佔用太多空間。
同樣值得指出的是，print_all_1以深度優先的方式遍歷樹，而print_all_2是寬度優先。確保你了解這些術語。有時，一種遍歷比另一種更合適。但這在很大程度上取決於你的選擇。
問題12
簡要描述Python的垃圾收集機制。
回答
這裡可以說很多。但你應該提到一些要點：
Python維護對內存中每個對象的引用數量的計數。如果引用計數變為零，則關聯的對象不再處於活動狀態，並且可以釋放分配給該對象的內存以用於其他內容偶爾會發生稱為「參考周期」的事情。垃圾收集器會定期查找這些並清理它們。一個例子是，如果你有兩個對象o1，o2那麼o1.x == o2和o2.x == o1。如果o1和o2沒有被其它的東西引用那麼他們不應該是活的。但是它們中的每一個都具有1的引用計數。某些啟發式方法用於加速垃圾收集。例如，最近創建的對象更可能已經死亡了。在創建對象時，垃圾收集器會將它們分配給幾代。每個對象都有一代，而年輕一代則先處理。這個解釋是CPython特有的。
問題13
按照效率順序放置以下功能。它們都包含0到1之間的數字列表。列表可能很長。一個示例輸入列表將是[random.random() for i in range(100000)]。你如何證明你的答案是正確的？
def f1(lIn):l1 = sorted(lIn)l2 = [i for i in l1 if i<0.5]return [i*i for i in l2]def f2(lIn):l1 = [i for i in lIn if i<0.5]l2 = sorted(l1)return [i*i for i in l2]def f3(lIn):l1 = [i*i for i in lIn]l2 = sorted(l1)return [i for i in l1 if i<(0.5*0.5)]
回答
最高效到最低效：f2，f1，f3。要證明這種情況，你需要對代碼進行概要分析。Python有一個可愛的分析包應該可以解決問題。
import cProfilelIn = [random.random() for i in range(100000)]cProfile.run('f1(lIn)')cProfile.run('f2(lIn)')cProfile.run('f3(lIn)')
為了完成，以下是上述配置文件的輸出：
>>> cProfile.run('f1(lIn)')4 function calls in 0.045 secondsOrdered by: standard namencalls tottime percall cumtime percall filename:lineno(function)1 0.009 0.009 0.044 0.044 <stdin>:1(f1)1 0.001 0.001 0.045 0.045 <string>:1(<module>)1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}1 0.035 0.035 0.035 0.035 {sorted}>>> cProfile.run('f2(lIn)')4 function calls in 0.024 secondsOrdered by: standard namencalls tottime percall cumtime percall filename:lineno(function)1 0.008 0.008 0.023 0.023 <stdin>:1(f2)1 0.001 0.001 0.024 0.024 <string>:1(<module>)1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}1 0.016 0.016 0.016 0.016 {sorted}>>> cProfile.run('f3(lIn)')4 function calls in 0.055 secondsOrdered by: standard namencalls tottime percall cumtime percall filename:lineno(function)1 0.016 0.016 0.054 0.054 <stdin>:1(f3)1 0.001 0.001 0.055 0.055 <string>:1(<module>)1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}1 0.038 0.038 0.038 0.038 {sorted}
為何關心？
定位和避免瓶頸通常是非常值得的。許多提高效率的編碼都歸結為常識 - 在上面的示例中，如果列表是較小的，則對列表進行排序顯然會更快，因此如果你在排序之前選擇過濾，這通常是一個好主意。不那麼明顯的東西仍然可以使用適當的工具找到。了解這些工具是件很好的事。
問題14
你失敗的得地方？
錯誤的答案
我永遠不會失敗！
為什麼這很重要：
表明你能夠承認錯誤，有能力承認錯誤，對錯誤負責，並從錯誤中吸取教訓。如果你想要成為有用的人的話，所有這些都非常重要。如果你真的很完美，那麼太糟糕了，你可能需要在這裡發揮一下你的想像力和創造力。
問題15
你有什麼個人項目嗎？
真的嗎？
這表明你願意在更新技能方面做一些更多的事情，而不是做最低限度的事。如果你在工作場所之外從事個人項目和代碼工作，那麼僱主更有可能將你視為一種可以增長的資產。即使他們不問這個問題，我也覺得提出這個問題很有用。
結論
這些問題故意涉及到許多話題。答案也是故意冗長的。在編程面試中，你需要證明自己的理解，如果能夠以簡潔的方式來表達，那麼一定要這樣做。我試圖在答案中提供足夠的信息，即使你以前從未聽過其中的一些話題，也可以從中獲得一些意義。我希望你在求職時發現這很有用。
好了，現在是老虎下山的時候了，加油吧，祝你早日找到一份符合自己想法的工作，並且在這個工作上努力下去，不斷提高自己的技能，不斷的提升自我，走向更高的平臺，有更高的發展。
加油吧！陌生人