日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
53道Python面試問答題，幫你成為大數(shù)據(jù)工程師！

 數(shù)據(jù)科學(xué)家和軟件工程師的Python問題

成都創(chuàng)新互聯(lián)堅持“要么做到，要么別承諾”的工作理念，服務(wù)領(lǐng)域包括：網(wǎng)站建設(shè)、成都網(wǎng)站制作、企業(yè)官網(wǎng)、英文網(wǎng)站、手機端網(wǎng)站、網(wǎng)站推廣等服務(wù)，滿足客戶于互聯(lián)網(wǎng)時代的夏津網(wǎng)站設(shè)計、移動媒體設(shè)計的需求，幫助企業(yè)找到有效的互聯(lián)網(wǎng)解決方案。努力成為您成熟可靠的網(wǎng)絡(luò)建設(shè)合作伙伴！

不久前，我開始擔(dān)任"數(shù)據(jù)科學(xué)家"的新角色，實際上是" Python工程師"。

如果我提前了解Python的線程生命周期而不是推薦系統(tǒng)，我會做得更好。

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

無論您是面試應(yīng)聘者，準(zhǔn)備應(yīng)聘工作還是只是精通Python，我都認(rèn)為這份清單將是無價之寶。

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

1.列表和元組有什么區(qū)別?

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

  • 列表是可變的。 創(chuàng)建后可以對其進行修改。
  • 元組是不可變的。 一旦創(chuàng)建了元組，就不能對其進行更改
  • 列表有順序。 它們是有序序列，通常是相同類型的對象。 即：按創(chuàng)建日期排序的所有用戶名，[" Seth"，" Ema"，" Eli"]
  • 元組具有結(jié)構(gòu)。 每個索引可能存在不同的數(shù)據(jù)類型。 即：內(nèi)存中的數(shù)據(jù)庫記錄，(2，" Ema"，" 2020–04–16")#id，名稱，created_at

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

在不導(dǎo)入Template類的情況下，有3種插值字符串的方法。

 
 
    
  
  
  1. name = 'Chris'
    2. 
  
  
  2. 
  
  
  3. # 1. f strings
    4. 
  
  
  4. 
  
  
  5. print(f'Hello {name}')
    6. 
  
  
  6. 
  
  
  7. # 2. % operator
    8. 
  
  
  8. 
  
  
  9. print('Hey %s %s' % (name, name))
    10. 
  
  
  10. 
  
  
  11. # 3. format
    12. 
  
  
  12. 
  
  
  13. print( "My name is {}".format((name)))
    14.

3." is"和" =="有什么區(qū)別?

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

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

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

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

 
 
    
  
  
  1. print(a == b)
    2. 
  
  
  2. print(a == c)
    3. 
  
  
  3. #=> True
    4. 
  
  
  4. #=> True
    5.

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

 
 
    
  
  
  1. print(a is b)
    2. 
  
  
  2. print(a is c)
    3. 
  
  
  3. #=> True
    4. 
  
  
  4. #=> False
    5.

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

 
 
    
  
  
  1. print(id(a))
    2. 
  
  
  2. print(id(b))
    3. 
  
  
  3. print(id(c))
    4. 
  
  
  4. #=> 4369567560
    5. 
  
  
  5. #=> 4369567560
    6. 
  
  
  6. #=> 4369567624
    7.

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

4.什么是裝飾器?

每次面試中我都被問到另一個問題。 它本身值得發(fā)布，但是如果您可以逐步編寫自己的示例，那么您已經(jīng)準(zhǔn)備好了。

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

我們將編寫一個裝飾器，該裝飾器會在調(diào)用另一個函數(shù)時記錄日志。

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

 
 
    
  
  
  1. def logging(func): 
    2. 
  
  
  2.     def log_function_called(): 
    3. 
  
  
  3.     print(f'{func} called.') 
    4. 
  
  
  4.         func() 
    5. 
  
  
  5.         return log_function_called
    6.

讓我們編寫其他函數(shù)，我們最終將裝飾器添加到(但尚未)。

 
 
    
  
  
  1. def my_name(): 
    2. 
  
  
  2.     print('chris')
    3. 
  
  
  3. 
  
  
  4. def friends_name(): 
    5. 
  
  
  5.     print('naruto')
    6. 
  
  
  6. 
  
  
  7. my_name()
    8. 
  
  
  8. friends_name()
    9. 
  
  
  9. 
  
  
  10. #=> chris
    11. 
  
  
  11. #=> naruto
    12.

現(xiàn)在將裝飾器添加到兩者。

 
 
    
  
  
  1. @logging
    2. 
  
  
  2. def my_name(): 
    3. 
  
  
  3.     print('chris')
    4. 
  
  
  4. 
  
  
  5. @logging
    6. 
  
  
  6. def friends_name(): 
    7. 
  
  
  7.     print('naruto')
    8. 
  
  
  8. 
  
  
  9. my_name()
    10. 
  
  
  10. friends_name()
    11. 
  
  
  11. 
  
  
  12. #=>  called.
    13. 
  
  
  13. #=> chris#=>  called.
    14. 
  
  
  14. #=> naruto
    15.

了解現(xiàn)在如何僅通過在其上面添加@logging就能輕松地將日志添加到我們編寫的任何函數(shù)中。

5.解釋范圍功能

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

該函數(shù)接受1到3個參數(shù)。 請注意，我將每種用法都包裝在列表推導(dǎo)中，以便我們看到生成的值。

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

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

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

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

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

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

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

 
 
    
  
  
  1. class Car : 
    2. 
  
  
  2.     def __init__(self, color, speed): 
    3. 
  
  
  3.     self.color = color self.speed = speed
    4. 
  
  
  4. 
  
  
  5. car = Car('red','100mph')
    6. 
  
  
  6. car.speed
    7. 
  
  
  7. #=> '100mph'
    8.

7. python中的實例，靜態(tài)和類方法之間有什么區(qū)別?

實例方法：接受self參數(shù)并與類的特定實例相關(guān)。

靜態(tài)方法：使用@staticmethod裝飾器，與特定實例無關(guān)，并且是獨立的(請勿修改類或?qū)嵗龑傩?

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

我們將說明一個虛構(gòu)的CoffeeShop類的區(qū)別。

 
 
    
  
  
  1. class CoffeeShop: 
    2. 
  
  
  2.     specialty = 'espresso'
    3. 
  
  
  3.     def __init__(self, coffee_price): 
    4. 
  
  
  4.     self.coffee_price = coffee_price 
    5. 
  
  
  5.     
    6. 
  
  
  6.     # instance method 
    7. 
  
  
  7.   def make_coffee(self): 
    8. 
  
  
  8.     print(f'Making {self.specialty} for ${self.coffee_price}') 
    9. 
  
  
  9.     
    10. 
  
  
  10.     # static method   
    11. 
  
  
  11.   @staticmethod def check_weather(): 
    12. 
  
  
  12.     print('Its sunny') 
    13. 
  
  
  13.     
    14. 
  
  
  14.     # class method 
    15. 
  
  
  15.   @classmethod 
    16. 
  
  
  16.     def change_specialty(cls, specialty): 
    17. 
  
  
  17.     cls.specialty = specialty 
    18. 
  
  
  18.         print(f'Specialty changed to {specialty}')
    19.

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

讓我們以coffee_price為5初始化咖啡店的實例。然后調(diào)用實例方法make_coffee。

 
 
    
  
  
  1. coffee_shop = CoffeeShop('5')
    2. 
  
  
  2. coffee_shop.make_coffee()
    3. 
  
  
  3. #=> Making espresso for $5
    4.

現(xiàn)在調(diào)用靜態(tài)方法。 靜態(tài)方法無法修改類或?qū)嵗隣顟B(tài)，因此通常用于實用程序功能，例如，添加兩個數(shù)字。 我們用我們的天氣檢查天氣。 大!

 
 
    
  
  
  1. coffee_shop.check_weather()
    2. 
  
  
  2. #=> Its sunny
    3.

現(xiàn)在，我們使用class方法來修改咖啡店的特色菜，然后再修改make_coffee。

 
 
    
  
  
  1. coffee_shop.change_specialty('drip coffee')
    2. 
  
  
  2. #=> Specialty changed to drip coffee
    3. 
  
  
  3. coffee_shop.make_coffee()
    4. 
  
  
  4. #=> Making drip coffee for $5
    5.

請注意，make_coffee以前是用來制作意式濃縮咖啡的，但現(xiàn)在卻可以制作滴濾咖啡!

8." func"和" func()"有什么區(qū)別?

這個問題的目的是看看您是否了解所有函數(shù)也是python中的對象。

 
 
    
  
  
  1. def func(): 
    2. 
  
  
  2.     print('Im a function') 
    3. 
  
  
  3. 
  
  
  4. func
    5. 
  
  
  5. #=> function __main__.func>
    6. 
  
  
  6. 
  
  
  7. func() 
    8. 
  
  
  8. #=> Im a function
    9.

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

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

map通過將函數(shù)應(yīng)用于序列中的每個元素，返回由返回值組成的列表。

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

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

10.解釋reduce函數(shù)的工作原理

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

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

 
 
    
  
  
  1. from functools import reduce
    2. 
  
  
  2. def add_three(x,y): 
    3. 
  
  
  3.     return x + y
    4. 
  
  
  4. 
  
  
  5. li = [1,2,3,5]
    6. 
  
  
  6. reduce(add_three, li)
    7. 
  
  
  7. #=> 11
    8.

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

11.解釋filter功能如何工作

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

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

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

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

12. python是按引用調(diào)用還是按值調(diào)用?

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

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

 
 
    
  
  
  1. name = 'chr'
    2. 
  
  
  2. def add_chars(s): 
    3. 
  
  
  3.     s += 'is' print(s) 
    4. 
  
  
  4. 
  
  
  5. add_chars(name) 
    6. 
  
  
  6. print(name)
    7. 
  
  
  7. #=> chris
    8. 
  
  
  8. #=> chr
    9.

可變對象(如list)是按引用調(diào)用的。 注意如何在函數(shù)外部定義的列表在函數(shù)內(nèi)部被修改。 函數(shù)中的參數(shù)指向內(nèi)存中存儲li值的原始塊。

 
 
    
  
  
  1. li = [1,2]
    2. 
  
  
  2. def add_element(seq): 
    3. 
  
  
  3.     seq.append(3) 
    4. 
  
  
  4.     print(seq) 
    5. 
  
  
  5. 
  
  
  6. add_element(li) 
    7. 
  
  
  7. print(li)
    8. 
  
  
  8. #=> [1, 2, 3]
    9. 
  
  
  9. #=> [1, 2, 3]
    10.

13.如何撤消清單?

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

 
 
    
  
  
  1. li = ['a','b','c']
    2. 
  
  
  2. print(li)
    3. 
  
  
  3. li.reverse()
    4. 
  
  
  4. 
  
  
  5. print(li)
    6. 
  
  
  6. #=> ['a', 'b', 'c']
    7. 
  
  
  7. #=> ['c', 'b', 'a']
    8.

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

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

 
 
    
  
  
  1. 'cat' * 3
    2. 
  
  
  2. #=> 'catcatcat'
    3.

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

15.列表乘法如何工作?

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

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

輸出包含重復(fù)兩次的[1,2,3]內(nèi)容的列表。

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

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

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

 
 
    
  
  
  1. class Shirt: 
    2. 
  
  
  2.     def __init__(self, color): 
    3. 
  
  
  3.     self.color = color 
    4. 
  
  
  4. 
  
  
  5. s = Shirt('yellow')
    6. 
  
  
  6. s.color
    7. 
  
  
  7. #=> 'yellow'
    8.

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

將2個列表加在一起將它們串聯(lián)在一起。 請注意，數(shù)組的功能不同。

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

18.淺拷貝和深拷貝之間有什么區(qū)別?

我們將在可變對象(列表)的上下文中進行討論。 對于不可變的物體，淺與深并不重要。

我們將介紹3種情況。

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

 
 
    
  
  
  1. li1 = [['a'],['b'],['c']]
    2. 
  
  
  2. li2 = li1
    3. 
  
  
  3. li1.append(['d'])
    4. 
  
  
  4. print(li2)
    5. 
  
  
  5. #=> [['a'], ['b'], ['c'], ['d']]
    6.

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

 
 
    
  
  
  1. li3 = [['a'],['b'],['c']]
    2. 
  
  
  2. li4 = list(li3)
    3. 
  
  
  3. li3.append([4])
    4. 
  
  
  4. print(li4)
    5. 
  
  
  5. #=> [['a'], ['b'], ['c']]
    6. 
  
  
  6. 
  
  
  7. li3[0][0] = ['X']
    8. 
  
  
  8. print(li4)
    9. 
  
  
  9. #=> [[['X']], ['b'], ['c']]
    10.

iii)創(chuàng)建一個深層副本。 這是通過copy.deepcopy()完成的。 現(xiàn)在，這兩個對象是完全獨立的，并且對其中任何一個所做的更改不會對另一個對象產(chǎn)生影響。

 
 
    
  
  
  1. import copy
    2. 
  
  
  2. li5 = [['a'],['b'],['c']]
    3. 
  
  
  3. li6 = copy.deepcopy(li5)
    4. 
  
  
  4. li5.append([4])
    5. 
  
  
  5. li5[0][0] = ['X']
    6. 
  
  
  6. print(li6)
    7. 
  
  
  7. #=> [['a'], ['b'], ['c']]
    8.

19.列表和數(shù)組有什么區(qū)別?

注意：Python的標(biāo)準(zhǔn)庫有一個數(shù)組對象，但在這里我專門指的是常用的Numpy數(shù)組。

  • 列表存在于python的標(biāo)準(zhǔn)庫中。 數(shù)組由Numpy定義。
  • 列表可以在每個索引處填充不同類型的數(shù)據(jù)。 數(shù)組需要齊次元素。
  • 列表上的算術(shù)從列表中添加或刪除元素。 每個線性代數(shù)的數(shù)組函數(shù)的算術(shù)運算。
  • 陣列還使用更少的內(nèi)存，并具有更多的功能。

我寫了另一篇有關(guān)數(shù)組的文章。

20.如何連接兩個數(shù)組?

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

我們需要使用Numpy的連接函數(shù)來實現(xiàn)。

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

21.您喜歡Python的什么?

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

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

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

當(dāng)處理大量數(shù)據(jù)時，沒有什么比熊貓那么有用了，這使得操作和可視化數(shù)據(jù)變得輕而易舉。

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

不可變表示創(chuàng)建后無法修改狀態(tài)。 例如：int，float，bool，string和tuple。

可變表示狀態(tài)可以在創(chuàng)建后進行修改。 示例是列表，字典和集合。

24.您如何將數(shù)字四舍五入到小數(shù)點后三位?

使用round(value，decimal_places)函數(shù)。

 
 
    
  
  
  1. a = 5.12345
    2. 
  
  
  2. round(a,3)
    3. 
  
  
  3. #=> 5.123
    4.

25.您如何分割列表?

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

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

26.什么是pickle?

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

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

 
 
    
  
  
  1. import pickleobj = [ {'id':1, 'name':'Stuffy'}, {'id':2, 'name': 'Fluffy'}]
    2. 
  
  
  2. 
  
  
  3. with open('file.p', 'wb') as f: 
    4. 
  
  
  4.     pickle.dump(obj, f)
    5. 
  
  
  5. 
  
  
  6. with open('file.p', 'rb') as f: 
    7. 
  
  
  7.     loaded_obj = pickle.load(f)
    8. 
  
  
  8. 
  
  
  9. print(loaded_obj)
    10. 
  
  
  10. #=> [{'id': 1, 'name': 'Stuffy'}, {'id': 2, 'name': 'Fluffy'}]
    11.

27.字典和JSON有什么區(qū)別?

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

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

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

ORM(對象關(guān)系映射)將數(shù)據(jù)模型(通常在應(yīng)用程序中)映射到數(shù)據(jù)庫表，并簡化了數(shù)據(jù)庫事務(wù)。

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

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

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

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

 
 
    
  
  
  1. a = [False, False, False]
    2. 
  
  
  2. b = [True, False, False]
    3. 
  
  
  3. c = [True, True, True]
    4. 
  
  
  4. print( any(a) )
    5. 
  
  
  5. print( any(b) )
    6. 
  
  
  6. print( any(c) )
    7. 
  
  
  7. #=> False
    8. 
  
  
  8. #=> True
    9. 
  
  
  9. #=> True
    10. 
  
  
  10. 
  
  
  11. print( all(a) )
    12. 
  
  
  12. print( all(b) )print( all(c) )#=> False#=> False#=> True
    13.

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

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

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

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

31.模塊和包裝之間有什么區(qū)別?

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

 
 
    
  
  
  1. import sklearn
    2.

包是模塊的目錄。

 
 
    
  
  
  1. from sklearn import cross_validation
    2.

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

32.如何在Python中遞增和遞減整數(shù)?

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

 
 
    
  
  
  1. value = 5
    2. 
  
  
  2. value += 1
    3. 
  
  
  3. print(value)
    4. 
  
  
  4. #=> 6
    5. 
  
  
  5. value -= 1
    6. 
  
  
  6. value -= 1
    7. 
  
  
  7. print(value)
    8. 
  
  
  8. #=> 4
    9.

33.如何返回整數(shù)的二進制?

使用bin()函數(shù)。

 
 
    
  
  
  1. bin(5)
    2. 
  
  
  2. #=> '0b101'
    3.

34.如何從列表中刪除重復(fù)的元素?

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

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

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

用于。

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

36. append和extend有什么區(qū)別?

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

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

37.如何取整數(shù)的絕對值?

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

 
 
    
  
  
  1. abs(2)
    2. 
  
  
  2. #=> 2
    3. 
  
  
  3. abs(-2)
    4. 
  
  
  4. #=> 2
    5.

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

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

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

39.如何按字母順序?qū)ψ值渑判?

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

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

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

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

 
 
    
  
  
  1. class Car(): 
    2. 
  
  
  2.     def drive(self): 
    3. 
  
  
  3.     print('vroom')
    4. 
  
  
  4. 
  
  
  5. class Audi(Car): 
    6. 
  
  
  6.     pass
    7. 
  
  
  7.   
    8. 
  
  
  8. audi = Audi()
    9. 
  
  
  9. audi.drive()
    10.

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

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

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

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

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

 
 
    
  
  
  1. li = ['a','b','c','d','e']
    2. 
  
  
  2. for idx,val in enumerate(li): 
    3. 
  
  
  3.     print(idx, val)
    4. 
  
  
  4. #=> 0 a
    5. 
  
  
  5. #=> 1 b
    6. 
  
  
  6. #=> 2 c
    7. 
  
  
  7. #=> 3 d
    8. 
  
  
  8. #=> 4 e
    9.

43.pass，continue和break之間有什么區(qū)別?

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

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

 
 
    
  
  
  1. a = [1,2,3,4,5]
    2. 
  
  
  2. for i in a: 
    3. 
  
  
  3.     if i > 3
    4. 
  
  
  4.     : pass 
    5. 
  
  
  5.   print(i)
    6. 
  
  
  6. 
  
  
  7. #=> 1
    8. 
  
  
  8. #=> 2
    9. 
  
  
  9. #=> 3
    10. 
  
  
  10. #=> 4
    11. 
  
  
  11. #=> 5
    12.

繼續(xù)繼續(xù)到下一個元素，并暫停當(dāng)前元素的執(zhí)行。 因此對于i <3的值，永遠(yuǎn)不會達(dá)到print(i)。

 
 
    
  
  
  1. for i in a: 
    2. 
  
  
  2.     if i < 3: 
    3. 
  
  
  3.     continue 
    4. 
  
  
  4.     print(i)
    5. 
  
  
  5. 
  
  
  6. #=> 3
    7. 
  
  
  7. #=> 4
    8. 
  
  
  8. #=> 5
    9.

break打破了循環(huán)，序列不再重復(fù)。 因此，不會打印3以后的元素。

 
 
    
  
  
  1. for i in a: 
    2. 
  
  
  2.     if i == 3: 
    3. 
  
  
  3.     break 
    4. 
  
  
  4.     print(i) 
    5. 
  
  
  5. 
  
  
  6. #=> 1
    7. 
  
  
  7. #=> 2
    8.

44.將以下for循環(huán)轉(zhuǎn)換為列表推導(dǎo)。

這個for循環(huán)。

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

成為。

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

列表理解通常被認(rèn)為是更具Python性的，但仍易于閱讀。

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

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

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

 
 
    
  
  
  1. x = 5
    2. 
  
  
  2. y = 10
    3. 
  
  
  3. 'greater'  if x > 6 else 'less'
    4. 
  
  
  4. #=> 'less'
    5. 
  
  
  5. 
  
  
  6. 'greater' if y > 6 else 'less'
    7. 
  
  
  7. #=> 'greater'
    8.

46.檢查字符串是否僅包含數(shù)字。

您可以使用isnumeric()。

 
 
    
  
  
  1. '123a'.isnumeric()
    2. 
  
  
  2. #=> False
    3. 
  
  
  3. 
  
  
  4. '123'.isnumeric()
    5. 
  
  
  5. #=> True
    6.

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

您可以使用isalpha()。

 
 
    
  
  
  1. '123a'.isalpha()
    2. 
  
  
  2. #=> False
    3. 
  
  
  3. 
  
  
  4. 'a'.isalpha()
    5. 
  
  
  5. #=> True
    6.

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

您可以使用isalnum()。

 
 
    
  
  
  1. '123abc...'.isalnum()
    2. 
  
  
  2. #=> False
    3. 
  
  
  3. 
  
  
  4. '123abc'.isalnum()
    5. 
  
  
  5. #=> True
    6.

49.從字典返回鍵列表。

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

 
 
    
  
  
  1. d = {'id':7, 'name':'Shiba', 'color':'brown', 'speed':'very slow'}
    2. 
  
  
  2. 
  
  
  3. list(d)
    4. 
  
  
  4. #=> ['id', 'name', 'color', 'speed']
    5.

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

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

 
 
    
  
  
  1. small_word = 'potatocake'
    2. 
  
  
  2. big_word = 'FISHCAKE'
    3. 
  
  
  3. 
  
  
  4. small_word.upper()
    5. 
  
  
  5. #=> 'POTATOCAKE'
    6. 
  
  
  6. big_word.lower()
    7. 
  
  
  7. #=> 'fishcake'
    8.

51. remove，del和pop有什么區(qū)別?

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

 
 
    
  
  
  1. li = ['a','b','c','d']
    2. 
  
  
  2. li.remove('b')
    3. 
  
  
  3. 
  
  
  4. li
    5. 
  
  
  5. #=> ['a', 'c', 'd']
    6.

del按索引刪除元素。

 
 
    
  
  
  1. li = ['a','b','c','d']
    2. 
  
  
  2. del li[0]
    3. 
  
  
  3. 
  
  
  4. li
    5. 
  
  
  5. #=> ['b', 'c', 'd']
    6.

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

 
 
    
  
  
  1. li = ['a','b','c','d']
    2. 
  
  
  2. li.pop(2)
    3. 
  
  
  3. #=> 'c'
    4. 
  
  
  4. 
  
  
  5. li
    6. 
  
  
  6. #=> ['a', 'b', 'd']
    7.

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

在下面，我們將創(chuàng)建字典，以字母作為鍵，并以字母索引作為值。

 
 
    
  
  
  1. # creating a list of letters
    2. 
  
  
  2. import string
    3. 
  
  
  3. list(string.ascii_lowercase)
    4. 
  
  
  4. alphabet = list(string.ascii_lowercase)
    5. 
  
  
  5. # list comprehensiond = {val:idx for idx,val in enumerate(alphabet)} 
    6. 
  
  
  6. 
  
  
  7. d
    8. 
  
  
  8. #=> {'a': 0,
    9. 
  
  
  9. #=> 'b': 1,
    10. 
  
  
  10. #=> 'c': 2,
    11. 
  
  
  11. #=> ...
    12. 
  
  
  12. #=> 'x': 23,
    13. 
  
  
  13. #=> 'y': 24,
    14. 
  
  
  14. #=> 'z': 25}
    15.

53.如何在Python中執(zhí)行異常處理?

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

語法如下所示。

 
 
    
  
  
  1. try: 
    2. 
  
  
  2. # try to do this
    3. 
  
  
  3. except: 
    4. 
  
  
  4. # if try block fails then do this
    5. 
  
  
  5. finally: 
    6. 
  
  
  6. # always do this
    7.

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

 
 
    
  
  
  1. try: 
    2. 
  
  
  2.     val = 1 + 'A'
    3. 
  
  
  3. except: 
    4. 
  
  
  4.     val = 10
    5. 
  
  
  5. finally: 
    6. 
  
  
  6.     print('complete') 
    7. 
  
  
  7. 
  
  
  8. print(val)
    9. 
  
  
  9. 
  
  
  10. #=> complete
    11. 
  
  
  11. #=> 10
    12.

結(jié)論

您永遠(yuǎn)不會知道面試中會遇到什么問題，最好的準(zhǔn)備方法是擁有大量編寫代碼的經(jīng)驗。

就是說，此列表應(yīng)涵蓋您需要以python方式查詢數(shù)據(jù)科學(xué)家或初級/中級python開發(fā)人員角色的所有內(nèi)容。

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

我錯過了什么大問題嗎?


網(wǎng)站題目：53道Python面試問答題，幫你成為大數(shù)據(jù)工程師！
鏈接地址：http://www.dlmjj.cn/article/dpdjeip.html