53道Python面試問答題，幫你成為大數據工程師！

數據科學家和軟件工程師的Python問題

> Photo by Brooke Cagle on Unsplash

不久前，我開始擔任"數據科學家"的新角色，實際上是" Python工程師"。

如果我提前瞭解Python的線程生命週期而不是推薦系統，我會做得更好。

本著這種精神，這是我的python面試/工作準備問題和答案。 大多數數據科學家編寫了大量代碼，因此這對科學家和工程師均適用。

無論您是面試應聘者，準備應聘工作還是隻是精通Python，我都認為這份清單將是無價之寶。

問題是無序的。 讓我們開始。

1.列表和元組有什麼區別？

在我進行過的每次python /數據科學訪談中，都曾問過我這個問題。 像手背一樣知道答案。

· 列表是可變的。 創建後可以對其進行修改。

· 元組是不可變的。 一旦創建了元組，就不能對其進行更改

· 列表有順序。 它們是有序序列，通常是相同類型的對象。 即：按創建日期排序的所有用戶名，[" Seth"，" Ema"，" Eli"]

· 元組具有結構。 每個索引可能存在不同的數據類型。 即：內存中的數據庫記錄，（2，" Ema"，" 2020–04–16"）＃id，名稱，created_at

2.如何進行字符串插值？

在不導入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)))

3." is"和" =="有什麼區別？

在我的python生涯的早期，我以為它們是相同的……您好錯誤。 因此，為了記錄，檢查身份和==檢查相等性。

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

<code>
a
 = [
1
,
2
, 
3
]
b
 = a
c
 = [
1
,
2
,
3
]/<code>

檢查是否相等，並注意它們是否相等。

<code>
print
(a == b)
print
(a == c)
 
/<code>

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

<code>
print
(a 
is
 b)
print
(a 
is
 c)
 
/<code>

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

<code>
print
(id(a))
print
(id(b))
print
(id(c))
 
 
/<code>

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

4.什麼是裝飾器？

每次面試中我都被問到另一個問題。 它本身值得發佈，但是如果您可以逐步編寫自己的示例，那麼您已經準備好了。

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

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

編寫裝飾器函數。 這需要一個函數func作為參數。 它還定義了一個函數log_function_drawn，該函數調用func（）並執行一些代碼print（f'{func}被調用。'）。 然後返回定義的函數

<code>
def
 
logging
(func)
:
 
	
def
 
log_function_called
()
:
 
  	print(
f'
{func}
 called.'
) 
		func() 
		 
return
 log_function_called/<code>

讓我們編寫其他函數，我們最終將裝飾器添加到（但尚未）。

<code>
def
 
my_name
()
:
 
	print(
'chris'
)

def
 
friends_name
()
:
 
	print(
'naruto'
)

my_name()
friends_name()

 
/<code>

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

<code> 
def
 
my_name
()
:
 
	print(
'chris'
)

 
def
 
friends_name
()
: 
 
	print(
'naruto'
)

my_name()
friends_name()

 
 
/<code>

瞭解現在如何僅通過在其上面添加@logging就能輕鬆地將日誌添加到我們編寫的任何函數中。

5.解釋範圍功能

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個屬性，即"顏色"和"速度"。 然後創建一個實例並返回速度。

<code>
class
 
Car
 :  

	
def
 
__init__
(
self
, color, speed)
: 
  	
self
.color = color 
self
.speed = speed

car = Car(
'red'
,
'100mph'
)
car.speed
/<code>

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

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

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

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

我們將說明一個虛構的CoffeeShop類的區別。

<code>
class
 
CoffeeShop
:
 
	specialty = 
'espresso'
	
 
def
 
__init__
(self, coffee_price)
:
 
  	self.coffee_price = coffee_price 
	
	 
  
def
 
make_coffee
(self)
:
 
  	print(
f'Making 
{self.specialty}
 for $
{self.coffee_price}
'
) 
	
	 
 
  	print(
'Its sunny'
) 
	
	 
 
	
def
 
change_specialty
(cls, specialty)
:
 
  	cls.specialty = specialty 
		print(
f'Specialty changed to 
{specialty}
'
)/<code>

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

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

<code>
coffee_shop
 = CoffeeShop( 
'5'
)
coffee_shop.make_coffee()
/<code>

現在調用靜態方法。 靜態方法無法修改類或實例狀態，因此通常用於實用程序功能，例如，添加兩個數字。 我們用我們的天氣檢查天氣。 大！

<code>
coffee_shop
.check_weather()
/<code>

現在，我們使用class方法來修改咖啡店的特色菜，然後再修改make_coffee。

<code>coffee_shop.change_specialty(
'drip coffee'
)
 
coffee_shop.make_coffee()
/<code>

請注意，make_coffee以前是用來製作意式濃縮咖啡的，但現在卻可以製作滴濾咖啡！

8." func"和" func（）"有什麼區別？

這個問題的目的是看看您是否瞭解所有函數也是python中的對象。

<code>def 
func
()
:
 
	
print
(
'Im a function'
) 

func
 

#=> function __main__
.
func
>


func
()
 
#=> Im a function/<code>

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

9.說明Map功能的工作方式

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

<code>
def
 
add_three
(x)
:
 
	
return
 x + 
3

li = [
1
,
2
,
3
]

[i 
for
 i 
in
 map(add_three, li)] /<code>

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

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

將頭纏起來直到您幾次使用都很難。

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

<code>
from
 functools 
import
 reduce
def
 
add_three
(x,y)
:
 
	
return
 x + y

li = [
1
,
2
,
3
,
5
]
reduce(add_three, li)
/<code>

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

11.解釋filter功能如何工作

過濾器按字面意思執行。 它按順序過濾元素。

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

<code>
def
 
add_three
(x)
:
 
	
if
 x % 
2
 == 
0
: 
  	
return
 
True
 
	
else
: 
return
 
False

li = [
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
]

[i 
for
 i  
in
 filter(add_three, li)]
/<code>

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

12. python是按引用調用還是按值調用？

如果您對這個問題進行了搜索並閱讀了前幾頁，請準備好深入瞭解語義。 您最好僅瞭解其工作原理。

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

<code>name = 
'chr'
def
 
add_chars
(s)
:
 
	s += 
'is'
 print(s) 

add_chars(name) 
print(name)
 
/<code>

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

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

add_element(li) 
print(li)
 
/<code>

13.如何撤消清單？

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

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

print
(li)
#=> [
'a'
, 
'b'
, 
'c'
]
#=> [
'c'
, 
'b'
, 
'a'
]/<code>

14.字符串乘法如何工作？

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

<code>
'cat'
 * 3
/<code>

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

15.列表乘法如何工作？

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

<code>[ ] * 
2
/<code>

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

16.在類上"self"指的是什麼？

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

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

<code>
class
 
Shirt
: 

	
def
 
__init__
( 
self
, color)
: 
  	
self
.color = color 

s = Shirt(
'yellow'
)
s.color
/<code>

17.如何連接python中的列表？

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

<code>
a
 = 
[1,2]
b
 = 
[3,4,5]
a
 
+ b
/<code>

18.淺拷貝和深拷貝之間有什麼區別？

我們將在可變對象（列表）的上下文中進行討論。 對於不可變的物體，淺與深並不重要。

我們將介紹3種情況。

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

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

ii）創建原始文檔的淺表副本。 我們可以使用list（）構造函數來做到這一點。 淺表副本會創建一個新對象，但會使用對原始對象的引用來填充它。 因此，將新對象添加到原始集合li3中不會傳播到li4，但是修改li3中的一個對象將傳播到li4。

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

li3[
0
][
0
] = [
'X'
]
print
(li4)
#=> 
[[['X']]
, [
'b'
], [
'c'
]]/<code>

iii）創建一個深層副本。 這是通過copy.deepcopy（）完成的。 現在，這兩個對象是完全獨立的，並且對其中任何一個所做的更改不會對另一個對象產生影響。

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

19.列表和數組有什麼區別？

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

· 列表存在於python的標準庫中。 數組由Numpy定義。

· 列表可以在每個索引處填充不同類型的數據。 數組需要齊次元素。

· 列表上的算術從列表中添加或刪除元素。 每個線性代數的數組函數的算術運算。

· 陣列還使用更少的內存，並具有更多的功能。

我寫了另一篇有關數組的文章。

20.如何連接兩個數組？

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

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

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

21.您喜歡Python的什麼？

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

我將其與Ruby相比，後者通常有很多方法來做某事，而沒有指南是首選。

22.您最喜歡使用Python的哪個庫？

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

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

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

可變表示狀態可以在創建後進行修改。 示例是列表，字典和集合。

24.您如何將數字四捨五入到小數點後三位？

使用round（value，decimal_places）函數。

<code>a = 5.12345
round(a,3)
/<code>

25.您如何分割列表？

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

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

26.什麼是pickle？

酸洗是在Python中序列化和反序列化對象的首選方法。

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

<code>
import
 pickleobj = [ {
'id'
:
1
, 
'name'
:
'Stuffy'
}, {
'id'
:
2
, 
'name'
: 
'Fluffy'
}]

with 
open
(
'file.p'
, 
'wb'
) 
as
 f: 
	pickle.dump(obj, f)

with 
open 
(
'file.p'
, 
'rb'
) 
as
 f: 
	loaded_obj = pickle.load(f)

print(loaded_obj)
#=> [{
'id'
: 
1
, 
'name'
: 
'Stuffy'
}, {
'id'
: 
2
, 
'name'
: 
'Fluffy'
}]/<code>

27.字典和JSON有什麼區別？

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

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

28.您在Python中使用了哪些ORM？

ORM（對象關係映射）將數據模型（通常在應用程序中）映射到數據庫表，並簡化了數據庫事務。

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

29. any（）和all（）如何工作？

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

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

<code>a = [
False
, 
False
, 
False
]
b = [
True
, 
False
, 
False
]
c = [
True
, 
True
, 
True
]
print
( any(a) )
print
( any(b) )
print
( any(c) )
 
 
 

print
( all(a) )
print
( all(b) )
print
( all(c) )/<code>

30.字典或列表的查找速度更快嗎？

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

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

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

31.模塊和包裝之間有什麼區別？

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

<code>
import
 sklearn/<code>

包是模塊的目錄。

<code>
from
 sklearn 
import
 cross_validation/<code>

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

32.如何在Python中遞增和遞減整數？

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

<code>
value
 = 
5
value
 += 
1
print(
value
)
 
 
value
 -= 
1
value
 -= 
1
print(
value
)
/<code>

33.如何返回整數的二進制？

使用bin（）函數。

<code>bin(5)
=> 
'0b101'
/<code>

34.如何從列表中刪除重複的元素？

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

<code>a = [1,1,1,2,3]
a = list(
set
(a))
print
(a)
/<code>

35.如何檢查列表中是否存在值？

用於。

<code>
'a'
 
in
 [
'a'
,
'b' 
,
'c'
]
 
'a'
 
in
 [1,2,3]
/<code>

36. append和extend有什麼區別？

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

<code>
a
 = 
b
 = 
a
.append(6)
print
(a)
 
b
.extend([4,5])
print
(b)
/<code>

37.如何取整數的絕對值？

這可以通過abs（）函數來完成。

<code>
abs
(
2
)
 
abs
(-
2
)
/<code>

38.如何將兩個列表組合成一個元組列表？

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

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

39.如何按字母順序對字典排序？

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

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

40.一個類如何從Python中的另一個類繼承？

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

<code>
class
 
Car
()
:
 
	
def
 
drive
(self)
:
 
  	print(
'vroom'
)

class
 
Audi
(Car)
:
 
	 
pass
  
audi = Audi()
audi.drive()/<code>

41.如何從字符串中刪除所有空格？

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

<code>s = 
'A string with white space'
''
.
join
(s.split())
/<code>

42.為什麼要在序列上迭代時使用enumerate（）？

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

<code>li = [
'a'
,
'b'
,
'c'
,
'd'
,
'e'
]
for
 idx,val 
in
 enumerate(li): 
	
print
(idx, val)
 
 
 
 
/<code>

43.pass，continue和break之間有什麼區別？

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

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

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

 
 
 
 
/<code>

繼續繼續到下一個元素，並暫停當前元素的執行。 因此對於i <3的值，永遠不會達到print（i）。

<code>
for
 
i in a: 
	
if
 
i < 3: 
  	
continue
 

	
print(i)
 
 
/<code> 

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

<code>
for
 
i in a: 
	
if
 
i == 3: 
  	
break
 

	  

 
/<code>

44.將以下for循環轉換為列表推導。

這個for循環。

<code>
a
 = 
[1,2,3,4,5] 
a2
 = 
[]
for
 
i in a: 
	  
+ 1)
	
print(a2)
/<code>

成為。

<code>
a3
 = 
 
print
(a3)

/<code>

列表理解通常被認為是更具Python性的，但仍易於閱讀。

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

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

語法看起來像一個if條件else b。

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

'greater'
 
if
 y > 6 
else
 
'less'
/<code>

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

您可以使用isnumeric（）。

<code>
'123a'
.isnumeric()
 

'123'
.isnumeric()
/<code>

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

您可以使用isalpha（）。

<code>
'123a'
.isalpha()
 

'a'
.isalpha()
/<code>

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

您可以使用isalnum（）。

<code>
'123abc...'
.isalnum()
 

'123abc'
.isalnum()
/<code>

49.從字典返回鍵列表。

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

<code>d = {
'id'
:
7
, 
'name'
:
'Shiba'
, 
'color'
:
'brown'
, 
'speed'
:
'very slow'
}

list(d)
#=> [
'id'
, 
'name'
, 
'color'
, 
'speed' 
]/<code>

50.如何對字符串進行大寫和小寫？

您可以使用upper（）和lower（）字符串方法。

<code>small_word = 
'potatocake'
big_word = 
'FISHCAKE'

small_word.
upper
()
#=> 
'POTATOCAKE'
big_word.
lower
()
#=> 
'fishcake'
/<code>

51. remove，del和pop有什麼區別？

remove（）刪除第一個匹配值。

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

li
#=> [
'a'
, 
'c'
, 
'd'
]/<code>

del按索引刪除元素。

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

li
#=> [
'b'
, 
'c'
, 
'd'
]/<code>

pop（）按索引刪除一個元素並返回該元素。

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

li
#=> [
'a'
, 
'b'
, 
'd'
]/<code>

52.舉一個字典理解的例子。

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

<code>
 creating a list of letters
import string
list(string.ascii_lowercase)
alphabet = list(string.ascii_lowercase)
 list comprehensiond = {val:idx 
for
 idx,val 
in
 enumerate(alphabet)} 


d
=> {
'a'
: 0,

=> 
'b'
: 1,

=> 
'c'
: 2,

=> ...
=> 
'x'
: 23,

=> 
'y'
: 24,

=> 
'z'
: 25}
/<code>

53.如何在Python中執行異常處理？

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

語法如下所示。

<code>
try
: 
# 
try
 to  
do
 
this
except: 
# 
if
 
try
 block fails then 
do
 
this
finally
: 
# always 
do
 
this
/<code>

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

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

print(val)

 
/<code>

結論

您永遠不會知道面試中會遇到什麼問題，最好的準備方法是擁有大量編寫代碼的經驗。

就是說，此列表應涵蓋您需要以python方式查詢數據科學家或初級/中級python開發人員角色的所有內容。

我希望這對您像寫對我一樣對您有幫助。

我錯過了什麼大問題嗎？

(本文翻譯自Chris的文章《53 Python Interview Questions and Answers》，參考：https://towardsdatascience.com/53-python-interview-questions-and-answers-91fa311eec3f)