Python3 編程面試題

• Python global 陳述句的作用
• lambda 匿名函式好處
• Python 錯誤處理
• Python 內置錯誤型別
• 簡述 any() 和 all() 方法
• Python 中什么元素為假？
• 提高 Python 運行效率的方法
• Python 單例模式
• 為什么 Python 不提供函式多載
• 實體方法/靜態方法/類方法
• __new__和 __init __方法的區別
• Python 的函式引數傳遞
• Python 實作對函參做型別檢查
• 為什么說 Python 是動態語言
• Python 裝飾器理解
• map 與 reduce 函式用法解釋
• Python 深拷貝、淺拷貝區別
• Python 繼承多型理解
• Python 面向物件的原則
• 參考資料

Python global 陳述句的作用

在撰寫程式的時候，如果想要改變(重新賦值)函式外部的變數，并且這個變數會作用于許多函式中，就需要告訴 Python 程式這個變數的作用域是全域變數，global 陳述句可以實作定義全域變數的作用，

lambda 匿名函式好處

精簡代碼，lambda省去了定義函式，map 省去了寫 for 回圈程序:

str_1 = ["中國", "美國", "法國", "", "", "英國"]
res = list(map(lambda x: "填充值" if x=="" else x, str_1))
print(res)  # ['中國', '美國', '法國', '填充值', '填充值', '英國']

Python 錯誤處理

和其他高級語言一樣，Python 也內置了一套try...except...finally... 的錯誤處理機制，

當我們認為某些代碼可能會出錯時，就可以用 try 來運行這段代碼，如果執行出錯，則后續代碼不會繼續執行，而是直接跳轉至跳轉至錯誤處理代碼，即 except 陳述句塊，執行完 except 后，如果有 finally 陳述句塊，則執行，至此，執行完畢，跳轉至錯誤處理代碼，

Python 內置錯誤型別

• IOError：輸入輸出例外
• AttributeError：試圖訪問一個物件沒有的屬性
• ImportError：無法引入模塊或包，基本是路徑問題
• IndentationError：語法錯誤，代碼沒有正確的對齊
• IndexError：下標索引超出序列邊界
• KeyError: 試圖訪問你字典里不存在的鍵
• SyntaxError: Python 代碼邏輯語法出錯，不能執行
• NameError: 使用一個還未賦予物件的變數

簡述 any() 和 all() 方法

• any(): 只要迭代器中有一個元素為真就為真;
• all(): 迭代器中所有的判斷項回傳都是真，結果才為真.

Python 中什么元素為假？

答案：（0，空字串，空串列、空字典、空元組、None, False）

提高 Python 運行效率的方法

1. 使用生成器，因為可以節約大量記憶體;
2. 回圈代碼優化，避免過多重復代碼的執行;
3. 核心模塊用 Cython PyPy 等，提高效率;
4. 多行程、多執行緒、協程;
5. 多個 if elif 條件判斷，可以把最有可能先發生的條件放到前面寫，這樣可以減少程式判斷的次數，提高效率，

Python 單例模式

為什么 Python 不提供函式多載

參考知乎為什么 Python 不支持函式多載？其他函式大部分都支持的？

我們知道 函式多載 主要是為了解決兩個問題，

1. 可變引數型別，
2. 可變引數個數，

另外，一個函式多載基本的設計原則是，僅僅當兩個函式除了引數型別和引數個數不同以外，其功能是完全相同的，此時才使用函式多載，如果兩個函式的功能其實不同，那么不應當使用多載，而應當使用一個名字不同的函式，

1. 對于情況 1 ，函式功能相同，但是引數型別不同，Python 如何處理？答案是根本不需要處理，因為 Python 可以接受任何型別的引數，如果函式的功能相同，那么不同的引數型別在 Python 中很可能是相同的代碼，沒有必要做成兩個不同函式，
2. 對于情況 2 ，函式功能相同，但引數個數不同，Python 如何處理？大家知道，答案就是預設引數(默認引數)，對那些缺少的引數設定為預設引數(默認引數)即可解決問題，因為你假設函式功能相同，那么那些缺少的引數終歸是需要用的，所以，鑒于情況 1 跟 情況 2 都有了解決方案，Python 自然就不需要函式多載了，

實體方法/靜態方法/類方法

Python 類語法中有三種方法，實體方法，靜態方法，類方法，它們的區別如下：

• 實體方法只能被實體物件呼叫，靜態方法(由 @staticmethod 裝飾器來宣告)、類方法(由 @classmethod 裝飾器來宣告)，可以被類或類的實體物件呼叫;
• 實體方法，第一個引數必須要默認傳實體物件，一般習慣用self，靜態方法，引數沒有要求，類方法，第一個引數必須要默認傳類，一般習慣用 cls .

實體代碼如下：

class Foo(object):
    """類三種方法語法形式
    """
    def instance_method(self):
        print("是類{}的實體方法，只能被實體物件呼叫".format(Foo))

    @staticmethod
    def static_method():
        print("是靜態方法")

    @classmethod
    def class_method(cls):
        print("是類方法")


foo = Foo()
foo.instance_method()
foo.static_method()
foo.class_method()
print('##############')
Foo.static_method()
Foo.class_method()

程式執行后輸出如下：

是類 <class 'main.Foo'> 的實體方法，只能被實體物件呼叫
是靜態方法
是類方法
##############
是靜態方法
是類方法

__new__和 __init __方法的區別

• __init__ 方法并不是真正意義上的建構式, __new__ 方法才是(類的建構式是類的一種特殊的成員函式，它會在每次創建類的新物件時執行);
• __new__ 方法用于創建物件并回傳物件，當回傳物件時會自動呼叫 __init__ 方法進行初始化, __new__ 方法比 __init__ 方法更早執行;
• __new__ 方法是靜態方法，而 __init__ 是實體方法，

Python 的函式引數傳遞

參考這兩個鏈接，stackoverflow的最高贊那個講得很詳細
How do I pass a variable by reference?
Python 面試題

個人總結（有點不好）：

• 將可變物件：串列list、字典dict、NumPy陣列ndarray和用戶定義的型別（類），作為引數傳遞給函式，函式內部將其改變后，函式外部這個變數也會改變（對變數進行重新賦值除外 rebind the reference in the method）
• 將不可變物件：字串string、元組tuple、數值numbers，作為引數傳遞給函式，函式內部將其改變后，函式外部這個變數不會改變

Python 實作對函參做型別檢查

Python 自帶的函式一般都會有對函式引數型別做檢查，自定義的函式引數型別檢查可以用函式 isinstance() 實作，例如：

def my_abs(x):
    """
    自定義的絕對值函式
    :param x: int or float
    :return: positive number, int or float
    """
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x > 0:
        return x
    else:
        return -x

添加了引數檢查后，如果傳入錯誤的引數型別，函式就可以拋出一個 TypeError 錯誤，

為什么說 Python 是動態語言

在 Python 中，等號 = 是賦值陳述句，可以把任意資料型別賦值給變數，同樣一個變數可以反復賦值，而且可以是不同型別的變數，例如：

a = 100 # a是int型變數
print(a)
a = 'ABC'  # a 是str型變數
print(a)

Pyhon 這種變數本身型別不固定，可以反復賦值不同型別的變數稱為動態語言，與之對應的是靜態語言，靜態語言在定義變數時必須指定變數型別，如果賦值的時候型別不匹配，就會報錯，Java/C++ 都是靜態語言（int a; a = 100）

Python 裝飾器理解

裝飾器本質上是一個 Python 函式或類，它可以讓其他函式或類在不需要做任何代碼修改的前提下增加額外功能，裝飾器的回傳值也是一個函式/類物件，它經常用于有切面需求的場景，比如：插入日志、性能測驗、事務處理、快取、權限校驗等場景，裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量與函式功能本身無關的雷同代碼到裝飾器中并繼續重用，概括的講，裝飾器的作用就是為已經存在的物件添加額外的功能，

map 與 reduce 函式用法解釋

1、map() 函式接收兩個引數，一個是函式，一個是 Iterable，map 將傳入的函式依次作用到序列的每個元素，并將結果作為新的 Iterator 回傳，簡單示例代碼如下：

# 示例１
def square(x):
    return x ** 2
r = map(square, [1, 2, 3, 4, 5, 6, 7])
squareed_list = list(r)
print(squareed_list)  # [1, 4, 9, 16, 25, 36, 49]
# 使用lambda匿名函式簡化為一行代碼
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
# 示例２
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))　＃　['1', '2', '3', '4', '5', '6', '7', '8', '9']

注意map函式回傳的是一個Iterator（惰性序列），要通過list函式轉化為常用串列結構，map()作為高階函式，事實上它是把運算規則抽象了，

2、reduce() 函式也接受兩個引數，一個是函式（兩個引數），一個是序列，與 map 不同的是reduce 把結果繼續和序列的下一個元素做累積計算,效果如下：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

示例代碼如下：

from functools import reduce
CHAR_TO_INT = {
    '0': 0,
    '1': 1,
    '2': 2,
    '3': 3,
    '4': 4,
    '5': 5,
    '6': 6,
    '7': 7,
    '8': 8,
    '9': 9
}
def str2int(str):
    ints = map(lambda x:CHAR_TO_INT[x], str)  # str物件是Iterable物件
    return reduce(lambda x,y:10*x + y, ints)
print(str2int('0'))
print(str2int('12300'))
print(str2int('0012345'))  # 0012345

Python 深拷貝、淺拷貝區別

Python 中的大多數物件，比如串列 list、字典 dict、集合 set、numpy 陣列，和用戶定義的型別（類），都是可變的，意味著這些物件或包含的值可以被修改，但也有些物件是不可變的，例如數值型 int、字串型 str 和元組 tuple，

1、復制不可變資料型別：

復制不可變資料型別，不管 copy 還是 deepcopy, 都是同一個地址，當淺復制的值是不可變物件（數值，字串，元組）時和=“賦值”的情況一樣，物件的 id 值與淺復制原來的值相同，

2、復制可變資料型別：

1. 直接賦值：其實就是物件的參考（別名），
2. 淺拷貝(copy)：拷貝父物件，不會拷貝物件內部的子物件（拷貝可以理解為創建記憶體），產生淺拷貝的操作有以下幾種：
   • 使用切片 [:] 操作
   • 使用工廠函式（如 list/dir/set ）, 工廠函式看上去像函式，實質上是類，呼叫時實際上是生成了該型別的一個實體，就像工廠生產貨物一樣.
   • 使用copy 模塊中的 copy() 函式，b = a.copy(), a 和 b 是一個獨立的物件，但他們的子物件還是指向統一物件（是參考），
3. 深拷貝(deepcopy)： copy 模塊的 deepcopy() 方法，完全拷貝了父物件及其子物件，兩者是完全獨立的，深拷貝，包含物件里面的子物件的拷貝，所以原始物件的改變不會造成深拷貝里任何子元素的改變，

注意：淺拷貝和深拷貝的不同僅僅是對組合物件來說，所謂的組合物件（容器）就是包含了其它物件的物件，如串列，類實體，而對于數字、字串以及其它“原子”型別（沒有子物件），沒有拷貝一說，產生的都是原物件的參考，更清晰易懂的理解，可以參考這篇文章，

看一個示例程式，就能明白淺拷貝與深拷貝的區別了：

#!/usr/bin/Python3
# -*-coding:utf-8 -*-

import copy
a = [1, 2, 3, ['a', 'b', 'c']]

b = a  # 賦值，傳物件的參考
c = copy.copy(a)  # 淺拷貝
d = copy.deepcopy(a)  # 深拷貝

a.append(4)
a[3].append('d')

print(id(a), id(b), id(c), id(d))  # a 與 b 的記憶體地址相同
print('a = ', a)
print('b = ', b)
print('c = ', c)
print('d = ', d)  # [1, 2, 3, ['a', 'b', 'c']]

程式輸出如下：

2061915781832 2061915781832 2061932431304 2061932811400

a = [1, 2, 3, ['a', 'b', 'c', 'd'], 4]
b = [1, 2, 3, ['a', 'b', 'c', 'd'], 4]
c = [1, 2, 3, ['a', 'b', 'c', 'd']]
d = [1, 2, 3, ['a', 'b', 'c']]

Python 繼承多型理解

• 多型是指對不同型別的變數進行相同的操作，它會根據物件（或類）型別的不同而表現出不同的行為，
• 繼承可以拿到父類的所有資料和方法，子類可以重寫父類的方法，也可以新增自己特有的方法，
• 先有繼承，后有多型，不同類的物件對同一訊息會作出不同的相應，

Python 面向物件的原則

• Python 工匠：寫好面向物件代碼的原則（上）
• Python 工匠：寫好面向物件代碼的原則（中）
• Python 工匠：寫好面向物件代碼的原則（下）

參考資料

1. 參考這里
2. 110道Python面試題（真題）
3. 關于Python的面試題
4. 繼承和多型
5. Python 直接賦值、淺拷貝和深度拷貝決議

標籤：其他

上一篇：學習 Shell準沒錯

下一篇：使用Dom4J決議【.xml】檔案