摘要：因為你可能需要在工作中與一些奇怪的人合作問題多線程使用。回答不允許真正意義上的多線程。在學習之前，很多人花了很多的時間在他們的多線程中遇到了瓶頸。

隨著人工智能、機器學習、深度學習的發展，這個領域也正在不斷的進入人們的眼簾，并且帶來了很多、很大的工作機會，隨著這些機會的誕生，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標準。這是有意的，因為如前所述，不同的老板將遵循不同的習慣。你需要適應公司的文化。因為實用性勝過一切。

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

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職位，你應該知道它是什么以及為什么它如此酷。

填寫遺漏的代碼：

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谷歌是你在工作中遇到需要包的問題的時候的朋友！

如果你不理解代碼應該做什么，請提出問題

保持簡單，笨蛋！

顯示你的基本操作系統交互內容方面的知識

遞歸是非常有用的

查看下面的代碼，寫下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 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]]

對于很多人來說，理解列表是一個很好的節省時間的方法，當然也是一個巨大的絆腳石

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

這些代碼中的一部分是故意設計的很奇怪的。因為你可能需要在工作中與一些奇怪的人合作

多線程使用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多線程中遇到了瓶頸。

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

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

因為沒有版本控制的代碼就像沒有杯子的咖啡。有時我們需要編寫一次性丟棄的腳本，這沒關系，但是如果你正在處理大量的代碼，版本控制系統將是一個優勢。版本控制有助于跟蹤誰對代碼庫進行了哪些更改; 找出Bug是什么時候引入代碼的; 跟蹤軟件的版本和發布版本; 在團隊成員之間分發源代碼; 部署和某些自動化。它允許你在破壞代碼之前將代碼轉回到自己的代碼之上。等等很多東西。這太棒了。

這段代碼輸出了什么：

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

什么是猴子補丁？，這是個好主意嗎？

猴子補丁是在定義函數或對象已經定義后進行更改的行為。例如：

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

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

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

這是什么東西的意思是：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}

有時我們需要將未知數量的參數或關鍵字參數傳遞給函數。有時我們會想要存儲參數或關鍵字參數供以后使用。有時它只是節省時間。

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

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

@my_decorator
def my_func(stuff):
do_things

相當于

def my_func(stuff):
do_things

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

因為OO編程確實非常重要。真的。回答這個問題表明你對繼承的理解和Python 超函數功能的使用的理解。大多數情況下，解決順序無關緊要。有時它確實如此，這取決于你的選擇。

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

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() 打印：

因為組合和對象構造是對象的全部。對象由東西組成的，需要以某種方式初始化。這也涉及一些關于遞歸和使用生成器的東西。

生成器是很棒的。你可以print_all_2通過構建一個很長的列表然后打印它的內容來實現類似的功能。關于生成器的一個好處是它們不需要在內存中占用太多空間。

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

簡要描述Python的垃圾收集機制。

這里可以說很多。但你應該提到一些要點：

Python維護對內存中每個對象的引用數量的計數。如果引用計數變為零，則關聯的對象不再處于活動狀態，并且可以釋放分配給該對象的內存以用于其他內容

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

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

這個解釋是CPython特有的。

按照效率順序放置以下功能。它們都包含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 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}

定位和避免瓶頸通常是非常值得的。許多提高效率的編碼都歸結為常識 - 在上面的示例中，如果列表是較小的，則對列表進行排序顯然會更快，因此如果你在排序之前選擇過濾，這通常是一個好主意。不那么明顯的東西仍然可以使用適當的工具找到。了解這些工具是件很好的事。

你失敗的得地方？

我永遠不會失??！

表明你能夠承認錯誤，有能力承認錯誤，對錯誤負責，并從錯誤中吸取教訓。如果你想要成為有用的人的話，所有這些都非常重要。如果你真的很完美，那么太糟糕了，你可能需要在這里發揮一下你的想象力和創造力。

你有什么個人項目嗎？

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

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

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

加油吧！陌生人