搞定這套 Python 爬蟲面試題,面試會 so easy

Python學習者發表於2019-03-15

本文是看到一粉絲的一個開源專案,目前只是完成了部分面試題的蒐集,需要大家一起努力完成該專案。本篇只是部分Python基礎的面試題。

Github地址:

github.com/asyncspider…

先來一份完整的爬蟲工程師面試考點:

img

一、 Python 基本功

1、簡述Python 的特點和優點

Python 是一門開源的解釋性語言,相比 Java C++ 等語言,Python 具有動態特性,非常靈活。

2、Python 有哪些資料型別?

Python 有 6 種內建的資料型別,其中不可變資料型別是Number(數字), String(字串), Tuple(元組),可變資料型別是 List(列表),Dict(字典),Set(集合)。

3、列表和元組的區別

列表和元組都是可迭代物件,能夠對其進行迴圈、切片等,但元組 tuple 是不可變的。元組不可變的特性,使得它可以成為字典 Dict 中的鍵。

4、Python 是如何執行的

CPython:

Python 程式執行時,會先進行編譯,將 .py 檔案中的程式碼編譯成位元組碼(byte code),編譯結果儲存在記憶體的 PyCodeObject 中,然後由 Python 虛擬機器解釋執行。當程式執行結束後,Python 直譯器會將 PyCodeObject 儲存到 pyc 檔案中。每一次執行時 Python 都會先尋找與檔案同名的 pyc 檔案,如果 pyc 存在則比對修改記錄,根據修改記錄決定直接執行或再次編譯後執行,最後生成 pyc 檔案 。

5、Python 執行速度慢的原因

a). Python 不是強型別的語言,所以直譯器執行時遇到變數以及資料型別轉換、比較操作、引用變數時都需要檢查其資料型別。

b). Python 的編譯器啟動速度比 JAVA 快,但幾乎每次都要啟動編譯。

c). Python 的物件模型會導致訪問記憶體效率變低。Numpy 的指標指向快取區資料的值,而 Python 的指標指向快取物件,再通過快取物件指向資料:

img

6、面對 Python 慢的問題,有什麼解決辦法

a). 可以使用其他的直譯器,比如 PyPy 和 Jython 等。

b). 如果對效能要求較高且靜態型別變數較多的應用程式,可以使用 CPython。

c). 對於 IO 操作多的應用程式,Python 提供 asyncio 模組提高非同步能力。

7、描述一下全域性直譯器鎖 GIL

每個執行緒在執行時候都需要先獲取 GIL,保證同一時刻只有一個執行緒可以執行程式碼,即同一時刻只有一個執行緒使用 CPU,也就是說多執行緒並不是真正意義上的同時執行。但是在 IO 操作時,是可以釋放鎖的(這也是 Python 能夠非同步的原因)。而且如果想要利用多核 CPU,那麼可以使用多程式。

8、深拷貝 淺拷貝

深拷貝是將物件本身複製給另一個物件,淺拷貝則是將物件的引用複製給另一個物件。所以當複製後的物件改變時,深拷貝的原物件值不會改變,而淺拷貝原物件的值會被改變。

9、is 和 == 的區別

is 表示的是物件標示符(object identity),而 == 表示的是相等(equality)。

is 的作用是用來檢查物件的標示符是否一致,也就是比較兩個物件在記憶體中的地址是否一樣,而 == 是用來檢查兩個物件是否相等。但是為了提高系統效能,對於較小的字串 Python 會保留其值的一個副本,當建立新的字串的時候直接指向該副本即可。如:

a = 8
b = 8
a is b
複製程式碼

10、檔案讀寫

簡述檔案讀取時 read 、readline、readlines 的區別和作用

他們的區別除了讀取內容範圍不同外,返回的內容型別也不同。

read()會讀取整個檔案,將讀取到底的檔案內容放到一個字串變數,返回 str 型別。

readline()讀取一行內容,放到一個字串變數,返回 str 型別。

readlines() 讀取檔案所有內容,按行為單位放到一個列表中,返回 list 型別。

11、請用一行程式碼實現

請分別使用匿名函式和推導式這兩種方式將 [0, 1, 2, 3, 4, 5] 中的元素求乘積,並列印輸出元組。

print(tuple(map(lambda x: x * x, [0, 1, 2, 3, 4, 5])))

print(tuple(i*i for i in [0, 1, 2, 3, 4, 5]))
複製程式碼

12、請用一行程式碼實現

用 reduce 計算 n 的階乘(n!=1×2×3×...×n)

print(reduce(lambda x, y: x*y, range(1, n)))
複製程式碼

13、請用一行程式碼實現

篩選並列印輸出 100 以內能被 3 整除的數的集合

print(set(filter(lambda n: n % 3 == 0, range(1, 100))))
複製程式碼

14、請用一行程式碼實現

text = 'Obj{"Name": "pic", "data": [{"name": "async", "number": 9, "price": "$3500"}, {"name": "Wade", "number": 3, "price": "$5500"}], "Team": "Hot"'
複製程式碼

列印文字中的球員身價元組,如 ($3500, $5500)

print(tuple(i.get("price") for i in json.loads(re.search(r'\[(.*)\]', text).group(0))))
複製程式碼

15、請寫出遞迴的基本骨架

def recursions(n):
    if n == 1:
        # 退出條件
        return 1
    # 繼續遞迴
    return n * recursions(n - 1)
複製程式碼

16、切片

請寫出下方輸出結果

tpl = [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

print(tpl[3:])
print(tpl[:3])
print(tpl[::5])
print(tpl[-3])
print(tpl[3])
print(tpl[::-5])
print(tpl[:])
del tpl[3:]
print(tpl)
print(tpl.pop())
tpl.insert(3, 3)
print(tpl)
複製程式碼
[15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
[0, 5, 10]
[0, 25, 50, 75]
85
15
[95, 70, 45, 20]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
[0, 5, 10]
10
[0, 5, 3]
複製程式碼

17、檔案路徑

列印輸出當前檔案所在目錄路徑

import os
print(os.path.dirname(os.path.abspath(__file__)))
複製程式碼

列印輸出當前檔案路徑

import os
print(os.path.abspath(__file__))
複製程式碼

列印輸出當前檔案上兩層檔案目錄路徑

import os
print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
複製程式碼

18、請寫出執行結果,並回答問題

tpl = (1, 2, 3, 4, 5)
apl = (6, 7, 8, 9)
print(tpl.__add__(apl))
複製程式碼

問題:tpl 的值發生變化了嗎?

執行結果如下:

(1, 2, 3, 4, 5, 6, 7, 8, 9)
複製程式碼

答:元組是不可變的,它是生成新的物件

19、請寫出執行結果,並回答問題

name = ('James', 'Wade', 'Kobe')
team = ['A', 'B', 'C']

tpl = {name: team}
print(tpl)
apl = {team: name}
print(apl)
複製程式碼

問題:這段程式碼能執行完畢嗎?為什麼?它的執行結果是?

答:這段程式碼不能完整執行,它會在 apl 處丟擲異常,因為字典的鍵只能是不可變物件,而 list 是可變的,所以不能作為字典的鍵。執行結果是:

{('James', 'Wade', 'Kobe'): ['A', 'B', 'C']}
TypeError
複製程式碼

20、裝飾器

請寫出裝飾器程式碼骨架

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
複製程式碼

簡述裝飾器在 Python 中的作用:

在不改動原函式程式碼的情況下,為其增加新的功能。

21、多程式 多執行緒

多程式更穩定還是多執行緒更穩定?為什麼?

多程式更穩定,它們是獨立執行的,不會因為一個崩潰而影響其他程式。

多執行緒的致命缺點是什麼?

因為所有執行緒共享程式的記憶體,所以任何一個執行緒掛掉都可能直接造成整個程式崩潰。

程式間通訊有哪些方式?

共享變數、佇列、管道。

二、Python 細節問題

1、 連線字串用join還是+

當用操作符+連線字串的時候,每執行一次+都會申請一塊新的記憶體,然後複製上一個+操作的結果和本次操作的右操作符到這塊記憶體空間,因此用+連線字串的時候會涉及好幾次記憶體申請和複製。而join在連線字串的時候,會先計算需要多大的記憶體存放結果,然後一次性申請所需記憶體並將字串複製過去,這是為什麼join的效能優於+的原因。所以在連線字串陣列的時候,應考慮優先使用join。

2、Python 垃圾回收機制

參考 blog.csdn.net/xiongchengl…

Python中的垃圾回收是以引用計數為主,分代收集為輔。引用計數的缺陷是迴圈引用的問題。

在Python中,如果一個物件的引用數為0,Python虛擬機器就會回收這個物件的記憶體。

引用計數法的原理是每個物件維護一個ob_refcnt,用來記錄當前物件被引用的次數,也就是來追蹤到底有多少引用指向了這個物件,當物件被建立、物件被引用、物件被傳入函式、被儲存在容器中等四種情況時,該物件的引用計數器 +1

物件被建立 a=14

物件被引用 b=a

物件被作為引數,傳到函式中 func(a)

物件作為一個元素,儲存在容器中 List={a,”a”,”b”,2}

與上述情況相對應,當發生物件別名被 del 銷燬時、物件的引用被賦予新物件時、漢書執行完畢後、從容器中刪除時等四種情況,該物件的引用計數器-1

當該物件的別名被顯式銷燬時 del a

當該物件的引別名被賦予新的物件, a=26

一個物件離開它的作用域,例如 func函式執行完畢時,函式裡面的區域性變數的引用計數器就會 -1(但是全域性變數不會)。

將該元素從容器中刪除時,或者容器被銷燬時。

當指向該物件的記憶體的引用計數器為0的時候,該記憶體將會被Python虛擬機器釋放.

sys.getrefcount(a)可以檢視 a 物件的引用計數,但是比正常計數大1,因為呼叫函式的時候傳入a,這會讓 a 的引用計數+1

引用計數的優點:

1、高效

2、執行期沒有停頓:一旦沒有引用,記憶體就直接釋放了。不用像其他機制等到特定時機。實時性還帶來一個好處:處理回收記憶體的時間分攤到了平時。

3、物件有確定的生命週期

4、易於實現

引用計數的缺點:

1、維護引用計數消耗資源,維護引用計數的次數和引用賦值成正比,而不像mark and sweep等基本與回收的記憶體數量有關。

2、無法解決迴圈引用的問題。A和B相互引用而再沒有外部引用A與B中的任何一個,它們的引用計數都為1,但顯然應該被回收。

# 迴圈引用示例
list1 = []
list2 = []
list1.append(list2)
list2.append(list1)
複製程式碼

為了解決這兩個缺點 Python 還引入了另外的機制:標記清除和分代回收.

標記清除

『標記清除(Mark—Sweep)』演算法是一種基於追蹤回收(tracing GC)技術實現的垃圾回收演算法。它分為兩個階段:第一階段是標記階段,GC會把所有的『活動物件』打上標記,第二階段是把那些沒有標記的物件『非活動物件』進行回收。那麼GC又是如何判斷哪些是活動物件哪些是非活動物件的呢?

物件之間通過引用(指標)連在一起,構成一個有向圖,物件構成這個有向圖的節點,而引用關係構成這個有向圖的邊。從根物件(root object)出發,沿著有向邊遍歷物件,可達的(reachable)物件標記為活動物件,不可達的物件就是要被清除的非活動物件。根物件就是全域性變數、呼叫棧、暫存器。

img

在上圖中,我們把小黑圈視為全域性變數,也就是把它作為root object,從小黑圈出發,物件1可直達,那麼它將被標記,物件2、3可間接到達也會被標記,而4和5不可達,那麼1、2、3就是活動物件,4和5是非活動物件會被GC回收。

標記清除演算法作為Python的輔助垃圾收集技術主要處理的是一些容器物件,比如list、dict、tuple,instance等,因為對於字串、數值物件是不可能造成迴圈引用問題。

Python使用一個雙向連結串列將這些容器物件組織起來。不過,這種簡單粗暴的標記清除演算法也有明顯的缺點:清除非活動的物件前它必須順序掃描整個堆記憶體,哪怕只剩下小部分活動物件也要掃描所有物件。

分代回收

分代回收同樣作為Python的輔助垃圾收集技術處理那些容器物件。

GC 的邏輯

分配記憶體
-> 發現超過閾值了
-> 觸發垃圾回收
-> 將所有可收集物件連結串列放到一起
-> 遍歷, 計算有效引用計數
-> 分成 有效引用計數=0 和 有效引用計數 > 0 兩個集合
-> 大於0的, 放入到更老一代
-> =0的, 執行回收
-> 回收遍歷容器內的各個元素, 減掉對應元素引用計數(破掉迴圈引用)
-> 執行-1的邏輯, 若發現物件引用計數=0, 觸發記憶體回收
-> python底層記憶體管理機制回收記憶體
複製程式碼

Python 中, 一個代就是一個連結串列, 所有屬於同一”代”的記憶體塊都連結在同一個連結串列中用來表示“代”的結構體是 gc_generation, 包括了當前代連結串列表頭、物件數量上限、當前物件數量。

Python預設定義了三代物件集合,索引數越大,物件存活時間越長,新生成的物件會被加入第0代,前面_PyObject_GC_Malloc中省略的部分就是Python GC觸發的時機。每新生成一個物件都會檢查第0代有沒有滿,如果滿了就開始著手進行垃圾回收。

分代回收是一種以空間換時間的操作方式,Python將記憶體根據物件的存活時間劃分為不同的集合,每個集合稱為一個代,Python將記憶體分為了3“代”,分別為年輕代(第0代)、中年代(第1代)、老年代(第2代),他們對應的是3個連結串列,它們的垃圾收集頻率與物件的存活時間的增大而減小。新建立的物件都會分配在年輕代,年輕代連結串列的總數達到上限時,Python垃圾收集機制就會被觸發,把那些可以被回收的物件回收掉,而那些不會回收的物件就會被移到中年代去,依此類推,老年代中的物件是存活時間最久的物件,甚至是存活於整個系統的生命週期內。同時,分代回收是建立在標記清除技術基礎之上。

3、遞迴

Python 遞迴深度預設是多少?遞迴深度限制的原因是什麼?

Python 遞迴深度可以用內建函式庫中的 sys.getrecursionlimit() 檢視。

因為無限遞迴會導致的 C 堆疊溢位和 Python 崩潰。

相關文章