面向對象第四講

面向對象第四講

mixins機制

分主類和輔類 繼承輔類就有輔類的功能，不影響子類的使用

命名方式， 以Mixin，able， 爲結尾

輔類在主類的左邊

class Vehicle():
    def run(self):
        pass

    def driver(self):  # 駕駛員
        pass


class FlyMixin():
    def fly(self):
        pass


class Car(Vehicle):
    pass


class Automobile(Vehicle):  # 汽車
    pass


class Airplane(FlyMixin, Vehicle):  # 飛機
    pass

"""
如上代碼，，汽車，轎車，飛機都有 Vehicle這個類的屬性，可是飛機有飛的屬性，因此把飛這個屬性單獨拿出來設置成輔類
"""

內置函數

內置函數就是不用去調用，當知足一些條件後自動執行的代碼，內置函數有不少，這裏只列舉幾個經常使用的

1. str

   class Student():
       def __init__(self, name, age):
           self.name = name
           self.age = age
   
       def __str__(self):
           print('打印對象的時候會自動觸發這個函數的運行，返回值必須是一個字符串')
           return f'{self.name}, {self.age}'
   
   obj = Student('egon', 10)
   print(obj)
   
   ========================================>
   打印對象的時候會自動觸發這個函數的運行，返回值必須是一個字符串
   egon, 10
   
   
   """
   __str__這個函數只有在打印對象的時候纔會觸發，並且返回結果只能是字符串。
   若是沒用這個方法，打印對象的結果應該是一個內存地址
   """
   

2. del

   class Student():
       def __init__(self, name, age):
           self.name = name
           self.age = age
   
       def __del__(self):
           print('del is running')
           print('1.手動刪除對象時執行 2.應用程序執行完畢時自動觸發')
   
   obj = Student('egon', 10)
   del obj
   
   print('end ==================')
   
   ============================================>
   del is running
   1.手動刪除對象時執行 2.應用程序執行完畢時自動觸發
   end ==================
   
   
   class Student():
       def __init__(self, name, age):
           self.name = name
           self.age = age
   
       def __del__(self):
           print('del is running')
           print('1.手動刪除對象時執行 2.應用程序執行完畢時自動觸發')
   
   obj = Student('egon', 10)
   
   print('end ==================')
   ==========================================>
   end ==================
   del is running
   1.手動刪除對象時執行 2.應用程序執行完畢時自動觸發
   
   """
   經過上述兩種打印結果得：
   該函數在刪除對象時會自動觸發
   程序運行結束的時候，也會自動觸發這個函數的運行
   """
   

3. isinstance

   class Student():
       def __init__(self, name, age):
           self.name = name
           self.age = age
   
   class Course():
       def __init__(self, name):
           self.name = name
   
   
   obj1 = Course('python')
   obj = Student('egon', 10)
   print(isinstance(obj, Student))
   print(isinstance(obj1, Student))
   
   """
   這個內置函數是用來檢查，這個對象是否是這個類實例出來的
   """
   

4. issubclass

   class People():
       pass
   
   class Student(People):
       def __init__(self, name, age):
           self.name = name
           self.age = age
   
   class Course():
       def __init__(self, name):
           self.name = name
   
   
   print(issubclass(Student, People))
   print(issubclass(Course, People))
   
   """
   此方法是判斷這個類是否是另一個類的子類
   """
   

5. getattr, setattr,delattr

   class Foo:
       x=1
       def __init__(self,y):
           self.y=y
   
       def __setattr__(self, key, value):
           print('----> from setattr')
           # self.key=value #這就無限遞歸了,你好好想一想
           self.__dict__[key]=value #應該使用它
   
   f = Foo(2)
   f.z = 1
   f.x = 111
   print(f.__dict__)
   =====================================>
   ----> from setattr
   ----> from setattr
   ----> from setattr
   {'y': 2, 'z': 1, 'x': 111}
   """
   由上能夠得出，這個方法在實例化，增長，修改數據屬性的時候會自動觸發，
   查看用 self.__dict__[key]=value
   """
   
   class Foo:
       x=1
       def __init__(self,y):
           self.y=y
   
       def __getattr__(self, item):
           print('----> from getattr:你找的屬性不存在')
   
   obj = Foo(1)
   obj.m
   """
   當你訪問的這個屬性不存在的時候會自動觸發該方法
   """
   
   class Foo:
       x = 1
   
       def __init__(self, y):
           self.y = y
   
       def __delattr__(self, item):
           print('----> from delattr')
           # del self.item #無限遞歸了
           self.__dict__.pop(item)     # 這裏彈出的是對象屬性，不是類屬性，由於是對象用__dict__
   
   obj = Foo(111)
   del obj.y
   
   """
   由此能夠得出，該方法在執行刪除屬性的時候會自動觸發
   """
   

6. call

   class Foo:
       def __init__(self):
           pass
   
       def __call__(self, *args, **kwargs):
           print('__call__ is running')
   
   obj = Foo()
   obj()
   """
   這個方法在對象加括號的時候執行
   """
   

反射

反射就是經過字符串操做類屬性或者方法

class Student():
    school = 'sh'
	def __init__(self, name):
		self.name = name
    def func(self):
        print('func is running')


obj = Student('egon')
print(hasattr(obj, 'school'))        # 判斷obj對象有沒有'school'這個屬性，注意這裏是字符串
print(getattr(obj, 'school'))        # 拿到對象obj下面的school屬性
print(getattr(obj, 's', None))       # 若是obj對象下面有這個屬性就拿到，沒用會報錯，不過能夠加第三個參數，沒有這個屬性的時候會返回第三個參數，通常是None
print(getattr(obj, 'func'))          # 拿到obj下面的func函數屬性，拿到的是一個函數的內存地址，加括號能夠調用
getattr(obj, 'func')()

setattr(obj, 'school', 123123234)    # 修改obj對象下面school的值
delattr(obj, 'name')                 # 這個是刪除對象obj下面的name屬性
delattr(Student, 'school')			# 刪除Student類下面的school屬性


由於python一切皆對象，因此試一下模塊是否是也支持這個方法

import time

print(getattr(time, 'time')())

異常

異常就是錯誤發生的信號，當遇到這個信號就會拋出異常，而且此後的代碼不在執行

爲何要用異常：
   增長了程序的可靠性，健壯性

語法：
try:
    # 被監測的代碼1
    # 被監測的代碼1
    # 被監測的代碼1
    # 被監測的代碼1
    # 被監測的代碼1
    pass
except 異常信息1 as e:
    # 捕捉到異常信息
except 異常信息2 as e
# 捕捉到異常信息
except 異常信息3 as e
    # 捕捉到異常信息
except 異常信息4 as e
    pass
except Exception as e:
    pass
else:
    print("當被監測的代碼沒有異常時候執行")
finally：
    print("無論有沒有異常都會執行的")
   

斷言

raise

if 1 < 2:
    raise Exception('異常')
    
"""
用這個方法，能夠返回返回指定異常，來明確地觸發異常， raise後必須是一個異常的類或者是異常的實例,
異常會打印到終端
"""

assert

print(1)
print(2)
assert isinstance(18,int)
assert isinstance(18,str)
print(3)
print(4)

"""
若assert後面的語句成立，則繼續執行，負責在此拋出異常
"""

自定義異常

class Myecxeption(BaseException):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return '異常信息:%s' % self.msg

obj = Myecxeption('自定義的異常')
raise Myecxeption('自定義異常')
# print(obj)

=====================>
__main__.Myecxeption: 異常信息:自定義異常