普通方法：對象和類綁定的過程。

class A:
    def func1(self):pass
    def func2(self):pass
    def func3(self):pass
    def func4(self):pass

a = A()
b = A()
print(A.func1)      # <function A.func1 at 0x00000217A0BE3400>
print(a.func1)      # <bound method A.func1 of <__main__.A object at 0x00000217A0CF9EB8>>
print
 
(b.func1)      # <bound method A.func1 of <__main__.A object at 0x00000217A0CFF080>>

類方法：由於不適用對象內存空間的屬性所以不會將對象和犯法綁在一起。而是將類和方法綁在一起。

class A:
    def func1(self):pass
    @classmethod
    def func2(cls):pass
    def func3(self):pass
    def func4(self):pass

a = A()
b = A()
print(A.func2)      #
 
 <bound method A.func2 of <class ‘__main__.A‘>>
print(a.func2)      # <bound method A.func2 of <class ‘__main__.A‘>>
print(b.func2)      # <bound method A.func2 of <class ‘__main__.A‘>>

#  對象能找到類，類裏面綁著方法。

靜態方法：不是綁定方法，沒有和對象或者類發生任何綁定關系。

class A:
    def func1(self):pass
 

    @classmethod
    def func2(cls):pass
    def func3(self):pass
    @staticmethod
    def func4(self):pass

a = A()
b = A()
print(A.func4)      # <function A.func4 at 0x000002BE409837B8>
print(a.func4)      # <function A.func4 at 0x000002BE409837B8>
print(b.func4)      # <function A.func4 at 0x000002BE409837B8>

#  沒有綁定  : 並沒有 bound method  

isinstance：能夠檢測到繼承關系。判斷一個對象和一個類有沒有血緣關系。isinstance(對象名，類名)。

#  能夠檢測到繼承的關系。
class A:pass
class B(A):pass
class C(B):pass
c = C()
print(isinstance(c,C))      # True
print(isinstance(c,B))      # True
print(isinstance(c,A))      # True

# type 只是單純的判斷類
print(type(c) is C)     # True
print(type(c) is B)     # False
print(type(c) is A)     # False

issubclass：可以查看是否存在繼承關系。

# issubclasss(子類名，父類名) 返回bool值。
class A:pass
class B(A):pass
class C(B):pass
print(issubclass(B,A))      # True
print(issubclass(C,B))      # True
print(issubclass(C,A))      # True

反射：

　　反射的4個內置函數：1，getattr　　2，hasattr　　3，setattr　　4，delattr

　　正常情況下，如果可以拿到這個變量，那麽如有這個變量的字符串形式，就是用反射可以獲取到這個值。

　　使用字符串數據類型的變量名，訪問一個命名空間中的名字。

　　找一個屬性，直接就可以找到這個屬性的值。

　　找一個方法，找到的是這個方法的的內存地址。

class A:
    role = ‘Person‘
    def func(self):
        print(‘*‘)
# ret = input(‘>>>‘)
# a = A()
print(getattr(A,‘role‘))       # 從A的命名空間裏找一個屬性，直接就可以找到這個屬性的值
f = getattr(A,‘func‘);f(1)     # 從A的命名空間找一個方法，找到的是這個方法的內存地址

hasattr()　　判斷一個命名空間中有沒有這個名字。

getattr()　　從命名空間中獲取這個名字對應的值，如果空間裏沒有這個屬性則會報錯。

class A:
    role = ‘Person‘
    def func(self):
        print(‘guxiaobai‘)
ret = input(‘>>>‘)
if hasattr(A,ret):
    f = getattr(A,ret)
    print(f)
    if type(f) is not str:
        f(1)  #  若是函數名則以加括號執行。
# 其次因為是從類中尋找的所以需要傳參數。若是對象中找，則不需要傳參數。
class A:
    role = ‘Person‘
    def func(self):
        print(‘guxiaobai‘)
ret = input(‘>>>‘)
a = A()
if hasattr(a,ret):
    f = getattr(a,ret)
    print(f)
    if type(f) is not str:
        f()

類中的反射：類可以獲取類中的屬性和方法。

class A:
    role = ‘Person‘
    def func(self):
        print(‘guxiaobai‘)

print(hasattr(A,‘role‘))    # True
print(hasattr(A,‘func‘))    # True
ret = input(‘>>>‘)
if hasattr(A,ret):
    print(getattr(A,ret))

class A:                                 
    role = ‘Person‘                      
    def __init__(self):                  
        self.money = 100                 
    def func(self):                      
        print(‘guxiaobai‘)               
a = A()                                  
print(hasattr(a,‘money‘))   # True       
print(getattr(a,‘money‘))   # 100        
getattr(a,‘func‘)()         # guxiaobai 

模塊使用模塊中的名字：

import time     # 一個py文件就是一個模塊
time.time()
print(getattr(time,‘time‘)())

在自己所在的模塊中使用自己的名字：

　　1，import sys　　首先導入sys模塊。

　　2，getattr(sys.modules[‘__main__‘]，名字)

def login():
    print(‘執行login功能‘)
def register():
    print(‘執行register功能‘)

import sys
while True:
    ret = input(‘請輸入你想執行的功能：退出輸入Q/q:‘)
    if ret.upper() == ‘Q‘:
        break
    if hasattr(sys.modules[‘__main__‘],ret):
        getattr(sys.modules[‘__main__‘],ret)()

getattr 一定要和 hasattr 配合使用。

setattr：修改和新建。

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

    def func(self):
        print(‘guqingqiu‘)

a = A(‘顧清秋‘)
print(a.name)       # 顧清秋
setattr(a,‘name‘,‘顧小白‘)         # 已經存在的屬性是修改。
print(a.name)       # 顧小白
print(a.__dict__)       # {‘name‘: ‘顧小白‘}
setattr(a,‘age‘,17)
print(a.__dict__)       # {‘age‘: 17, ‘name‘: ‘顧小白‘}
print(a.age)  # 17      # 不存在的屬性就是新建。

setattr 如果新建方法（只能將不屬於類的方法移入到類中）且格式：setattr(類名，‘方法名’，方法名)因為方法一般不存放在對象中，所以一般是類名，若是用對象調用，則 方法（形參）中必須有一個形參，否則就不需要。

def login():
    print(‘執行login功能‘)
class A:
    def __init__(self,name):
        self.name = name

    def func(self):
        print(‘guqingqiu‘)
a = A(‘顧清秋‘)
print(A.__dict__)
setattr(A,‘login‘,login)
print(A.__dict__)
getattr(A,‘login‘)()       # 外部login()中不需要形參。
getattr(a,‘login‘)()       # 外部login(self)中需要形參,否則會報錯。

delattr：刪除屬性或方法，基本不用。

class A:
    def __init__(self,name):
        self.name = name
    def func(self):
        print(‘guqingqiu‘)
a = A(‘顧清秋‘)
print(a.__dict__)   # {‘name‘: ‘顧清秋‘}
delattr(a,‘name‘)
print(a.__dict__)   # {}

內置方法：

　　　　內置的東西都和內置方法有著千絲萬縷的聯系。

class A:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __len__(self):
        return len(self.__dict__)
a = A(‘alex‘,35,‘不詳‘)
print(a.__len__())  # 3
a.hobby = ‘開車‘
print(a.__len__())  # 4

字典的存儲：hash

# hash 和 __hash__關系
class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __hash__(self):
        return 0       # return 是什麽就是什麽值。
a = A(‘alex‘,35)
print(hash(a))
print(a.__hash__())

python's twenty-third day for me 面對對象進階