python面向對象之反射

1、靜態方法（staticmethod）和類方法（classmethod）

類方法：有個默認參數cls,而且能夠直接用類名去調用，能夠與類屬×××互（也就是可使用類屬性）

靜態方法：讓類裏的方法直接被類調用，就像正常調用函數同樣

類方法和靜態方法的相同點：均可以直接被類調用，不須要實例化

類方法和靜態方法的不一樣點：

　　類方法必須有一個cls參數表示這個類，可使用類屬性

　　靜態方法不須要參數

綁定方法：分爲普通方法和類方法

　　　　　普通方法：默認有一個self對象傳進來，而且只能被對象調用-------綁定到對象

　　　　　 類方法：默認有一個cls對象傳進來，而且能夠被類和對象（不推薦）調用-----綁定到類

非綁定方法：靜態方法：沒有設置默認參數，而且能夠被類和對象（不推薦）調用-----非綁定

import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    # @staticmethod
    # def now():
    #     t=time.localtime()
    #     return Date(t.tm_year,t.tm_mon,t.tm_mday)
    @classmethod         #改爲類方法
    def now(cls):
        t=time.localtime()
        return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪一個類來調用,即用哪一個類cls來實例化
class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)
e=EuroDate.now()
print(e)               #咱們想觸發EuroDate.__str__,此時e就是由EuroDate產生的,結果如咱們所願
'''
輸出結果:
year:2017 month:3 day:3
'''

2、反射

反射：能夠用字符串的方式去訪問對象的屬性，調用對象的方法（可是不能去訪問方法），python中一切皆對象，均可以使用反射。

反射有四種方法:

hasattr：hasattr（object,name）判斷一個對象是否有name屬性或者name方法。有就返回True，沒有就返回False

getattr：獲取對象的屬性或者方法，若是存在則打印出來。hasattr和getattr配套使用

　　　　須要注意的是，若是返回的是對象的方法，返回出來的是對象的內存地址，若是須要運行這個方法，能夠在後面添加一對（）

setattr：給對象的屬性賦值，若屬性不存在，先建立後賦值

delattr：刪除該對象指定的一個屬性

一、對象應用反射

class Foo:
    def __init__(self):
        self.name = 'egon'
        self.age = 51
    def func(self):
        print('hello')
egg = Foo()

print(hasattr(egg,'name'))      #先判斷name在egg裏面存在不存在，結果是True
print(getattr(egg,'name'))      #若是爲True它纔去獲得，結果是egon
print(hasattr(egg,'func'))     #結果是True
print(getattr(egg,'func'))     #獲得的是地址<bound method Foo.func of <__main__.Foo object at 0x0000000001DDA2E8>>
getattr(egg,'func')()        #在這裏加括號才能獲得，由於func是方法，結果是hello

通常用法以下，先判斷是否hasattr，而後取getattr
if hasattr(egg,'func'):
    getattr(egg,'func')()   #結果是hello
else:
    print('沒找到')

二、類應用反射

class Foo:
    f = 123
    @classmethod
    def class_method_dome(cls):
        print('class_method_dome')
    @staticmethod
    def static_method_dome():
        print('static_method_dome')
        
print(hasattr(Foo,'class_method_dome'))         #結果是True
method = getattr(Foo,'class_method_dome')
method()                               #結果是class_method_dome

print(hasattr(Foo,'static_method_dome'))         #結果是True
method1 = getattr(Foo,'static_method_dome')
method1()                              #結果是static_method_dome

三、模塊應用反射

# 1.導入其餘模塊引用

import mymodule
print(hasattr(mymodule,'test'))
getattr(mymodule,'test')()


p = getattr(mymodule,'test')
p()                              #至關於上面getattr(mymodule,'test')()

# 2.在本模塊中應用反射

def demo1():
    print('hello')
import sys
module_obj = sys.modules[__name__]        #至關於'__main__'
print(module_obj)                 #結果是<module '__main__' from 'C:/Users/Administrator/Desktop/test.py'>
print(hasattr(module_obj,'demo1'))       #結果是True
getattr(module_obj,'demo1')()          #結果是hello

導入本身的模塊的例子：

def 註冊():
    print('regiester')
def 登陸():
    print('login')
def 購物():
    pass
print('註冊，登陸，購物')
ret = input('請輸入你要作的操做：')
import sys
my_module = sys.modules[__name__]  #利用sys模塊導入一個本身的模塊
if hasattr(my_module,ret):
    getattr(my_module,ret)()