​

魔術方法

檢視類的魔術方法

class A:
    pass
dir(A)  # 可以得到類所有公有成員
複製程式碼

輸出結果如下

['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__']
複製程式碼

在Python中，所有以__雙下劃線包起來的方法，都統稱為魔術方法。比如最常見的 __init__ 。

這裡多說一句，小編是一名python開發工程師，這裡有我自己整理了一套最新的python系統學習教程，包括從基礎的python指令碼到web開發、爬蟲、資料分析、資料視覺化、機器學習等。想要這些資料的可以進裙930900780領取。

建立/銷燬

• __new__: object.__new__(cls) 建立類的方法：建構函式
• __del__:刪除類：解構函式
• __init__：初始化函式

class A:
    def __new__(cls, *args, **kwargs):
        print('new')
        return object.__new__(cls)

    def __init__(self):
        print('init')
        self.x = 3

    def __del__(self):
        print('del')

A() # 返回一個類<__main__.A at 0x7f4a84767978>
# 輸出
new
init

a = A()
del a  # 輸出del
複製程式碼

每當例項空間被收回時(在垃圾收集時)，__del__就會自動執行。

運算子過載

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Point(self.x - other.x, self.y - other.y)

a = Point(0, 0)
b = Point(3, 5)
c = a + b
c += Point(4, 6)
print(c.x, c.y)  # 7, 11  
p = Point(3, 5) - Point(2, 1)
print(p.x, p.y)  # 1, 4
複製程式碼

類的物件之間可以進行加減運算，只要類實現了加減運算對應的魔術方法即可。加法的具體實現是__add__，減法的具體實現是__sub__。

• 具體運算子對應的過載函式可以參考int類中運算子過載的實現：help(int)

​

不要過度使用運算子過載

Point.__add__ = lambda self, value: self - value
p = Point(3, 5) + Point(4, 6)
print(p.x, p.y)  # 輸出-1, -1
複製程式碼

__add__的具體實現如果寫成了減法，這種型別的錯誤非常不容易發現，因此如果不是在寫庫給第三方使用的時候，基本用不上運算子過載。

hash

• 使用內建函式hash對某個物件求hash值時， 會呼叫物件的__hash__方法，示例程式碼如下

In [1]: class Point:
   ...:     def __hash__(self):
   ...:         return 1
   ...:     

In [2]: hash(Point())
Out[2]: 1
複製程式碼

• __hash__方法必須返回int，否則會丟擲TypeError

In [1]: class Point:
   ...:     def __hash__(self):
   ...:         return 'aaa'
   ...:     

In [2]: hash(Point())
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-5-a919dcea3eae> in <module>()
----> 1 hash(Point())

TypeError: __hash__ method should return an integer
複製程式碼

• 可hash物件，就是具有__hash__方法的物件

In [6]: class Point:
   ...:     def __hash__(self):
   ...:         return 1
   ...:         

In [7]: set([Point(), 12]) # 可hash
Out[7]: {<__main__.Point at 0x7f19d4073320>, 12}

In [8]: Point.__hash__ = None

In [9]: set([Point(), 12])  # 不能放在集合裡面，因為不能hash
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-25999920b521> in <module>()
----> 1 set([Point(), 12])

TypeError: unhashable type: 'Point'

複製程式碼

• 一個類如果沒有重寫__hash__方法的話，這個類的每個物件，通常具有不同的hash

In [1]: class Point:
   ...:     pass
   ...: 

In [2]: p1 = Point()

In [3]: p2 = Point()

In [4]: hash(p1)
Out[4]: 8757059543567

In [5]: hash(p2)
Out[5]: 8757059543756
複製程式碼

• 通常 __hash__ 會和 __eq__一起使用， 因為直譯器通常同時判斷hash是否相等以及例項是否相等

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __hash__(self):
        return hash('{}:{}'.format(self.x, self.y))

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

p1 = Point(3, 5)
p2 = Point(3, 5)
set([p1, p2])  # 返回 {<__main__.Point at 0x7f286092d588>}
hash(p1) == hash(p2)  # 返回True
p1 == p2  # 返回True
複製程式碼

大小

當物件實現了__len__方法時，可以使用內建方法len求物件的長度, __len__方法必須返回非負整數

lst = [1, 2, 3]
len(lst)  # 返回3
lst.__len__()  # 返回3
複製程式碼

因此內建函式和__len__方法的效果相同。

class Sized:
    def __len__(self):
        return 10

len(Sized())  # 返回10
複製程式碼

bool

• 當物件o實現了__bool__ 方法時， bool(o)返回值為o.__bool__()

class F:
    def __bool__(self):
        return False

bool(F())  # 返回False

class T:
    def __bool__(self):
        return True

bool(T())  # 返回True
複製程式碼

• 當物件o沒有實現__bool__方法時，如果o實現了__len__方法， bool(o)返回值為 len(o) != 0

class L:
    def __len__(self):
        return 3

bool(L())  # 返回True

class Q:
    def __len__(self):
        return 0

bool(Q())  # 返回False
複製程式碼

• 當物件o既沒有實現__bool__方法，也沒有實現 __len__方法的時候， bool(o)返回值為True

class Boolean:
    pass

bool(Boolean())  # 返回True
複製程式碼

• __bool__優先順序比__len__更高

class Sized:
    def __init__(self, size):
        self.size = size

    def __len__(self):
        return self.size

    def __bool__(self):
        return self.size == 0

bool(Sized(0))  # 返回True
bool(Sized(10))  # 返回False
複製程式碼

• __bool__方法必須返回bool型別

class B:
    def __bool__(self):
        return None  # 返回非bool型別的值時會出錯，即使返回int型的也會報錯

bool(B())
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-80-4efbb03885fe> in <module>()
----> 1 bool(B())

TypeError: __bool__ should return bool, returned NoneType
複製程式碼

視覺化

• __str__方法，print函式本質是呼叫物件的__str__方法，用於給人讀
• __repr__方法，repr函式本質是呼叫物件的__repr__方法，用於給機器讀

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):  # 給人來讀
        return 'Point<{}, {}>'.format(self.x, self.y)

    def __repr__(self): # 給機器讀的
        return 'Point({}, {})'.format(self.x, self.y)

print(Point(3, 5))  # Point<3, 5>
print(repr(Point(3, 5)))  # Point(3, 5)
複製程式碼

repr:返回物件的規範化的字串表示

可呼叫物件

class Fn:
    def __call__(self):
        print('{} called'.format(self))

f = Fn()
f()

# 輸出
<__main__.Fn object at 0x7fd254367470> called
複製程式碼

一個物件，只要實現了__call__方法， 就可以通過小括號來來呼叫， 這一類物件，稱之為可呼叫物件

給物件加上函式也就是對__call__方法加上引數：

class Add:
    def __call__(self, x, y):
        return x + y

Add()(3, 5)  # 返回8，等價於 add =Add() add(3, 5)
複製程式碼

可呼叫物件的應用例項：實現可過期可換出的cache裝飾器

import inspect
import datetime
from functools import wraps

class Cache:
    def __init__(self, size=128, expire=0):
        self.size = size
        self.expire = 0
        self.data = {}

    @staticmethod
    def make_key(fn, args, kwargs):
        ret = []
        names = set()
        params = inspect.signature(fn).parameters
        keys = list(params.keys())
        for i, arg in enumerate(args):
            ret.append((keys[i], arg))
            names.add(keys[i])
        ret.extend(kwargs.items())
        names.update(kwargs.keys())
        for k, v in params.items():
            if k not in names:
                ret.append((k, v.default))
        ret.sort(key=lambda x: x[0])
        return '&'.join(['{}={}'.format(name, arg) for name, arg in ret])

    def __call__(self, fn):
        @wraps(fn)
        def wrap(*args, **kwargs):
            key = self.make_key(fn, args, kwargs)
            now = datetime.datetime.now().timestamp()
            if key in self.data.keys():
                value, timestamp, _ = self.data[key]
                if expire == 0 or now - timestamp < expire:
                    self.data[key] = (value, timestamp, now)
                    return value
                else:
                    self.data.pop(key)
            value = fn(*args, **kwargs)
            if len(self.data) >= self.size: 
                # 過期清理
                if self.expire != 0:
                    expires = set()
                    for k, (_, timestamp, _) in self.data.items():
                        if now - timestamp >= self.expire:
                            expires.add(k)
                    for k in expires:
                        self.data.pop(k)
            if len(self.data) >= self.size:
                # 換出
                k = sorted(self.data.items(), key=lambda x: x[1][2])[0][0]
                self.data.pop(k)
            self.data[key] = (value, now, now)
            return value
        return wrap

@Cache()
def add(x, y):
    return x + y

add(1, 2)  # 返回3
複製程式碼

用__call__來實現可呼叫物件，和閉包是殊途同歸的，通常是為了封裝一些內部狀態

上下文管理

支援上下文管理的物件

class Context:
    def __enter__(self):
        print('enter context')

    def __exit__(self, *args, **kwargs):
        print('exit context')
複製程式碼

當一個物件同時實現了__enter__和__exit__方法，那麼這個物件就是支援上下文管理的物件。

支援上下文管理的物件可以使用以下語句塊進行處理：

with obj:
    pass
複製程式碼

比如

with Context():
    print('do somethings')
print('out of context')

# 輸出
enter context
do somethings
exit context
out of context
複製程式碼

所以，with開啟一個語句塊， 執行這個語句塊之前，會執行 __enter__方法， 執行這個語句塊之後，會執行__exit__ 方法，也就是說在這個語句塊的前後會執行一些操作，因此也叫上下文。

• 即使with塊丟擲異常，__enter__和__exit__也會被執行，所以上下文管理是安全的。

with Context():
    raise Exception()

enter context
exit context
---------------------------------------------------------------------------
Exception                                 Traceback (most recent call last)
<ipython-input-126-c1afee4bfdab> in <module>()
      1 with Context():
----> 2     raise Exception()

Exception: 
複製程式碼

• 即使with塊中主動退出直譯器， __enter__ 和__exit__也能保證執行

import sys

with Context():
   sys.exit()

enter context
exit context
An exception has occurred, use %tb to see the full traceback.

SystemExit

/home/clg/.pyenv/versions/3.5.2/envs/normal/lib/python3.5/site-packages/IPython/core/interactiveshell.py:2889: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.
  warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)
複製程式碼

with塊的as字句

• as子句可以獲取__enter__方法的返回值

class Context:
    def __enter__(self):
        print('enter context')
        return self  # __enter__函式的返回值

    def __exit__(self, *args, **kwargs):
        print('exit context')

ctx = Context()
with ctx as c:
    print(id(ctx))
    print(id(c))
    print(c)

# 輸出結果
enter context
140541332713712
140541332713712
<__main__.Context object at 0x7fd2543670f0>
exit context
複製程式碼

__enter__方法

• __enter__方法的返回值可以被as字句捕獲到

• __enter__ 除self之外，不帶任何引數

class Context:
    def __enter__(self, *args, **kwargs):
        print('enter context')
        print(args)
        print(kwargs)


    def __exit__(self, *args, **kwargs):
        print('exit context')

# 輸出
enter context
()
{}
exit context
複製程式碼

args和kwargs都是空的，因此上下文管理的時候__enter__函式除self外，不帶任何引數。

__exit__方法

• __exit__的返回值，沒有辦法獲取到，如果with塊中丟擲異常 __exit__返回False的時候，會向上丟擲異常，返回True， 會遮蔽異常

class Context:
    def __enter__(self):
        print('enter context')

    def __exit__(self, *args, **kwargs):
        print('exit context')
        return 'haha'

with Context() as c:
    print(c)

# 輸出
enter context
None
exit context
複製程式碼

• __exit__的三個引數 異常型別， 異常， traceback

class Context:
    def __enter__(self):
        print('enter context')

    def __exit__(self, *args, **kwargs):
        print('exit context')
        print(args)
        print(kwargs)

with Context():
    pass

# 輸出
enter context
exit context
(None, None, None)
{}
複製程式碼

args輸出三個None，表示三個位置引數，kwargs為空，表示沒有關鍵字引數。

with Context():
    raise Exception()

enter context
exit context
(<class 'Exception'>, Exception(), <traceback object at 0x7f28608fdc88>)
{}
---------------------------------------------------------------------------
Exception                                 Traceback (most recent call last)
<ipython-input-145-c1afee4bfdab> in <module>()
      1 with Context():
----> 2     raise Exception()

Exception: 
複製程式碼

• 使用變數接受__exit__的三個引數：exc_type,exc_value,traceback

class Context:
    def __enter__(self):
        print('enter context')

    def __exit__(self, exc_type, exc_value, traceback):
        print('exit context')
        print('exception type: {}'.format(exc_type))
        print('exception value: {}'.format(exc_value))
        print('exception traceback: {}'.format(traceback))
        return True

with Context():
    raise TypeError('hahaha')

# 輸出
enter context
exit context
exception type: <class 'TypeError'>
exception value: hahaha
exception traceback: <traceback object at 0x7fd257c18608>
複製程式碼

上下文管理的應用場景

with 語句適用於對資源進行訪問的場合，確保不管使用過程中是否發生異常都會執行必要的“清理”操作，釋放資源，比如檔案使用後自動關閉、執行緒中鎖的自動獲取和釋放等。即凡是在程式碼塊前後插入程式碼的場景統統適用

1. 資源管理
2. 許可權驗證

以下以計時器為例

from functools import wraps
class Timeit:
    def __init__(self, fn=None):
        wraps(fn)(self)

    def __call__(self, *args, **kwargs):
        start = datetime.datetime.now()
        ret = self.__wrapped__(*args, **kwargs)
        cost = datetime.datetime.now() - start
        print(cost)
        return ret

    def __enter__(self):
        self.start = datetime.datetime.now()

    def __exit__(self, *args):
        cost = datetime.datetime.now() - self.start
        print(cost)

with Timeit():
    z = 3 + 8  # 輸出0:00:00.000037

@Timeit
def add(x, y):
    return x + y

add(3, 8)  # 輸出0:00:00.000044  返回11
複製程式碼

總共實現了兩種計時方式，既可以對語句塊計時，也可以對函式計時。

contextmanager的使用

contextlib是個比with優美的東西，也是提供上下文管理機制的模組，它是通過Generator裝飾器實現的，不再是採用__enter__和__exit__。contextlib中的contextmanager作為裝飾器來提供一種針對函式級別的上下文管理機制。

import contextlib


@contextlib.contextmanager
def context():
    print('enter context') # 初始化部分 相當於 __enter__ 方法
    try:
        yield 'haha' # 相當於__enter__的返回值
    finally:
        print('exit context') # 清理部分， 相當於 __exit__ 方法


with context() as c:
    print(c)
    raise Exception()

# 輸出
enter context
haha
exit context
---------------------------------------------------------------------------
Exception                                 Traceback (most recent call last)
<ipython-input-189-4c1dae6b647a> in <module>()
      1 with context() as c:
      2     print(c)
----> 3     raise Exception()

Exception: 
複製程式碼

yield後面必須配合finally使用，否則如果丟擲異常，程式不會執行yield後面的部門，也就是不會執行__exit__部分。

反射

python的反射，核心本質其實就是利用字串的形式去物件（模組）中操作（查詢/獲取/刪除/新增）成員，就是一種基於字串的事件驅動！

關於模組的python反射以及反射機制分析參見：python反射機制深入分析

以下主要分析類物件的反射機制

​

getattr setattr hasattr

三個函式的原型：

1. getattr：getattr(object, name[, default]) -> value。getattr(x, 'y')等效於x.y
2. setattr：setattr(obj, name, value, /)。setattr(x, 'y', v)等效於x.y = v
3. hasattr：hasattr(obj, name, /)

主要作用是通過物件的成員名稱獲取物件的成員

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def print(self, x, y):
        print(x, y)

p = Point(3, 5)
p.__dict__['x'] # 返回3， 對於屬性來說，可以通過 __dict__ 獲取
getattr(p, 'print')(3, 5) # 成員方法無法通過__dict__獲取，但是可以通過getattr函式獲取 # p.print(3, 5)
getattr(p, 'x') # getattrr 也可以獲取到屬性
setattr(p, 'haha', 'abcd') # p.haha = 'abcd'，給物件p增加屬性haha
p.haha  # 返回abcd
hasattr(p, 'print')  # 返回True

複製程式碼

setattr的物件是例項，如果要給例項動態增加方法，需要先把函式轉化為方法，轉化的方法如下：

import types

def mm(self):
    print(self.x)

setattr(p, 'mm', types.MethodType(mm, p))  # 將mm函式轉化為物件p的方法之後，再給p增加
p.mm()  # 輸出3
複製程式碼

使用getattr setattr hasattr 實現一個命令路由器：

class Command:
    def cmd1(self):
        print('cmd1')
    def cmd2(self):
        print('cmd2')
    def run(self):
        while True:
            cmd = input('>>>').strip()
            if cmd == 'quit':
                return
            getattr(self, cmd, lambda :print('not found cmd {}'.format(cmd)))()

command = Command()
command.run()

# 輸出 
>>>cmd1
cmd1
>>>cmd2
cmd2
>>>cmd3
not found cmd cmd3
>>>quit
複製程式碼

__getattr__ __setattr__ __delattr__

• 當一個類定義了__getattr__方法時，如果訪問不存在的成員，會呼叫__getattr__方法

class A:
    def __init__(self):
        self.x = 3

a = A()
a.x  # 返回3
a.y  # 如果沒有實現__getattr__方法，當訪問不存在的成員時會報錯
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-228-cc7049c6eeec> in <module>()
----> 1 a.y

AttributeError: 'A' object has no attribute 'y'
複製程式碼

增加__getattr__方法

class A:
    def __init__(self):
        self.x = 3

    def __getattr__(self, name):
        return 'missing property {}'.format(name)

a = A()
a.x  # 返回3
a.y  # 返回'missing property y'。即訪問不存在的成員，會呼叫__getattr__方法
複製程式碼

• 當一個類實現了__setattr__時， 任何地方對這個類的物件增加屬性，或者對現有屬性賦值，都會呼叫__setattr__

class A:
    def __init__(self):
        self.x = 3

    def __setattr__(self, name, value):
        print('set {} to {}'.format(name, value))
        setattr(self, name, value)

a = A()
a.x  # 返回3
a.y = 5  # 輸出set y to 5
複製程式碼

• 當一個類實現了__delattr__ 方法時，刪除其例項的屬性，會呼叫此方法

class A:
    def __init__(self):
        self.x = 3

    def __delattr__(self, name):
        print('you cannot delete property: {}'.format(name))

a = A()
a.x  # 返回3
del a.x  # 輸出you cannot delete property: x
複製程式碼

最後多說一句，小編是一名python開發工程師，這裡有我自己整理了一套最新的python系統學習教程，包括從基礎的python指令碼到web開發、爬蟲、資料分析、資料視覺化、機器學習等。想要這些資料的可以進裙930900780領取。

本文章素材來源於網路，如有侵權請聯絡刪除。