摘要：因?yàn)槟憧赡苄枰诠ぷ髦信c一些奇怪的人合作問題多線程使用?；卮鸩辉试S真正意義上的多線程。在學(xué)習(xí)之前，很多人花了很多的時(shí)間在他們的多線程中遇到了瓶頸。

隨著人工智能、機(jī)器學(xué)習(xí)、深度學(xué)習(xí)的發(fā)展，這個(gè)領(lǐng)域也正在不斷的進(jìn)入人們的眼簾，并且?guī)砹撕芏?、很大的工作機(jī)會，隨著這些機(jī)會的誕生，Python在這個(gè)機(jī)會中也在不斷的發(fā)展壯大，因?yàn)镻ython不像其他語言一樣復(fù)雜，Python簡單易學(xué)容易被人們接受。并且這并不是我一個(gè)人在這里瞎說就可以證明的，在2019年6月PYPL流行程序設(shè)計(jì)語言中，Python排在第一位占到了28.08%，是第二名Java和第三名Javascript的和,并且還在不斷的上漲中。

而且在另外一個(gè)編程語言TIOBE指數(shù)排行榜中，Python排在了第三位，排在第一位和第二位的是Java和C語言。并且排行榜還預(yù)測認(rèn)為Python會在3-4年取代C和Java，而原因是軟件工程行業(yè)正在不斷的蓬勃發(fā)展，吸引了很多新人進(jìn)入該領(lǐng)域，Java和C對于初學(xué)者來說一些困難，而Python相對于這兩種語言來說，太過于簡單了。

站在這里，我認(rèn)為現(xiàn)在正在看這篇文章的你想要找一份有關(guān)于Python的工作，不然你也不會點(diǎn)進(jìn)來不是，你可能是一個(gè)Python的初學(xué)者，或者說已經(jīng)在Python工作崗位上已經(jīng)工作過了，但是如果你還需要找一份Python的工作的話，你可能需要證明你知道如何使用Python。以下是一些涉及與Python相關(guān)的基礎(chǔ)技能的問題。重點(diǎn)放在語言本身，而不是任何特定的包或框架。

某種程度上來說，我還沒有遇到過這么難的面試，如果你能輕松的答對這些問題，找到正確的答案，那么就快去找份工作吧。

本教程不打算涵蓋所有的工作場所因?yàn)椴煌墓椭鲿圆煌姆绞较蚰闾岢霾煌膯栴}; 他們會有各自的習(xí)慣; 他們重視的內(nèi)容也是不同的。他們會以不同的方式測試你。有些老板會讓你坐在電腦前，要求你解決簡單的問題; 有些會讓你在白板前站起來做類似的事; 有些人會給你一個(gè)需要讓你回家解決的問題，方便節(jié)省他們的時(shí)間;而還有些人會和你談?wù)劇?/p>

而對程序員的最佳測試實(shí)際上就是編程。使用簡單的教程測試是一件困難的事情。因此，為了面試過程中的加分，請確保你真的掌握了解決問題的方法。如果你真的很明白這些方法，那么你就可以利用解決問題的方法，使你獲得勝利。

同樣的，對于軟件工程師的最有效的測試實(shí)際上是工程學(xué)。本教程是關(guān)于Python作為一種語言。能夠設(shè)計(jì)高效，有效，可維護(hù)的類層次結(jié)構(gòu)來解決小眾問題是非常了不起的，并且是一項(xiàng)值得追求的技能，但是這就超出了本文的范圍。

本教程不符合PEP8標(biāo)準(zhǔn)。這是有意的，因?yàn)槿缜八觯煌睦习鍖⒆裱煌牧?xí)慣。你需要適應(yīng)公司的文化。因?yàn)閷?shí)用性勝過一切。

本教程另一個(gè)不足之處是不夠簡潔。我不想只是向你提出問題和答案，而是希望有些事情可以解決。我希望你能夠理解，或者至少理解的足夠好，這樣你們對任何有問題的話題能夠進(jìn)一步的去解釋

Python到底是什么，你可以在回答中與其他技術(shù)進(jìn)行比較（加分項(xiàng)）。

以下是幾個(gè)要點(diǎn)：

Python是一種解釋型語言。這意味著，與C語言及其變體等語言不同，Python不需要在運(yùn)行之前進(jìn)行編譯。其他解釋語言包括PHP和Ruby。

Python是動(dòng)態(tài)類型的，這意味著當(dāng)你聲明變量或類似的變量時(shí)，你不需要聲明變量的類型。你可以做先一些事情如：x=111，然后再將x="I"m a string"這樣并沒有錯(cuò)誤

Python非常適合面向?qū)ο蟮木幊蹋驗(yàn)樗试S類的定義以及組合和繼承。Python沒有訪問修飾符（如C ++的public，private），對于這一點(diǎn)的理由是因?yàn)椤覀兌际浅赡耆恕?/p>

在Python中，函數(shù)也是一個(gè)類對象。這意味著可以將它們分配給變量，從其他函數(shù)返回并傳遞給函數(shù)。類也是一個(gè)類對象

編寫Python代碼可以很快，但運(yùn)行它通常比編譯語言慢。但幸運(yùn)的是，Python允許包含基于C的擴(kuò)展，因此瓶頸可以被優(yōu)化掉并且可以經(jīng)常被優(yōu)化。這個(gè)numpy包就是一個(gè)很好的例子，它真的非常快，因?yàn)樗幚淼暮芏鄶?shù)字運(yùn)算實(shí)際上并不是由Python完成的

Python可用于許多領(lǐng)域 - Web應(yīng)用程序，自動(dòng)化，科學(xué)建模，大數(shù)據(jù)應(yīng)用程序等等。它也經(jīng)常被用作“粘合”代碼，以使其他語言和組件發(fā)揮得很好。

Python使得困難的事情變得容易，因此程序員可以專注于重寫算法和結(jié)構(gòu)，而不是關(guān)注底層的低級細(xì)節(jié)。

如果你正在申請的是Python職位，你應(yīng)該知道它是什么以及為什么它如此酷。

填寫遺漏的代碼：

def print_directory_contents(sPath):
"""
這個(gè)函數(shù)接受一個(gè)目錄的名稱?
并且打印該目錄中的路徑文件
包含目錄以及目錄中的任何文件

這個(gè)函數(shù)類似于os.walk。
但是請不要使用這個(gè)模塊系統(tǒng)。
輸入你的答案
我們對你使用嵌套結(jié)構(gòu)的能力很感興趣
"""
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)

與你的命名約定保持一致。如果在任何示例代碼中都有明顯的命名約定，請堅(jiān)持下去。即使它不是你通常使用的命名約定

遞歸函數(shù)需要遞歸和終止。確認(rèn)你真的了解這是如何發(fā)生的，這樣你就可以避免無底的調(diào)用堆棧

我們使用該os模塊以跨平臺的方式與操作系統(tǒng)進(jìn)行交互。你可以說，sChildPath = sPath + "/" + sChild但這不適用于Windows

熟悉基本的軟件包是非常值得的，但是不要為了記住所有的東西而頭痛，百度or谷歌是你在工作中遇到需要包的問題的時(shí)候的朋友！

如果你不理解代碼應(yīng)該做什么，請?zhí)岢鰡栴}

保持簡單，笨蛋！

顯示你的基本操作系統(tǒng)交互內(nèi)容方面的知識

遞歸是非常有用的

查看下面的代碼，寫下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那么不用緊張。沒有一個(gè)理智的雇主會要求你熟記標(biāo)準(zhǔn)庫。這是help(zip)的輸出。

zip(...)
zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]

Return a list of tuples, where each tuple contains the i-th element
from each of the argument sequences. The returned list is truncated
in length to the length of the shortest argument sequence.

如果這沒有任何意義，那么就請你花幾分鐘去想清楚你要選擇的方式。

A0 = {"a": 1, "c": 3, "b": 2, "e": 5, "d": 4} # the order may vary
A1 = range(0, 10) # or [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] in python 2
A2 = []
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]]

對于很多人來說，理解列表是一個(gè)很好的節(jié)省時(shí)間的方法，當(dāng)然也是一個(gè)巨大的絆腳石

如果你能讀懂它們，那么你也可以寫下來

這些代碼中的一部分是故意設(shè)計(jì)的很奇怪的。因?yàn)槟憧赡苄枰诠ぷ髦信c一些奇怪的人合作

多線程使用Python。這是個(gè)好主意嗎？列出一些方法可以讓一些Python代碼以并行方式運(yùn)行。

Python不允許真正意義上的多線程。它有一個(gè)多線程包，但如果你想使用多線程來加速你的代碼，那么使用它通常不是一個(gè)好主意。Python有一個(gè)名為全局解釋器鎖(Global Interpreter Lock（GIL）)的結(jié)構(gòu)。GIL確保每次只能執(zhí)行一個(gè)“線程”。一個(gè)線程獲取GIL，做一點(diǎn)工作，然后將GIL傳遞到下一個(gè)線程。這種情況發(fā)生的很快，因此對于人眼看來，你的線程似乎是并行運(yùn)行的，但它們實(shí)際上只是輪流使用相同的CPU核心。所有這些GIL傳遞都增加了運(yùn)行的內(nèi)存。這意味著如果你想讓代碼運(yùn)行得更快，那么使用線程包通常不是一個(gè)好主意。

使用Python的線程包也是有原因的。如果你想同時(shí)運(yùn)行一些東西，并且效率不是一個(gè)問題，那么它就完全沒問題了。或者，如果你正在運(yùn)行需要等待某些事情的代碼（例如某些IO），那么它可能會很有意義。但是線程庫不會讓你使用額外的CPU核心。

多線程可以外包到操作系統(tǒng)（通過多處理），一些調(diào)用Python代碼的外部應(yīng)用程序（例如，Spark或Hadoop），或者Python代碼調(diào)用的一些代碼例如：你可以使用你的Python代碼調(diào)用一個(gè)C函數(shù)來完成昂貴的多線程事務(wù)。

因?yàn)镚IL是一個(gè)A-hole。在學(xué)習(xí)GIL之前，很多人花了很多的時(shí)間在他們的Python多線程中遇到了瓶頸。

如何跟蹤代碼的不同版本？

版本控制！此時(shí)，你應(yīng)該表現(xiàn)的非常興奮，并告訴他們你如何使用Git（或任何你最喜歡的）來跟蹤與Granny的通信。Git是我首選的版本控制系統(tǒng)，但還有其他版本控制系統(tǒng)，例如subversion。

因?yàn)闆]有版本控制的代碼就像沒有杯子的咖啡。有時(shí)我們需要編寫一次性丟棄的腳本，這沒關(guān)系，但是如果你正在處理大量的代碼，版本控制系統(tǒng)將是一個(gè)優(yōu)勢。版本控制有助于跟蹤誰對代碼庫進(jìn)行了哪些更改; 找出Bug是什么時(shí)候引入代碼的; 跟蹤軟件的版本和發(fā)布版本; 在團(tuán)隊(duì)成員之間分發(fā)源代碼; 部署和某些自動(dòng)化。它允許你在破壞代碼之前將代碼轉(zhuǎn)回到自己的代碼之上。等等很多東西。這太棒了。

這段代碼輸出了什么：

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]

第一個(gè)函數(shù)調(diào)用應(yīng)該相當(dāng)明顯，循環(huán)將0和1附加到空列表中l(wèi).l是指向存儲在內(nèi)存中的列表的變量的名稱。 第二個(gè)調(diào)用通過在新的內(nèi)存塊中創(chuàng)建新列表開始。l然后指向這個(gè)新列表。然后它將0,1和4附加到這個(gè)新列表中。這太好了。 第三個(gè)函數(shù)調(diào)用是奇怪的。它使用存儲在原始內(nèi)存塊中的原始列表。這就是它從0和1開始的原因。

如果你不明白，試試這個(gè)：

l_mem = []

l = l_mem # the first call
for i in range(2):
l.append(i*i)

print(l) # [0, 1]

l = [3,2,1] # the second call
for i in range(3):
l.append(i*i)

print(l) # [3, 2, 1, 0, 1, 4]

l = l_mem # the third call
for i in range(3):
l.append(i*i)

print(l) # [0, 1, 0, 1, 4]

什么是猴子補(bǔ)??？，這是個(gè)好主意嗎？

猴子補(bǔ)丁是在定義函數(shù)或?qū)ο笠呀?jīng)定義后進(jìn)行更改的行為。例如：

import datetime
datetime.datetime.now = lambda: datetime.datetime(2012, 12, 12)

大多數(shù)時(shí)候，這是一個(gè)非常糟糕的想法 - 如果事情以明確的方式運(yùn)行，通常是最好的。猴子補(bǔ)丁的一個(gè)原因是測試。該模擬包對此還是非常有用的。

它表明你對單元測試中的方法有所了解。你提到避免使用猴子補(bǔ)丁會表明你不是那些喜歡花哨的代碼而不喜歡可維護(hù)代碼的程序員（他們就在那里，而且合作起來會非常糟糕）。它表明你對Python如何在較低層次上工作，如何實(shí)際存儲和調(diào)用函數(shù)等有所了解。

這是什么東西的意思是：args，*kwargs？我們?yōu)槭裁匆盟兀?/p> 回答

當(dāng)我們不確定要向函數(shù)傳遞多少參數(shù)時(shí)，或者我們想向函數(shù)傳遞已存儲的列表或參數(shù)元組時(shí)使用args。kwargs用于當(dāng)我們不知道將多少關(guān)鍵字參數(shù)傳遞給函數(shù)時(shí)，或者它可以用用于關(guān)鍵字參數(shù)傳遞字典的值。標(biāo)識符args和kwargs是一種約定，你也可以使用bob，billy但這不是明智的。

這是一個(gè)小示例：

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}

有時(shí)我們需要將未知數(shù)量的參數(shù)或關(guān)鍵字參數(shù)傳遞給函數(shù)。有時(shí)我們會想要存儲參數(shù)或關(guān)鍵字參數(shù)供以后使用。有時(shí)它只是節(jié)省時(shí)間。

這些對你來說意味著：@classmethod，@staticmethod，@property？

這些是裝飾者。裝飾器是一種特殊的函數(shù)，它既可以獲取函數(shù)并可以返回一個(gè)函數(shù)，或者獲取一個(gè)類并返回一個(gè)類。該@符號只是語法糖，允許你以一種易于閱讀的方式裝飾一些東西。

@my_decorator
def my_func(stuff):
do_things

相當(dāng)于

def my_func(stuff):
do_things

my_func = my_decorator(my_func)

裝飾器@classmethod，@staticmethod和@property是在類中定義的函數(shù)的時(shí)候使用。以下是他們的行為方式：

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))
@classmethod
def class_method(args,*kwargs):
print("calling class_method({0},{1})".format(args,kwargs))
@staticmethod
def static_method(args,*kwargs):
print("calling static_method({0},{1})".format(args,kwargs))
@property
def some_property(self,args,*kwargs):
print("calling some_property getter({0},{1},{2})".format(self,args,kwargs))
return self._some_property
@some_property.setter
def some_property(self,args,*kwargs):
print("calling some_property setter({0},{1},{2})".format(self,args,kwargs))
self._some_property = args[0]
@property
def some_other_property(self,args,*kwargs):
print("calling some_other_property getter({0},{1},{2})".format(self,args,kwargs))
return self._some_other_property

o = MyClass()

o.normal_method?

o.normal_method()?

o.normal_method(1,2,x=3,y=4)?

o.class_method

o.class_method()

o.class_method(1,2,x=3,y=4)

o.static_method

o.static_method()

o.static_method(1,2,x=3,y=4)

o.some_property

o.some_property()

o.some_other_property

o.some_property = "groovy"

o.some_property

o.some_other_property = "very groovy"

o.some_other_property

想想下面這串代碼，它將輸出什么？

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): pass

a = A()
b = B()
c = C()
d = D()
e = E()

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

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

因?yàn)镺O編程確實(shí)非常重要。真的?；卮疬@個(gè)問題表明你對繼承的理解和Python 超函數(shù)功能的使用的理解。大多數(shù)情況下，解決順序無關(guān)緊要。有時(shí)它確實(shí)如此，這取決于你的選擇。

考慮以下代碼，它將輸出什么？

class Node(object):
def __init__(self,sName):
self._lChildren = []
self.sName = sName
def __repr__(self):
return "".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 oNext
for 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)

oRoot.print_all_1()
oRoot.print_all_2()

oRoot.print_all_1() 打?。?/p>

oRoot.print_all_2() 打印：

因?yàn)榻M合和對象構(gòu)造是對象的全部。對象由東西組成的，需要以某種方式初始化。這也涉及一些關(guān)于遞歸和使用生成器的東西。

生成器是很棒的。你可以print_all_2通過構(gòu)建一個(gè)很長的列表然后打印它的內(nèi)容來實(shí)現(xiàn)類似的功能。關(guān)于生成器的一個(gè)好處是它們不需要在內(nèi)存中占用太多空間。

同樣值得指出的是，print_all_1以深度優(yōu)先的方式遍歷樹，而print_all_2是寬度優(yōu)先。確保你了解這些術(shù)語。有時(shí)，一種遍歷比另一種更合適。但這在很大程度上取決于你的選擇。

簡要描述Python的垃圾收集機(jī)制。

這里可以說很多。但你應(yīng)該提到一些要點(diǎn)：

Python維護(hù)對內(nèi)存中每個(gè)對象的引用數(shù)量的計(jì)數(shù)。如果引用計(jì)數(shù)變?yōu)榱?，則關(guān)聯(lián)的對象不再處于活動(dòng)狀態(tài)，并且可以釋放分配給該對象的內(nèi)存以用于其他內(nèi)容

偶爾會發(fā)生稱為“參考周期”的事情。垃圾收集器會定期查找這些并清理它們。一個(gè)例子是，如果你有兩個(gè)對象o1，o2那么o1.x == o2和o2.x == o1。如果o1和o2沒有被其它的東西引用那么他們不應(yīng)該是活的。但是它們中的每一個(gè)都具有1的引用計(jì)數(shù)。

某些啟發(fā)式方法用于加速垃圾收集。例如，最近創(chuàng)建的對象更可能已經(jīng)死亡了。在創(chuàng)建對象時(shí)，垃圾收集器會將它們分配給幾代。每個(gè)對象都有一代，而年輕一代則先處理。

這個(gè)解釋是CPython特有的。

按照效率順序放置以下功能。它們都包含0到1之間的數(shù)字列表。列表可能很長。一個(gè)示例輸入列表將是[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。要證明這種情況，你需要對代碼進(jìn)行概要分析。Python有一個(gè)可愛的分析包應(yīng)該可以解決問題。

import cProfile
lIn = [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 seconds

Ordered by: standard name

ncalls tottime percall cumtime percall filename:lineno(function)
1 0.009 0.009 0.044 0.044 :1(f1)
1 0.001 0.001 0.045 0.045 :1()
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 seconds

Ordered by: standard name

ncalls tottime percall cumtime percall filename:lineno(function)
1 0.008 0.008 0.023 0.023 :1(f2)
1 0.001 0.001 0.024 0.024 :1()
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 seconds

Ordered by: standard name

ncalls tottime percall cumtime percall filename:lineno(function)
1 0.016 0.016 0.054 0.054 :1(f3)
1 0.001 0.001 0.055 0.055 :1()
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}

定位和避免瓶頸通常是非常值得的。許多提高效率的編碼都?xì)w結(jié)為常識 - 在上面的示例中，如果列表是較小的，則對列表進(jìn)行排序顯然會更快，因此如果你在排序之前選擇過濾，這通常是一個(gè)好主意。不那么明顯的東西仍然可以使用適當(dāng)?shù)墓ぞ哒业?。了解這些工具是件很好的事。

你失敗的得地方？

我永遠(yuǎn)不會失敗！

表明你能夠承認(rèn)錯(cuò)誤，有能力承認(rèn)錯(cuò)誤，對錯(cuò)誤負(fù)責(zé)，并從錯(cuò)誤中吸取教訓(xùn)。如果你想要成為有用的人的話，所有這些都非常重要。如果你真的很完美，那么太糟糕了，你可能需要在這里發(fā)揮一下你的想象力和創(chuàng)造力。

你有什么個(gè)人項(xiàng)目嗎？

這表明你愿意在更新技能方面做一些更多的事情，而不是做最低限度的事。如果你在工作場所之外從事個(gè)人項(xiàng)目和代碼工作，那么雇主更有可能將你視為一種可以增長的資產(chǎn)。即使他們不問這個(gè)問題，我也覺得提出這個(gè)問題很有用。

這些問題故意涉及到許多話題。答案也是故意冗長的。在編程面試中，你需要證明自己的理解，如果能夠以簡潔的方式來表達(dá)，那么一定要這樣做。我試圖在答案中提供足夠的信息，即使你以前從未聽過其中的一些話題，也可以從中獲得一些意義。我希望你在求職時(shí)發(fā)現(xiàn)這很有用。

好了，現(xiàn)在是老虎下山的時(shí)候了，加油吧，祝你早日找到一份符合自己想法的工作，并且在這個(gè)工作上努力下去，不斷提高自己的技能，不斷的提升自我，走向更高的平臺，有更高的發(fā)展。

加油吧！陌生人