本文轉載自公眾號“讀芯術”(ID：AI_Discovery)

不久前我才通過面試，入職成為了“數據科學家”，但我實際上做的卻是“Python工程師”的工作。如果能提前復習Python線程生命周期的知識，而不是推薦系統，我可以準備得更好。

出于這種想法，我整理了python面試或準備求職用的問題和答案。大多數數據科學家會編寫大量代碼，因此這均適用于數據科學家和軟件工程師。

無論你是準備面試抑或是復習Python知識，這份清單都將能夠幫到你。

問題不分先后，我們開始吧!

[[325689]]

1. 列表和元組有什么區別?

每次python或數據科學面試中，我都被問到過這個問題。求職者應對這個答案了如指掌。

• 列表是可變的。創建后可被修改。
• 元組是不可變的。一旦創建了元組，就不能更改
• 列表有順序，是有序序列，通常是相同類型的對象。即：按創建日期排序的所有用戶名，[" Seth"，" Ema"，" Eli"]
• 元組有結構。每個索引中可能存在不同的數據類型。即：內存中的數據庫記錄，(2，" Ema"，" 2020–04–16")#id, name,created_at

2. "is"和" =="有什么區別?

在我初學python時，我以為它們是相同的……卻出現了一些bug。因此，為了記錄，is表示檢查身份，而==表示檢查相等性。

可通過一個例子來解釋。創建一些列表并將其分配給名稱。請注意，b指向與下面的a相同的對象。

a = [1,2,3] 
b = a 
c = [1,2,3] 

檢查是否相等，并注意它們是否全都相等。

print(a == b) 
print(a == c) 
#=> True 
#=> True 

但是它們具有相同的身份嗎?不。

print(a is b) 
print(a is c) 
#=> True 
#=> False 

我們可以通過打印其對象ID進行驗證。

print(id(a)) 
print(id(b)) 
print(id(c)) 
#=>4369567560 
#=> 4369567560 
#=>4369567624 

c與a和b具有不同的ID。

3. 什么是裝飾器?

這個問題每次面試都會問到。問題本身值得再寫一篇文章，但是如果可以逐步編寫自己的示例，那么就已經準備好回答這個問題了。

裝飾器允許通過將現有函數傳遞給裝飾器，從而將功能添加到現有函數，該裝飾器將執行現有函數以及其他代碼。

編寫一個裝飾器，該裝飾器會在調用另一個函數時記錄日志。

編寫裝飾器函數。這需要一個函數func作為參數。它還定義了一個函數log_function_called，該函數調用func()并執行一些代碼print(f'{func}called。')。然后返回定義的函數

deflogging(func): 
    def log_function_called(): 
      print(f'{func} called.') 
        func() 
        return log_function_called 

編寫其他函數，最終將裝飾器添加進去(但尚未)。

def my_name(): 
  print('chris')def friends_name(): 
  print('naruto')my_name() 
friends_name() 
#=> chris 
#=> naruto 

現在將裝飾器添加到兩者。

@logging 
def my_name(): 
 print('chris')@logging 
def friends_name(): 
 print('naruto')my_name() 
friends_name() 
#=> <function my_name at 0x10fca5a60> called. 
#=> chris 
#=> <function friends_name at 0x10fca5f28> called. 
#=> naruto 

了解現在如何僅通過在其上面添加@logging就能輕松地將日志添加到編寫的任何函數中。

4. 如何實現字符串插值?

在不導入Template類的情況下，有3種實現字符串插值的方法。

name = 'Chris'# 1. f strings 
print(f'Hello {name}')# 2. % operator 
print('Hey %s %s' % (name, name))# 3. format 
print( 
 "My name is {}".format((name)) 
) 

5. 解釋range函數

Range生成一個整數列表，有3種使用方式。

該函數接受1到3個參數。請注意，將每種用法都包裝在列表解析中，以便看到生成的值。

range(stop)：生成從0到"stop"整數的整數。

[i for i in range(10)] 
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

range(start，stop)：生成從" start"到" stop"整數的整數。

[i for i in range(2,10)] 
#=> [2, 3, 4, 5, 6, 7, 8, 9] 

range(start，stop，step)：以" step"為間隔生成從" start"到" stop"的整數。

[i for i in range(2,10,2)] 
#=> [2, 4, 6, 8] 

6.定義一個名為car的類，具有2個屬性，即"顏色"和"速度"。然后創建一個實例并返回速度。

class Car : 
    def __init__(self, color, speed): 
        self.color = color 
        self.speed = speedcar =Car('red','100mph') 
car.speed 
#=> '100mph' 

7. python中的實例方法，靜態方法和類方法之間有什么區別?

實例方法：接受self參數并與類的特定實例相關。

靜態方法：使用@staticmethod裝飾器，與特定實例無關，并且是獨立的(請勿修改類或實例屬性)

類方法：接受cls參數并可以修改類本身

舉例說明一個虛構的CoffeeShop類的區別。

class CoffeeShop: 
    specialty = 'espresso' 
     def __init__(self, coffee_price): 
        self.coffee_price = coffee_price 
      # instance method 
    def make_coffee(self): 
        print(f'Making {self.specialty}for ${self.coffee_price}') 
       # static method    
    @staticmethod 
    def check_weather(): 
        print('Its sunny')    # class method 
    @classmethod 
    def change_specialty(cls, specialty): 
        cls.specialty = specialty 
        print(f'Specialty changed to{specialty}') 

CoffeeShop類具有specialty的屬性，默認情況下設置為" espresso"。CoffeeShop的每個實例都使用屬性coffee_price初始化。它還有3種方法，實例方法、靜態方法和類方法。

[[325690]]

圖源：unsplash

以coffee_price為5初始化咖啡店的實例。然后調用實例方法make_coffee。

coffee_shop = CoffeeShop('5') 
coffee_shop.make_coffee() 
#=> Making espresso for $5 

現在調用靜態方法。靜態方法無法修改類或實例狀態，因此通常用于實用程序功能，例如，添加兩個數字。我們用其來檢查天氣。Its sunny。真棒!

coffee_shop.check_weather() 
#=> Itssunny 

現在使用類方法來修改咖啡店的特色菜，然后再修改make_coffee。

coffee_shop.change_specialty('dripcoffee') 
#=> Specialty changed to drip coffeecoffee_shop.make_coffee() 
#=> Making drip coffee for $5 

請注意，make_coffee以前是用來制作espresso 的，但現在卻可以制作drip coffee!

8. 解釋filter函數的運行原理

顧名思義，Filter函數的運行原理是按順序過濾元素。

每個元素都傳遞給一個函數，如果函數返回True，則按輸出順序返回;如果函數返回False，則將其丟棄。

def add_three(x): 
    if x % 2 == 0: 
        return True        
    else: 
        return Falseli =[1,2,3,4,5,6,7,8][i for i in filter(add_three, li)] 
#=> [2, 4, 6, 8] 

請注意如何刪除所有不能被2整除的元素。

9. python是按引用調用還是按值調用?

如果已經搜索了這個問題并閱讀了前幾頁，請準備好深入了解語義。最好僅了解其工作原理。

不變的對象，如字符串，數字和元組是按值調用的。請注意，在函數內部進行修改后，name的值不會在函數外部發生變化。name的值已分配給該功能范圍內的內存中的新塊。

name = 'chr'def add_chars(s): 
    s += 'is' 
    print(s) 
   add_chars(name)    
print(name) 
#=> chris 
#=> chr 

可變對象，如list，按引用調用。注意在函數外部定義的列表是如何在函數內部被修改的。函數中的參數指向內存中存儲li值的原始塊。

li = [1,2]def add_element(seq): 
    seq.append(3) 
    print(seq) 
add_element(li)    
print(li) 
#=> [1, 2, 3] 
#=> [1, 2, 3] 

10. 如何撤消列表?

請注意如何在列表上調用reverse()并對其進行突變。它不會返回變異列表本身。

li = ['a','b','c']print(li) 
li.reverse() 
print(li) 
#=> ['a', 'b', 'c'] 
# 

11. 說明map函數的工作原理

map通過將函數應用于序列中的每個元素，返回由返回值組成的列表。

def add_three(x): 
    return x + 3li = [1,2,3][i for i inmap(add_three, li)] 
#=> [4, 5, 6] 

上面，列表中的每個元素都添加了3。

12. 字符串乘法如何工作?

讓我們看看將字符串‘cat’乘以3的結果。

'cat' * 3 
#=> 'catcatcat' 

該字符串將自身連接3次。

13. 列表乘法如何工作?

我們來看看將列表[1,2,3]乘以2的結果。

[1,2,3] * 2 
#=> [1, 2,3, 1, 2, 3] 
1 

輸出包含重復兩次的[1,2,3]內容的列表。

14. 在類上"self"指的是什么?

self是指類本身的實例。這就是我們賦予方法訪問權限并能夠更新方法所屬對象的能力。

下面，將self傳遞給__init __()使我們能夠在初始化時設置實例的顏色。

class Shirt: 
    def __init__(self, color): 
        self.color = color 
       s = Shirt('yellow') 
s.color 
#=> 'yellow' 

15. 如何連接python中的列表?

將2個列表加在一起并進行串聯。請注意，數組的功能不同。

a = [1,2] 
b = [3,4,5]a + b 
#=> [1, 2, 3, 4, 5] 

16. 淺拷貝和深拷貝之間有什么區別?

在可變對象(列表)的情境下進行討論。對于不可變對象，淺與深并不重要。

這里介紹3種情況。

一是引用原始對象。這將新名稱li2指向li1在內存中指向的相同位置。因此，對li1所做的任何更改也會在li2中發生。

li1 = [['a'],['b'],['c']] 
li2 = li1li1.append(['d']) 
print(li2) 
#=> [['a'], ['b'], ['c'], ['d']] 

二是創建原始文檔的淺拷貝。可以使用list()構造函數來做到這一點。淺拷貝會創建一個新對象，但會引用原始對象來填充它。因此，將新對象添加到原始集合li3中不會傳播到li4，但是修改li3中的一個對象將傳播到li4。

li3 = [['a'],['b'],['c']] 
li4 = list(li3)li3.append([4]) 
print(li4) 
#=> [['a'], ['b'], ['c']]li3[0][0] = ['X'] 
print(li4) 
#=> [[['X']], ['b'], ['c']] 

三是創建一個深拷貝。這是通過copy.deepcopy()完成的。現在，這兩個對象是完全獨立的，并且對其中任何一個做出更改不會對另一個對象產生影響。

import copyli5 =[['a'],['b'],['c']] 
li6 = copy.deepcopy(li5)li5.append([4]) 
li5[0][0] = ['X'] 
print(li6) 
#=> [['a'], ['b'], ['c']] 
=> 

17. 如何連接兩個數組?

請記住，數組不是列表。數組來自Numpy和算術函數，例如線性代數。

需要使用Numpy的連接函數來實現。

import numpy as npnpa =np.array([1,2,3]) 
b = np.array([4,5,6])np.concatenate((a,b)) 
#=> array([1, 2, 3, 4, 5, 6]) 

18. 喜歡Python的原因?

Python非常易讀，并且有一種Python方式可以處理幾乎所有事情，這意味著它是一種簡潔明了的首選方式。

將其與Ruby相比，后者通常有很多方法來做某事，而沒有指南來說明哪個是首選。

 

[[325691]]

 

 

圖源：unsplash

 

19. 最喜歡使用Python的哪個庫?

當處理大量數據時，沒有什么比pandas庫那么實用了，這使得操作和可視化數據變得輕而易舉。

20. 命名可變和不可變的對象

不可變表示創建后無法修改狀態。例如：int、float、bool、string和tuple。

可變表示狀態在創建后可以進行修改。比如列表、字典和集合。

21. 如何將數字四舍五入到小數點后三位?

使用round(value，decimal_places)函數。

a = 5.12345 
round(a,3) 
#=> 5.123 

22. 如何分割列表?

切片符號采用3個參數list [start：stop：step]，其中step是返回元素的間隔。

a =[0,1,2,3,4,5,6,7,8,9]print(a[:2]) 
#=> [0, 1]print(a[8:]) 
#=> [8, 9]print(a[2:8]) 
#=> [2, 3, 4, 5, 6, 7]print(a[2:8:2]) 
#=> [2, 4, 6] 

23. 列表和數組有什么區別?

注意：Python的標準庫有一個數組對象，但在這里專門指的是常用的Numpy數組。

• 列表存在于python的標準庫中，數組由Numpy定義。
• 列表可以在每個索引處填充不同類型的數據，數組需要齊次元素。
• 列表上的運算可以從列表中添加或刪除元素，數組函數進行線性代數運算。
• 數組占用內存少，功能更多。

有關數組的知識值得再寫一篇文章。

24. 什么是pickling?

picking是在Python中序列化和反序列化對象的協助方法。

在下面的示例中，對字典列表進行序列化和反序列化。

import pickleobj = [ 
    {'id':1, 'name':'Stuffy'}, 
    {'id':2, 'name': 'Fluffy'} 
]with open('file.p', 'wb') as f: 
    pickle.dump(obj, f)withopen('file.p', 'rb') as f: 
    loaded_obj =pickle.load(f)print(loaded_obj) 
#=> [{'id': 1, 'name': 'Stuffy'}, {'id': 2, 'name': 'Fluffy'}] 

25. 字典和JSON有什么區別?

Dict是python數據類型，是已索引但無序的鍵和值的集合。

JSON只是遵循指定格式的字符串，用于傳輸數據。

26. 在Python中使用了哪些ORM?

ORM(對象關系映射)將數據模型(通常在應用程序中)映射到數據庫表，并簡化了數據庫操作。

SQLAlchemy通常在Flask的上下文中使用，而Django擁有自己的ORM。

['c', 'b', 'a'] 

27. any()和all()如何工作?

Any接受一個序列，如果序列中的任一元素為true，則返回true。

僅當序列中的所有元素均為true時，All才返回true。

a = [False, False, False] 
b = [True, False, False] 
c = [True, True, True]print( any(a) ) 
print( any(b) ) 
print( any(c) ) 
#=> False 
#=> True 
#=> Trueprint( all(a) ) 
print( all(b) ) 
print( all(c) ) 
#=> False 
#=> False 
#=> True 

28. 字典或列表的查找速度更快嗎?

在列表中查找值需要O(n)時間，因為需要遍歷整個列表直到找到值為止。

在字典中查找鍵需要O(1)時間，因為它是一個哈希表。

如果值很多，時間可能會相差很大，因此通常建議使用字典來提高速度。但是它們確實還有其他限制，例如需要唯一鍵。

 

[[325692]]

 

 

圖源：unsplash

 

29. 如何返回整數的二進制?

使用bin()函數。

bin(5) 
#=>'0b101' 

30. 如何從列表中刪除重復的元素?

可以通過將列表轉換為集合然后返回列表來完成。

a = [1,1,1,2,3] 
a = list(set(a)) 
print(a) 
#=> [1, 2, 3] 

31. 如何檢查列表中是否存在值?

使用in。

'a' in ['a','b','c'] 
#=> True'a' in [1,2,3] 
#=> False 

32. append和extend有什么區別?

append將值添加到列表，而extend將另一個列表中的值添加到這個列表。

a = [1,2,3] 
b = [1,2,3]a.append(6) 
print(a) 
#=> [1, 2, 3, 6]b.extend([4,5]) 
print(b) 
#=> [1, 2, 3, 4, 5] 

33. 如何取整數的絕對值?

這可以通過abs()函數來完成。

abs(2) 
#=> 2abs(-2) 
#=> 2 

34. 如何將兩個列表組合成一個元組列表?

可以使用zip函數將列表組合成一個元組列表。這不僅限于僅使用兩個列表。也可以用3個或更多來完成。

a = ['a','b','c'] 
b = [1,2,3][(k,v) for k,v in zip(a,b)] 
#=> [('a', 1), ('b', 2), ('c', 3)] 

35. 如何按字母順序對字典排序?

無法對字典進行"排序"，因為字典沒有順序，但是可以返回已排序的元組列表，其中包含字典中的鍵和值。

d = {'c':3, 'd':4, 'b':2,'a':1}sorted(d.items()) 
#=> [('a', 1), ('b', 2), ('c', 3), ('d', 4)] 

36. 一個類如何從Python中的另一個類繼承?

在下面的示例中，Audi繼承自Car。繼承帶來了父類的實例方法。

class Car(): 
    def drive(self): 
        print('vroom')class Audi(Car): 
    passaudi = Audi() 
audi.drive() 

37. 模塊和包裝之間有什么區別?

模塊是可以一起導入的文件(或文件集合)。

importsklearn 

包是模塊的目錄。

from sklearnimport cross_validation 

因此，包是模塊，但并非所有模塊都是包。

38. 如何在Python中遞增和遞減整數?

可以使用+-和-=進行遞增和遞減。

value = 5value += 1 
print(value) 
#=> 6value -= 1 
value -= 1 
print(value) 
#=> 4 

39. 如何從字符串中刪除所有空格?

最簡單的方法是在空白處分割字符串，然后重新連接而沒有空格。

s = 'A string with white space'''.join(s.split()) 
#=> 'Astringwithwhitespace' 

40. 為什么要在迭代序列時使用enumerate()?

enumerate()允許在迭代序列時跟蹤索引。它比定義和遞增代表索引的整數更具Python感。

li = ['a','b','c','d','e']foridx,val in enumerate(li): 
    print(idx, val) 
#=> 0 a 
#=> 1 b 
#=> 2 c 
#=> 3 d 
#=> 4 e 

41. pass、continue和break之間有什么區別?

pass意味著什么都不做。之所以常使用它，是因為Python不允許在其沒有代碼的情況下創建類、函數或if語句。

在下面的示例中，如果i > 3 中沒有代碼，則會引發錯誤，因此使用pass。

a = [1,2,3,4,5]for i in a: 
    if i > 3: 
        pass 
    print(i) 
#=> 1 
#=> 2 
#=> 3 
#=> 4 
#=> 5 

continue 繼續到下一個元素，并暫停執行當前元素。因此對于i <3的值，永遠不會達到print(i)。

for i in a: 
    if i < 3: 
        continue 
    print(i) 
#=> 3 
#=> 4 
#=> 5 

break打破了循環，序列不再重復。因此，不會打印3以后的元素。

for i in a: 
    if i == 3: 
        break 
    print(i)    
#=> 1 
#=> 2 

42. 舉例說明三元運算符。

三元運算符是單行if / else語句。

句法看起來像a if condition else b.。

x = 5 
y = 10'greater' if x > 6 else 'less' 
#=> 'less''greater' if y > 6 else 'less' 
#=> 'greater' 

43. 檢查字符串是否僅包含數字。

可以使用isnumeric().

'123a'.isnumeric() 
#=> False'123'.isnumeric() 
#=> True 

44. 檢查字符串是否僅包含字母。

可以使用isalpha().

'123a'.isalpha() 
#=> False'a'.isalpha() 
#=> True 

45. 檢查字符串是否僅包含數字和字母。

您可以使用isalnum().

'123abc...'.isalnum() 
#=> False'123abc'.isalnum() 
#=> True 

46. 從字典返回鍵列表。

這可以通過將字典傳遞給python的list()構造函數list()來完成。

d = {'id':7, 'name':'Shiba','color':'brown', 'speed':'very slow'}list(d) 
#=> ['id', 'name', 'color', 'speed'] 

47. 如何對字符串進行大寫和小寫?

可以使用upper()和lower()字符串方法。

small_word = 'potatocake' 
big_word = 'FISHCAKE'small_word.upper() 
#=> 'POTATOCAKE'big_word.lower() 
#=> 'fishcake' 

48. 將以下for循環轉換為列表解析。

這個for循環。

a = [1,2,3,4,5]  
a2 = [] 
for i in a: 
     a2.append(i + 1)print(a2) 
#=> [2, 3, 4, 5, 6] 

成為：

a3 = [i+1 for i in a]print(a3) 
#=> [2, 3, 4, 5, 6] 

列表解析通常被認為更具Python感，卻仍易于閱讀。

 

 

 

圖源：unsplash

 

49. remove、del和pop有什么區別?

remove()刪除第一個匹配值。

li =['a','b','c','d']li.remove('b') 
li 
#=> ['a', 'c', 'd'] 

del按索引刪除元素。

li = ['a','b','c','d']del li[0] 
li 
#=> ['b', 'c', 'd'] 

pop()按索引刪除一個元素并返回該元素。

li = ['a','b','c','d']li.pop(2) 
#=> 'c'li 
#=> ['a', 'b', 'd'] 

50. 舉一個字典解析的例子。

在下面，將創建字典，以字母作為鍵，并以字母索引作為值。

# creating a list of letters 
import string 
list(string.ascii_lowercase) 
alphabet = list(string.ascii_lowercase)# list comprehension 
d = {val:idx for idx,val in enumerate(alphabet)} d 
#=> {'a': 0, 
#=> 'b': 1, 
#=> 'c': 2, 
#=> ... 
#=> 'x': 23, 
#=> 'y': 24, 
#=> 'z': 25} 

51. 如何在Python中執行異常處理?

Python提供了3個單詞來處理異常，請嘗試使用" try"、" except"和" finally"。

句法如下所示。

try: 
    # try to do this 
except: 
    # if try block fails then do this 
finally: 
    # always do this 

在下面的簡單示例中，try塊失敗，因為無法在字符串中添加整數。else塊設置val = 10，然后finally塊打印完成。

try: 
    val = 1 + 'A' 
except: 
    val = 10 
finally: 
    print('complete') 
   print(val) 
#=> complete 
#=> 10 

52. " func"和" func()"有什么區別?

這個問題是想考查是否了解所有函數也是python中的對象。

def func(): 
    print('Im a function') 
func 
#=> function __main__.func>func()    
#=> Im a function 

func表示函數的對象，可以將其分配給變量或傳遞給另一個函數。帶括號的func()調用該函數并返回其輸出。

53. 解釋reduce函數的工作原理

光是思考原理很難理解，需要上手幾次才能明白。

reduce接受一個函數和一個序列，然后對該序列進行迭代。在每次迭代中，當前元素和前一個元素的輸出都將傳遞給函數。最后，返回一個值。

from functools import reducedefadd_three(x,y): 
    return x + yli =[1,2,3,5]reduce(add_three, li) 
#=> 11 

返回11，它是1 + 2 + 3 + 5的總和。

 

[[325693]]

 

 

圖源：unsplash

 

此列表涵蓋大多數數據科學家或初級/中級python開發人員在面試中可能被問到的關python方面的問題。面試中會遇到什么問題永遠不會知道，最好的準備方法是積累大量編寫代碼的經驗。我們要做的是盡可能地準備充分。