前天的定制類的__call__通過小佳揚(yáng)的一語驚醒夢中人，就是把對象函數(shù)化了。
感覺有點(diǎn)囫圇吞棗，看完教程后要還好好地歸納下。

定義常量時候使用，例如定義月份。

JAN = 1
FEB = 2
MAR = 3
...
NOV = 11
DEC = 12

但是此時的類型是int。
通過Python提供的Enum類來實(shí)現(xiàn)為枚舉類型定義一個class類型。

from enum import Enum

Month = Enum("Month", ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"))

這樣就獲得了Month類型的枚舉類，可以使用Month.Jan來引用一個常量，或者枚舉成員。

for name, member in Month.__members__.items():
    print(name, "=>", member, ",", member.value)

value屬性是自動賦給成員的值，默認(rèn)從1開始計(jì)數(shù)。

如果需要更精確地控制枚舉類型，可以從Enum派生出自定義類。

from enum import Enum, unique

@unique
class Weekday(Enum):
    Sun = 0 # Sun的value被設(shè)定為0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

@unique裝飾器可以幫助我們檢查保證沒有重復(fù)值。

動態(tài)語言和靜態(tài)語言最大的不同，就是函數(shù)和類的定義，不是編譯時定義的，而是運(yùn)行時動態(tài)創(chuàng)建的。
type()函數(shù)可以查看類型或者變量的類型，class的類型就是type。
而且type()函數(shù)既可以返回一個對象的類型，又可以創(chuàng)建出新的類型。

#用type()函數(shù)創(chuàng)造出hello類
def fn(self, name="world"): # 先定義函數(shù)
     print("Hello, %s." % name)
Hello = type("Hello", (object,), dict(hello=fn))

用type()創(chuàng)建類，需要依次傳入三個參數(shù)：

class的名稱；

繼承的父類集合，注意Python支持多重繼承，如果只有一個父類，別忘了tuple的單元素寫法；

class的方法名稱與函數(shù)綁定，這里我們把函數(shù)fn綁定到方法名hello上

這樣和直接定義class的寫法沒有差異，但是這樣的話就可以在代碼運(yùn)行的過程中，動態(tài)創(chuàng)建類，這和靜態(tài)語言有很大不同。

除了使用type()動態(tài)創(chuàng)建類以外，要控制類的創(chuàng)建行為，還可以使用metaclass。
先定義metaclass，就可以創(chuàng)建類，最后創(chuàng)建實(shí)例。
據(jù)說很難理解的魔術(shù)代碼，還是認(rèn)真的努力理解下吧！
看下大牛的代碼！
這個metaclass可以給我們自定義的MyList增加一個add方法：
定義ListMetaclass，按照默認(rèn)習(xí)慣，metaclass的類名總是以Metaclass結(jié)尾，以便清楚地表示這是一個metaclass。

# metaclass是類的模板，所以必須從`type`類型派生：
class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs["add"] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)

有了ListMetaclass，我們在定義類的時候還要指示使用ListMetaclass來定制類，傳入關(guān)鍵字參數(shù)metaclass：

class MyList(list, metaclass=ListMetaclass):
    pass

這樣MyList創(chuàng)建的時候，需要通過ListMetaclass.__new__()來創(chuàng)建。
__new__()方法接收到的參數(shù)依次是：

當(dāng)前準(zhǔn)備創(chuàng)建的類的對象；

類的名字；

類集成的父類集合；

類的方法集合。

而MyList()可以調(diào)用add方法，但普通list()就沒有。
list即類的對象。
這個復(fù)雜的有點(diǎn){{BANNED}}的定義方式，在一些場景下，例如ORM的編寫中，會很有用。

ORM全稱“Object Relational Mapping”，即對象-關(guān)系映射，就是把關(guān)系數(shù)據(jù)庫的一行映射為一個對象，也就是一個類對應(yīng)一個表，這樣，寫代碼更簡單，不用直接操作SQL語句。

這塊有點(diǎn)復(fù)雜，雖然看懂了，但是還要好好琢磨下

高級語言都內(nèi)置了一套try...except...finally...的錯誤處理機(jī)制，Python小可愛也有。

當(dāng)有錯誤時候，會打斷代碼的進(jìn)行，跳轉(zhuǎn)到except處，一旦有finally的話就一定會執(zhí)行,無論有沒有發(fā)生錯誤。
可以有多個except獲取不同的錯誤，但是注意父類和子類的問題，如果一旦包括了父類錯誤，子類所在的except就不會被執(zhí)行。
except后也可以加else語句，當(dāng)沒有錯誤發(fā)生的時候，會執(zhí)行else語句。

Python所有的錯誤都是從BaseException類派生的，常見的錯誤類型和繼承關(guān)系有這些：
https://docs.python.org/3/lib...

也就是說，不需要在每個可能出錯的地方去捕獲錯誤，只要在合適的層次去捕獲錯誤就可以了。這樣一來，就大大減少了寫try...except...finally的麻煩。

如果錯誤沒有被捕獲，它就會一直往上拋，最后被Python解釋器捕獲，打印一個錯誤信息，然后程序退出。
所以找錯誤棧的時候，一定要找到準(zhǔn)確的最里面那層。

等Python解釋器打印錯誤棧的信息，程序也結(jié)束了。
既然可以捕獲，就在捕獲的同時打印錯誤信息并分析原因，讓程序繼續(xù)下去。
Python內(nèi)置的logging可以很容易的記錄錯誤信息。

# err_logging.py

import logging

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar("0")
    except Exception as e:
        logging.exception(e)

main()
print("END")

這樣打印完錯誤信息后還會打印END,即運(yùn)行了后續(xù)的代碼。
將logging通過配置記錄到日志文件中方便后續(xù)的排查。

捕獲的錯誤其實(shí)是錯誤class的一個實(shí)例，錯誤也是需要定以后才能拋出然后被捕獲到的。
如果要拋出錯誤，首先根據(jù)需要，可以定義一個錯誤的class，選擇好繼承關(guān)系，然后，用raise語句拋出一個錯誤的實(shí)例.

# err_raise.py
class FooError(ValueError):
    pass

def foo(s):
    n = int(s)
    if n==0:
        raise FooError("invalid value: %s" % s)
    return 10 / n

foo("0")

另一種拋出錯誤的例子如下。

# err_reraise.py

def foo(s):
    n = int(s)
    if n==0:
        raise ValueError("invalid value: %s" % s)
    return 10 / n

def bar():
    try:
        foo("0")
    except ValueError as e:
        print("ValueError!")
        raise   #錯誤又被拋出

bar()

這種方式也很常見，在拋出問題后繼續(xù)拋回上一級，由頂曾調(diào)用者進(jìn)行處理。
raise語句如果不帶參數(shù)，就會把當(dāng)前錯誤原樣拋出。
此外，在except中raise一個Error，還可以把一種類型的錯誤轉(zhuǎn)化成另一種類型。

用print()打印有問題的變量
麻煩在還得刪掉或注釋掉相應(yīng)語句

凡是可以用print打印的地方，都可以用asset斷言來代替。

def foo(s):
    n = int(s)
    assert n != 0, "n is zero!"#判斷此處n!=0是否為True,如果非則拋出AssertionError
    return 10 / n

def main():
    foo("0")

可以在啟動Python解釋器的時候關(guān)閉assert

$python -0

同樣是替換print,logging不會拋出錯誤，而且可以輸出到文件。

import logging
logging.basicConfig(level=logging.INFO)

s = "0"
n = int(s)
logging.info("n = %d" % n)
print(10 / n)

這就是logging的好處，它允許你指定記錄信息的級別，有debug，info，warning，error等幾個級別，當(dāng)我們指定level=INFO時，logging.debug就不起作用了。同理，指定level=WARNING后，debug和info就不起作用了。這樣一來，你可以放心地輸出不同級別的信息，也不用刪除，最后統(tǒng)一控制輸出哪個級別的信息。
logging的另一個好處是通過簡單的配置，一條語句可以同時輸出到不同的地方，比如console和文件。

啟動Python的調(diào)試器pdb，讓程序以單步方式運(yùn)行。

這個方法也是用pdb，但是不需要單步執(zhí)行，我們只需要import pdb，然后，在可能出錯的地方放一個pdb.set_trace()，就可以設(shè)置一個斷點(diǎn)