介紹

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

而且在另外一個編程語言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)來不是，你可能是一個Python的初學(xué)者，或者說已經(jīng)在Python工作崗位上已經(jīng)工作過了，但是如果你還需要找一份Python的工作的話，你可能需要證明你知道如何使用Python。以下是一些涉及與Python相關(guān)的基礎(chǔ)技能的問題。重點(diǎn)放在語言本身，而不是任何特定的包或框架。

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

本教程不是固定指南

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

而對程序員的最佳測試實(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í)用性勝過一切。

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

問題1

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

回答

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

• Python是一種解釋型語言。這意味著，與C語言及其變體等語言不同，Python不需要在運(yùn)行之前進(jìn)行編譯。其他解釋語言包括PHP和Ruby。
• Python是動態(tài)類型的，這意味著當(dāng)你聲明變量或類似的變量時，你不需要聲明變量的類型。你可以做先一些事情如：x=111，然后再將x="I'm a string"這樣并沒有錯誤
• Python非常適合面向?qū)ο蟮木幊?，因?yàn)樗试S類的定義以及組合和繼承。Python沒有訪問修飾符（如C ++的public，private），對于這一點(diǎn)的理由是因?yàn)椤覀兌际浅赡耆恕?/span>
• 在Python中，函數(shù)也是一個類對象。這意味著可以將它們分配給變量，從其他函數(shù)返回并傳遞給函數(shù)。類也是一個類對象
• 編寫Python代碼可以很快，但運(yùn)行它通常比編譯語言慢。但幸運(yùn)的是，Python允許包含基于C的擴(kuò)展，因此瓶頸可以被優(yōu)化掉并且可以經(jīng)常被優(yōu)化。這個numpy包就是一個很好的例子，它真的非?？?，因?yàn)樗幚淼暮芏鄶?shù)字運(yùn)算實(shí)際上并不是由Python完成的
• Python可用于許多領(lǐng)域 - Web應(yīng)用程序，自動化，科學(xué)建模，大數(shù)據(jù)應(yīng)用程序等等。它也經(jīng)常被用作“粘合”代碼，以使其他語言和組件發(fā)揮得很好。
• Python使得困難的事情變得容易，因此程序員可以專注于重寫算法和結(jié)構(gòu)，而不是關(guān)注底層的低級細(xì)節(jié)。

為什么這很重要：

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

問題2

填寫遺漏的代碼：

def print_directory_contents(sPath):

"""

這個函數(shù)接受一個目錄的名稱

并且打印該目錄中的路徑文件

包含目錄以及目錄中的任何文件

這個函數(shù)類似于os.walk。

但是請不要使用這個模塊系統(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谷歌是你在工作中遇到需要包的問題的時候的朋友！
• 如果你不理解代碼應(yīng)該做什么，請?zhí)岢鰡栴}
• 保持簡單，笨蛋！

為什么這很重要：

• 顯示你的基本操作系統(tǒng)交互內(nèi)容方面的知識
• 遞歸是非常有用的

問題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那么不用緊張。沒有一個理智的雇主會要求你熟記標(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]]

為什么這很重要

1. 對于很多人來說，理解列表是一個很好的節(jié)省時間的方法，當(dāng)然也是一個巨大的絆腳石
2. 如果你能讀懂它們，那么你也可以寫下來
3. 這些代碼中的一部分是故意設(shè)計(jì)的很奇怪的。因?yàn)槟憧赡苄枰诠ぷ髦信c一些奇怪的人合作

問題4

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

回答

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

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

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

為什么這很重要

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

問題5

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

回答：

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

為什么這很重要：

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

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

為什么重要？

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

問題7

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

回答

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

import datetime

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

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

為什么這很重要

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

問題8

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

回答

當(dāng)我們不確定要向函數(shù)傳遞多少參數(shù)時，或者我們想向函數(shù)傳遞已存儲的列表或參數(shù)元組時使用*args。**kwargs用于當(dāng)我們不知道將多少關(guān)鍵字參數(shù)傳遞給函數(shù)時，或者它可以用用于關(guān)鍵字參數(shù)傳遞字典的值。標(biāo)識符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}

為什么關(guān)心？

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

問題9

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

回答背景知識

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

@my_decorator

def my_func(stuff):

do_things

相當(dāng)于

def my_func(stuff):

do_things

my_func = my_decorator(my_func)

實(shí)際答案

裝飾器@classmethod，@staticmethod和@property是在類中定義的函數(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()

#未修飾方法的工作原理與普通方法一樣，它們將當(dāng)前實(shí)例(self)作為第一個參數(shù)

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 argument

o.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 them

o.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 callable

o.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 callable

o.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 attribute

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

a = A()

b = B()

c = C()

d = D()

e = E()

# specify output from here onwards

a.go()

b.go()

c.go()