一、異常處理
1.異常處理介紹：
異常是錯誤發生的信号，一旦程式出錯就會産生一個異常，如果該異常沒有被應用程式處理，那麼該異常就會被抛出來，程式執行随之停止
2.異常通常包含三個部分
1.traceback異常的追蹤資訊
2.異常的類型
3.異常的資訊
3.為何使用異常處理：
避免程式因為異常而奔潰，是以在應用程式中應該對異常進行處理，進而增強程式的健壯性
4.自定義處理異常的結構
1) try: except Exception as e:
2) try: except Exception: else:
3) try: except Exception: else: finally:
4) try: except...
5) try: finally:
else必須放到後面，else的代碼塊會在沒有異常的情況下運作
finally：無論被檢測的代碼有無異常，都會運作，通常用于資源回收（列如 檔案操作中途代碼錯誤 可以在finally中定義回收代碼） 自定義異常：（防止資源被無限占用，自定義規範）
"""
class MyException(BaseException):
# 構造自定義異常類對象
def __init__(self):
pass
# 格式化異常資訊
def __str__(self):
pass
"""
自定義異常必須要繼承
Exception：可以比對任意類型的異常 被稱為萬能異常類型 
AttributeError 試圖通路一個對象沒有的樹形，比如foo.x，但是foo沒有屬性x
IOError 輸入/輸出異常；基本上是無法打開檔案
ImportError 無法引入子產品或包；基本上是路徑問題或名稱錯誤
IndentationError 文法錯誤（的子類） ；代碼沒有正确對齊
IndexError 下标索引超出序列邊界，比如當x隻有三個元素，卻試圖通路x[5]
KeyError 試圖通路字典裡不存在的鍵
KeyboardInterrupt Ctrl+C被按下
NameError 使用一個還未被賦予對象的變量
SyntaxError Python代碼非法，代碼不能編譯(個人認為這是文法錯誤，寫錯了）
TypeError 傳入對象類型與要求的不符合
UnboundLocalError 試圖通路一個還未被設定的局部變量，基本上是由于另有一個同名的全局變量，
導緻你以為正在通路它
ValueError 傳入一個調用者不期望的值，即使值的類型是正确的 一些常用異常
主動抛出異常：raise Exception（msg）
斷言（了解）
# print('上半部分，生産資料')
# l = [1,2,3,4,5]
#
# # if len(l)!=5:
# # raise TypeError('清單的長度必須是5')
# assert len(l) ==5 #if的簡化版本
# print('下半部分，處理資料') 二、元類
1.元類介紹：
源自于一句話，在python中，一切皆對象，而對象都是由類執行個體化得到的。簡單的說 元類就是産生類的類
定義了一個類，類裡有一個構造器和方法
class OldboyTeacher:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def score(self):
print('%s'%self.name)
tea1 = OldboyTeacher('egon',18,'male')
print(type(tea1))#<class '__main__.OldboyTeacher'>
print(type(OldboyTeacher))#<class 'type'> 從上面的代碼中我們可以看出，對象teal調用OldboyTeacher類得到的，一切皆對象，OldboyTeacher也是一個對象，隻要是對象，都是調用一個類的執行個體化方法得到的，即OldboyTeacher=元類，OldboyTeacher類的類型為type，内置元類就是type
class關鍵字建立自定義類的底層工作原理，分為四步：
1.先拿到類名：OldboyTeacher
2.再拿到類的基類們：object
3.然後拿到類的名稱空間（執行類體代碼，将産生的名字放到類的名稱空間，也就是一個字典裡）
4.調用元類來執行個體化得到自定義的類：OldboyTeacher = type（OldboyTeacher，（object，）{...}）
自定義類的三個關鍵組成部分：
1.類名
2.類的基類
3.類的名稱空間
不依賴class類建立一個自定義類：
#1.拿到類名
clss_name = 'OldboyTeacher'
# 2.拿到類的基類們：（object）
class_bases=(object,)
# 3.拿到類的名稱空間
class_dic ={}
class_body ="""
school ='Oldboy'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def score(self):
print('%s is scoring' %self.name)
"""
exec(class_body,{},class_dic)#可以把exec指令的執行當成是一個函數的執行，會将執行期間産生的名字存放于局部名稱空間中
print(class_dic)#{'school': 'Oldboy', '__init__': <function __init__ at 0x00000209D705C268>, 'score': <function score at 0x00000209D7208B70>}
# 4.調用type得到自定義的類
OldboyTeacher = type(clss_name,class_bases,class_dic)
tea1 = OldboyTeacher('egon',18,'male')
print(tea1.__dict__)#{'name': 'egon', 'age': 18, 'sex': 'male'} 補充exec：exec（）
#參數一：包含一系列python代碼的字元串
#參數二：全局作用域（字典形式），如果不指定，預設為globals()
#參數三：局部作用域（字典形式），如果不指定，預設為locals()
#可以把exec指令的執行當成是一個函數的執行，會将執行期間産生的名字存放于局部名稱空間中 将class_body中産生的名稱空間都存放在class_dic的清單中
2.自定義元類來控制類的産生
注：隻有繼承了type類的類才能稱之為自定義的元類，否則就是一個普通的類
以一個例子來說明使用方法：
#1.控制類名 必須是駝峰體
#2.類體必須有文檔注釋，且不能為空
class Mymeta(type):#但凡繼承了type的類的類才能稱之為自定義的元類，否則就是一個普通的類
def __init__(self,class_name,class_bases,class_dic):
if class_name.islower():
raise TypeError('類名必須使用駝峰體')
doc =class_dic.get('__doc__')
if doc is None or len(doc) ==0 or len(doc.strip('\n '))==0:
raise TypeError('類體中必須有文檔注釋，且不能為空')
class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta（'OldboyTeacher',(object,)，{...}）
'''
'''
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def score(self):
print('%s'%self.name) 3.自定義元類來控制類調用過程
對象之是以可以調用，是因為對象的類中有一個函數__call__，那麼OldboyTeacher也是對象的話，肯定也是定義了一個__call__方法
我們來看看__call__中做了哪些事：
class Mymeta(type):#但凡繼承了type的類的類才能稱之為自定義的元類，否則就是一個普通的類
def __call__(self, *args, **kwargs):#self = OldboyTeacher這個類，args=（'egon',18,'male）,kwargs={}
#1.先産生一個空對象
tea_obj = self.__new__(self) # tea_obj是OldboyTeacher這個類的對象
#2.先執行__init__方法，完成對象的初始屬性操作
self.__init__(tea_obj,*args,**kwargs)
# 3.傳回初始化好的那個對象
return tea_obj
class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta（'OldboyTeacher',(object,)，{...}）
school = 'Oldboy'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def score(self):
print('%s'%self.name)
tea1 = OldboyTeacher('egon',18,'male')#會觸發OldboyTeacher的類，即元類中的__call__ 回顧一下類的執行個體化步驟：
1.先産生一個空對象
2.執行__init__方法，完成對象的初始化屬性操作
3.傳回初始化好的那個對象
4.屬性查找
class Mymeta(type):
# n=444
def __call__(self, *args, **kwargs): #self=OldboyTeacher這個類
# 1. 先産生一個空對象
tea_obj = self.__new__(self) # tea_obj是OldboyTeacher這個類的對象
# print(self.__new__ is object.__new__)
# tea_obj=object.__new__(self)
# 2. 執行__init__方法,完成對象的初始屬性操作
self.__init__(tea_obj, *args, **kwargs)
# 3. 傳回初始化好的那個對象
return tea_obj
class Bar:
# n = 33
pass
class Foo(Bar):
# n = 222
pass
class OldboyTeacher(Foo, metaclass=Mymeta): # OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
# n = 111
school = 'Oldboy'
def __init__(self, name, age, sex):
self.name = name #None.name='egon'
self.age = age
self.sex = sex
def score(self):
print('%s is scoring' % self.name)
def __new__(cls, *args, **kwargs):
# print('=====>')
return super().__new__(cls)
tea1 = OldboyTeacher('egon', 18, 'male')
# print(tea1)
print(tea1.__dict__)
# print(OldboyTeacher.n)
# print(object.__new__) View Code
#查找順序：
#1、先對象層：OldoyTeacher->Foo->Bar->object
#2、然後元類層：Mymeta->type
總結，Mymeta下的__call__裡的self.__new__在OldboyTeacher、Foo、Bar裡都沒有找到__new__的情況下，會去找object裡的__new__，而object下預設就有一個__new__，是以即便是之前的類均未實作__new__,也一定會在object中找到一個，
根本不會、也根本沒必要再去找元類Mymeta->type中查找__new__但我們還是推薦在__call__中使用self.__new__（self）去創造空對象，因為這種方式會檢索三個類OldboyTeacher->Foo->Bar,而object.__new__則是直接跨過了他們三個
焚膏油以繼晷，恒兀兀以窮年。