Python成長之路 面向對象編程進階與異常處理

面向對象編程進階的知識點

一、靜態方法

二、類方法

三、屬性

四、特殊成員方法

五、反射

六、異常處理

1、靜態方法

與類無關，只能由類調用，不可以訪問類中任何屬性和方法。無默認參數，與類有關聯的就是經過類來調用該方法

class Foo(object):

    def __init__(self,name):
        self.name = name

    def general_func(self):
        print('普通方法1')

    def general_func2(self):
        self.general_func()
        print('普通方法2')

    @staticmethod
    def stat_func(arg):
        # print(arg.name) 不能夠調用類中屬性和方法
        print('靜態放法')

# f = Foo('beijing')
# f.general_func2()
# 普通方法調用能夠調用類中的方法和屬性

# Foo.stat_func('name') 正確的調用方式
        
# f = Foo('beijing')
# f.stat_func(f)
# 上面這種方法能夠調用類中的方法和屬性，由於傳進去了實列把他們關聯起來了
# 當靜態放法不須要傳參的時候不管如何都調用不了類中的屬性和方法
# 上面的方法不建議使用，只建議經過類來調用靜態方法，而不是經過實例。

　　

2、類方法

由類調用，至少有一個cls參數。只能訪問類中的變量。不可以訪問實例變量

class Foo(object):
    country = 'china'

    def __init__(self,name):
        self.name = name

    def general_func(self):
        print('普通方法1')

    def general_func2(self):
        print(self.name)
        self.general_func()
        print('普通方法2')

    @classmethod
    def class_func(cls):
        print(cls.country)
        # print(cls.name) 不可以調用構造函數中的變量
        cls.general_func( 'arg' )  # 必需要傳參才能調用類種方法
        print('類方法')

Foo.class_func()  # 類方法的調用

　　

3、屬性

屬性的定義分爲兩種方式：

• 裝飾器 即：在方法上應用裝飾器
• 靜態字段 即：在類中定義值爲property對象的靜態字段

裝飾器方式：在類的普通方法上應用@property裝飾器

經典類具備一種@property裝飾器

而新式類具備三種@property裝飾器分別爲

• @property :獲取
• @方法名.setter ：修改
• @方法名.deleter ：刪除

class Fruit(object):
    def __init__(self):
        self.original_price = 15

    @property
    def apple_price(self):
        new_price = self.original_price
        return new_price

    @apple_price.setter
    def apple_price(self,value):
        self.original_price = value

    @apple_price.deleter
    def apple_price(self,value):
        del self.original_price

appl = Fruit()          # 實例
print(appl.apple_price) # 輸出蘋果的價格 15
appl.apple_price = 20   # 修改蘋果的價格
print(appl.apple_price) # 輸出蘋果的價格 20
del appl.apple_price    # 刪除蘋果的價格
print(appl.apple_price) # 由於刪除蘋果價格因此會報錯

　　

靜態字段方式，建立值爲property對象的靜態字段

靜態字段的方式穿件屬性時，經典類和新式類無區別，都含有的屬性是獲取、修改、刪除

property的構造方法中有個四個參數

• 第一個參數是方法名，調用 對象.屬性 時自動觸發執行方法
• 第二個參數是方法名，調用 對象.屬性 ＝ XXX 時自動觸發執行方法
• 第三個參數是方法名，調用 del 對象.屬性 時自動觸發執行方法
• 第四個參數是字符串，調用 對象.屬性.__doc__ ，此參數是該屬性的描述信息

class Fruit(object):
    def __init__(self):
        self.original_price = 15

    def get_price(self):
        new_price = self.original_price
        return new_price

    def set_price(self,value):
        self.original_price = value

    def del_price(self,value):
        del self.original_price

    PEOCE = property(get_price,set_price,del_price,'價格變更')#對應的四個參數

appl = Fruit()          # 實例
print(appl.PEOCE) # 輸出蘋果的價格 15
appl.PEOCE = 20   # 修改蘋果的價格
print(appl.PEOCE) # 輸出蘋果的價格 20
del appl.PEOCE    # 刪除蘋果的價格
print(appl.PEOCE) # 由於刪除蘋果價格因此會報錯

　

這個兩種方式中注意第一種方式新式類和經典類有區別，而第二種方式新式類和經典類都同樣。一樣要注意兩種方式的寫法不一樣。

4、特殊成員

一、__doc__  表示類的描述信息

class Animal(object):
    """
    這個類是關於動物描述
    """
    pass

print(Animal.__doc__) # 這個類是關於動物描述

　　

二、__init__ 構造函數，經過對類的實例化時(即建立對象)，自動觸發執行__init__函數

三、__del__   析構函數，當實例化的對象在內存中被釋放時，自動觸發執行__del__

四、__module__ 和 __class__

__module__表示當前操做的實例化對象在那個模塊中

__class__ 表示當前操做的1對象的類是什麼

五、__dict__ 查看類或對象中全部的成員

class People(object):
    nationality = 'china'

    def __init__(self,name,sex):
        self.name = name
        self.sex = sex

    def run(self):
        print('能夠奔跑')

    def sleep(self):
        print('可以睡覺')

print(People.__dict__) # {'__weakref__': <attribute '__weakref__' of 'People' objects>, '__module__': '__main__', 'nationality': 'china', '__dict__': <attribute '__dict__' of 'People' objects>, '__doc__': None, '__init__': <function People.__init__ at 0x0000029AD21E11E0>, 'sleep': <function People.sleep at 0x0000029AD21E12F0>, 'run': <function People.run at 0x0000029AD21E1268>}


people2 = People('Tom','M')

print(people2.__dict__) # {'name': 'Tom', 'sex': 'M'}

　　

六、__call__ 在對象後面加括號，自動執行 __call__方法

七、__str__  若是一個類定義了__str__方法，那麼在打打印實例化對象時，默認輸出該方法的返回值

class People(object):

    def __str__(self):
        return 'Tom'


people = People()
print(people) # ‘Tom’

5、反射

def eat():
    print('能夠吃了')


class Fruits(object):

    def __init__(self, name):
        self.fruits_name = name

    def juice(self, name):
        print('使用%s榨汁給%s喝'%(self.fruits_name,name))

fruits = Fruits('apple')

choice = input('>>>:').strip()

if hasattr(fruits, choice):  # getattr判斷一個對象obj裏面是否有對應的name_str字符串的方法，有就返回True否返回False
    # g = getattr(fruits, choice)  getattr根據字符串獲取對應obj中方法的地址
    # g('Tom') #調用該方法
    # print(fruits.fruits_name)  # 結果爲apple
    # setattr(fruits, choice, 'tangerine')  # 當判斷是一個屬性的時候咱們能夠改變屬性的值
    # print(fruits.fruits_name)  # 結果爲tangerine
    delattr(fruits, choice)
    print(fruits.fruits_name)  # 會報錯由於刪除掉了fruits_name這個屬性
else:
    # setattr(fruits, choice, eat)  # 把外面的方法關聯到類中能夠在類中調用了
    # getattr(fruits, choice)()  # 這個就是在類中調用關聯的方法若是關聯的方法有參數那麼就要傳入參數
    setattr(fruits, choice, 22)  # 傳入一個屬性到對象中
    print(getattr(fruits, choice)) #調用對象中的屬性

　　

動態導入模塊

import importlib

metaclass = importlib.import_module('import_lib.metaclass')
print(metaclass.C().name)


# import_lib = __import__('import_lib.metaclass')
# c = import_lib.metaclass.C()
# print(c.name)
# 第一個導入的是metaclass模塊 而第二種導入的是import_lib這個包
#官方推薦使用第一個

　　

6、異常處理

爲了使程序出現bug的時候不講錯誤的提示信息顯示給用戶，而傳給用戶一個提示的頁面。

異常處理的通常格式爲

try：

　　pass

except Exception as e:

　　pass

下面是一個異常處理的例子

dic = {'name': 'Tom', 'age': 18}
try:
    dic['sex']

except KeyError as e:
    print('輸入的鍵%s不存在' %e)

　在寫程序的時候有的時候可能出現不止一種異常咱們就能夠重複使用except來捕獲異常，當咱們全部想到的異常一個都沒有捕獲時咱們可使用except Exception as e    來作最後的捕獲，等還有一些其餘、它關於捕獲的例子

dic = {'name': 'Tom', 'age': 18}
try:
    dic['sex']

except KeyError as e:
    print('輸入的鍵%s不存在' %e)
    
except ValueError as e:
    print(e)
    .
    .
    .
except Exception as  e:  # 萬能的捕獲異常
    print(e)
    
else:
    pass  # 當沒出現錯誤的時候執行這個模塊

finally:
    pass  # 無論有沒有出錯都要執行這個模塊

　　

自定義異常

class CustomException(Exception):

    def __init__(self, msg):
        self.message = msg

    def __str__(self):
        return self.message

try:
    raise CustomException('自定義異常')
except CustomException as e:
    print(e)

　　

斷言語句

斷言通常用於測試，若是測試結果爲Flas，將拋出AssertionError異常

str = 'abc'
assert type(str) is dict
# 拋出AssertionError異常