轉自https://github.com/taizilongxu/interview_python

1 Python的函式引數傳遞

看兩個例子:

a = 1
def fun(a):
    a = 2
fun(a)
print a  # 1

a = []
def fun(a):
    a.append(1)
fun(a)
print a  # [1]

所有的變數都可以理解是記憶體中一個物件的“引用”，或者，也可以看似c中void*的感覺。

通過id來看引用a的記憶體地址可以比較理解：

a = 1
def fun(a):
    print "func_in",id(a)   # func_in 41322472
    a =
 
 2
    print "re-point",id(a), id(2)   # re-point 41322448 41322448
print "func_out",id(a), id(1)  # func_out 41322472 41322472
fun(a)
print a  # 1

注：具體的值在不同電腦上執行時可能不同。

可以看到，在執行完a = 2之後，a引用中儲存的值，即記憶體地址發生變化，由原來1物件的所在的地址變成了2這個實體物件的記憶體地址。

而第2個例子a引用儲存的記憶體值就不會發生變化：

a = []
def fun(a):
    print "func_in",id(a)  #
 
 func_in 53629256
    a.append(1)
print "func_out",id(a)     # func_out 53629256
fun(a)
print a  # [1]

這裡記住的是型別是屬於物件的，而不是變數。而物件有兩種,“可更改”（mutable）與“不可更改”（immutable）物件。在python中，strings, tuples, 和numbers是不可更改的物件，而 list, dict, set 等則是可以修改的物件。(這就是這個問題的重點)

當一個引用傳遞給函式的時候,函式自動複製一份引用,這個函式裡的引用和外邊的引用沒有半毛關係了.所以第一個例子裡函式把引用指向了一個不可變物件,當函式返回的時候,外面的引用沒半毛感覺.而第二個例子就不一樣了,函式內的引用指向的是可變物件,對它的操作就和定位了指標地址一樣,在記憶體裡進行修改.

2 Python中的元類(metaclass)

3 @staticmethod和@classmethod

Python其實有3個方法,即靜態方法(staticmethod),類方法(classmethod)和例項方法,如下:

def foo(x):
    print "executing foo(%s)"%(x)

class A(object):
    def foo(self,x):
        print "executing foo(%s,%s)"%(self,x)

    @classmethod
    def class_foo(cls,x):
        print "executing class_foo(%s,%s)"%(cls,x)

    @staticmethod
    def static_foo(x):
        print "executing static_foo(%s)"%x

a=A()

這裡先理解下函式引數裡面的self和cls.這個self和cls是對類或者例項的繫結,對於一般的函式來說我們可以這麼呼叫foo(x),這個函式就是最常用的,它的工作跟任何東西(類,例項)無關.對於例項方法,我們知道在類裡每次定義方法的時候都需要繫結這個例項,就是foo(self, x),為什麼要這麼做呢?因為例項方法的呼叫離不開例項,我們需要把例項自己傳給函式,呼叫的時候是這樣的a.foo(x)(其實是foo(a, x)).類方法一樣,只不過它傳遞的是類而不是例項,A.class_foo(x).注意這裡的self和cls可以替換別的引數,但是python的約定是這倆,還是不要改的好.

對於靜態方法其實和普通的方法一樣,不需要對誰進行繫結,唯一的區別是呼叫的時候需要使用a.static_foo(x)或者A.static_foo(x)來呼叫.

更多關於這個問題:

4 類變數和例項變數

類變數：

​ 是可在類的所有例項之間共享的值（也就是說，它們不是單獨分配給每個例項的）。例如下例中，num_of_instance 就是類變數，用於跟蹤存在著多少個Test 的例項。

例項變數：

例項化之後，每個例項單獨擁有的變數。

class Test(object):  
    num_of_instance = 0  
    def __init__(self, name):  
        self.name = name  
        Test.num_of_instance += 1  
  
if __name__ == '__main__':  
    print Test.num_of_instance   # 0
    t1 = Test('jack')  
    print Test.num_of_instance   # 1
    t2 = Test('lucy')  
    print t1.name , t1.num_of_instance  # jack 2
    print t2.name , t2.num_of_instance  # lucy 2

補充的例子

class Person:
    name="aaa"

p1=Person()
p2=Person()
p1.name="bbb"
print p1.name  # bbb
print p2.name  # aaa
print Person.name  # aaa

這裡p1.name="bbb"是例項呼叫了類變數,這其實和上面第一個問題一樣,就是函式傳參的問題,p1.name一開始是指向的類變數name="aaa",但是在例項的作用域裡把類變數的引用改變了,就變成了一個例項變數,self.name不再引用Person的類變數name了.

可以看看下面的例子:

class Person:
    name=[]

p1=Person()
p2=Person()
p1.name.append(1)
print p1.name  # [1]
print p2.name  # [1]
print Person.name  # [1]

5 Python自省

這個也是python彪悍的特性.

自省就是面向物件的語言所寫的程式在執行時,所能知道物件的型別.簡單一句就是執行時能夠獲得物件的型別.比如type(),dir(),getattr(),hasattr(),isinstance().

a = [1,2,3]
b = {'a':1,'b':2,'c':3}
c = True
print type(a),type(b),type(c) # <type 'list'> <type 'dict'> <type 'bool'>
print isinstance(a,list)  # True

6 字典推導式

可能你見過列表推導時,卻沒有見過字典推導式,在2.7中才加入的:

d = {key: value for (key, value) in iterable}

7 Python中單下劃線和雙下劃線

>>> class MyClass():
...     def __init__(self):
...             self.__superprivate = "Hello"
...             self._semiprivate = ", world!"
...
>>> mc = MyClass()
>>> print mc.__superprivate
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: myClass instance has no attribute '__superprivate'
>>> print mc._semiprivate
, world!
>>> print mc.__dict__
{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

__foo__:一種約定,Python內部的名字,用來區別其他使用者自定義的命名,以防衝突，就是例如__init__(),__del__(),__call__()這些特殊方法

_foo:一種約定,用來指定變數私有.程式設計師用來指定私有變數的一種方式.不能用from module import * 匯入，其他方面和公有一樣訪問；

__foo:這個有真正的意義:解析器用_classname__foo來代替這個名字,以區別和其他類相同的命名,它無法直接像公有成員一樣隨便訪問,通過物件名._類名__xxx這樣的方式可以訪問.

8 字串格式化:%和.format

.format在許多方面看起來更便利.對於%最煩人的是它無法同時傳遞一個變數和元組.你可能會想下面的程式碼不會有什麼問題:

"hi there %s" % name

但是,如果name恰好是(1,2,3),它將會丟擲一個TypeError異常.為了保證它總是正確的,你必須這樣做:

"hi there %s" % (name,)   # 提供一個單元素的陣列而不是一個引數

但是有點醜..format就沒有這些問題.你給的第二個問題也是這樣,.format好看多了.

你為什麼不用它?

• 不知道它(在讀這個之前)
• 為了和Python2.5相容(譬如logging庫建議使用%(issue #4))

9 迭代器和生成器

這裡有個關於生成器的建立問題面試官有考： 問： 將列表生成式中[]改成() 之後資料結構是否改變？ 答案：是，從列表變為生成器

>>> L = [x*x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x*x for x in range(10))
>>> g
<generator object <genexpr> at 0x0000028F8B774200>

通過列表生成式，可以直接建立一個列表。但是，受到記憶體限制，列表容量肯定是有限的。而且，建立一個包含百萬元素的列表，不僅是佔用很大的記憶體空間，如：我們只需要訪問前面的幾個元素，後面大部分元素所佔的空間都是浪費的。因此，沒有必要建立完整的列表（節省大量記憶體空間）。在Python中，我們可以採用生成器：邊迴圈，邊計算的機制—>generator

10 *args and **kwargs

用*args和**kwargs只是為了方便並沒有強制使用它們.

當你不確定你的函式裡將要傳遞多少引數時你可以用*args.例如,它可以傳遞任意數量的引數:

>>> def print_everything(*args):
        for count, thing in enumerate(args):
...         print '{0}. {1}'.format(count, thing)
...
>>> print_everything('apple', 'banana', 'cabbage')
0. apple
1. banana
2. cabbage

相似的,**kwargs允許你使用沒有事先定義的引數名:

>>> def table_things(**kwargs):
...     for name, value in kwargs.items():
...         print '{0} = {1}'.format(name, value)
...
>>> table_things(apple = 'fruit', cabbage = 'vegetable')
cabbage = vegetable
apple = fruit

你也可以混著用.命名引數首先獲得引數值然後所有的其他引數都傳遞給*args和**kwargs.命名引數在列表的最前端.例如:

def table_things(titlestring, **kwargs)

*args和**kwargs可以同時在函式的定義中,但是*args必須在**kwargs前面.

當呼叫函式時你也可以用*和**語法.例如:

>>> def print_three_things(a, b, c):
...     print 'a = {0}, b = {1}, c = {2}'.format(a,b,c)
...
>>> mylist = ['aardvark', 'baboon', 'cat']
>>> print_three_things(*mylist)

a = aardvark, b = baboon, c = cat

就像你看到的一樣,它可以傳遞列表(或者元組)的每一項並把它們解包.注意必須與它們在函式裡的引數相吻合.當然,你也可以在函式定義或者函式呼叫時用*.

11 面向切面程式設計AOP和裝飾器

這個AOP一聽起來有點懵,同學面阿里的時候就被問懵了...

裝飾器是一個很著名的設計模式，經常被用於有切面需求的場景，較為經典的有插入日誌、效能測試、事務處理等。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量函式中與函式功能本身無關的雷同程式碼並繼續重用。概括的講，裝飾器的作用就是為已經存在的物件新增額外的功能。

12 鴨子型別

“當看到一隻鳥走起來像鴨子、游泳起來像鴨子、叫起來也像鴨子，那麼這隻鳥就可以被稱為鴨子。”

我們並不關心物件是什麼型別，到底是不是鴨子，只關心行為。

比如在python中，有很多file-like的東西，比如StringIO,GzipFile,socket。它們有很多相同的方法，我們把它們當作檔案使用。

又比如list.extend()方法中,我們並不關心它的引數是不是list,只要它是可迭代的,所以它的引數可以是list/tuple/dict/字串/生成器等.

鴨子型別在動態語言中經常使用，非常靈活，使得python不想java那樣專門去弄一大堆的設計模式。

13 Python中過載

函式過載主要是為了解決兩個問題。

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

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

好吧，那麼對於情況 1 ，函式功能相同，但是引數型別不同，python 如何處理？答案是根本不需要處理，因為 python 可以接受任何型別的引數，如果函式的功能相同，那麼不同的引數型別在 python 中很可能是相同的程式碼，沒有必要做成兩個不同函式。

那麼對於情況 2 ，函式功能相同，但引數個數不同，python 如何處理？大家知道，答案就是預設引數。對那些缺少的引數設定為預設引數即可解決問題。因為你假設函式功能相同，那麼那些缺少的引數終歸是需要用的。

好了，鑑於情況 1 跟 情況 2 都有了解決方案，python 自然就不需要函式過載了。

14 新式類和舊式類

這個面試官問了,我說了老半天,不知道他問的真正意圖是什麼.

新式類很早在2.2就出現了,所以舊式類完全是相容的問題,Python3裡的類全部都是新式類.這裡有一個MRO問題可以瞭解下(新式類是廣度優先,舊式類是深度優先),<Python核心程式設計>裡講的也很多.

一箇舊式類的深度優先的例子

class A():
    def foo1(self):
        print "A"
class B(A):
    def foo2(self):
        pass
class C(A):
    def foo1(self):
        print "C"
class D(B, C):
    pass

d = D()
d.foo1()

# A

按照經典類的查詢順序從左到右深度優先的規則，在訪問d.foo1()的時候,D這個類是沒有的..那麼往上查詢,先找到B,裡面沒有,深度優先,訪問A,找到了foo1(),所以這時候呼叫的是A