一、三個內置函數 1、issubclass(a, b) 判斷a類是否是b類的子類 1 class Foo: 2 pass 3 4 class Zi(Foo): 5 pass 6 7 class Sun(Zi): 8 pass 9 print(issubclass(Zi,Foo)) #True 10 ...
一、三個內置函數
1、issubclass(a, b) 判斷a類是否是b類的子類
1 class Foo: 2 pass 3 4 class Zi(Foo): 5 pass 6 7 class Sun(Zi): 8 pass 9 print(issubclass(Zi,Foo)) #True 10 print(issubclass(Zi,Sun)) # Falseissubclass
2、type(對象) 返回該對象的數據類型,精確識別(即不向上相容)
1 class Animal: 2 pass 3 4 class Cat(Animal): 5 pass 6 7 class BosiCat(Cat): 8 pass 9 10 c = Cat() 11 b = BosiCat() 12 print(type(c)) #<class '__main__.Cat'> 會準確說出c是一種Cat,不會說c是一種Animaltype
3、isinstance(對象,類) 判斷xx對象是否是xxx類 (向上相容)
class Animal: pass class Cat(Animal): pass class BosiCat(Cat): pass c = Cat() b = BosiCat() print(isinstance(c , Cat)) #判斷c 是否是一種Cat print(isinstance(c,Animal)) #判斷c 是否是一種Animal print(isinstance(c,BosiCat)) 結果: True True Falseisinstace
二、判斷函數與方法
python官方定義:
函數function —— A series of statements which returns some value to a caller. It can also be passed zero or more arguments which may be used in the execution of the body.
方法method —— A function which is defined inside a class body. If called as an attribute of an instance of that class, the method will get the instance object as its first argument (which is usually called self).
從定義看,函數就相當於一個數學公式,它不與其他東西相互關聯,傳遞相應的參數就能用。而方法是,定義在類內部的函數,並且這個函數和類或類的實例對象有某種關聯,訪問時會自動傳遞一個參數作為第一參數。
簡單來說:
函數沒和類或對象進行綁定;
方法和類或對象有綁定
# 區分函數和方法:
1 def func(): 2 pass 3 print(func) # <function func at 0x10646ee18> 函數 4 class Foo: 5 6 def chi(self): 7 print("我是吃") 8 f = Foo() 9 print(f.chi) # <bound method Foo.chi of <__main__.Foo object at 10 0x10f688550>> 方法函數和方法
1 class Foo: 2 def chi(self): 3 print("我是吃") 4 @staticmethod 5 def static_method(): 6 pass 7 @classmethod 8 def class_method(cls): 9 pass 10 11 f = Foo() 12 13 print(f.chi) # <bound method Foo.chi of <__main__.Foo object at 14 0x10f688550>> 15 16 print(Foo.chi) # <function Foo.chi at 0x10e24a488> 17 print(Foo.static_method) # <function Foo.static_method at 0x10b5fe620> 18 print(Foo.class_method) # bound method Foo.class_method of <class 19 '__main__.Foo'>> 20 21 print(f.static_method) # <function Foo.static_method at 0x10e1c0620> 22 print(f.class_method) #<bound method Foo.class_method of <class 23 '__main__.Foo'>>函數和方法
結論:
1. 類方法. 不論任何情況, 都是方法.
2. 靜態方法, 不論任何情況. 都是函數
3. 實例方法, 如果是實例訪問. 就是方法. 如果是類名訪問就是函數.
#官方判斷方法:
通過types模塊引入MethodType FunctionType 來判斷
1 from types import FunctionType, MethodType 2 3 class Car: 4 def run(self): # 實例方法 5 print("我是車, 我會跑") 6 7 @staticmethod 8 def cul(): 9 print("我會計算") 10 11 @classmethod 12 def jump(cls): 13 print("我會jump") 14 15 c = Car() 16 17 實例方法: 18 # 1. 用對象.方法 方法 19 # 2. 類名.方法 函數 20 c = Car() 21 print(isinstance(c.run, FunctionType)) # False 22 print(isinstance(Car.run, FunctionType)) # True 23 print(isinstance(c.run, MethodType)) # True 24 print(isinstance(Car.run, MethodType)) # False 25 26 # 靜態方法 都是函數 27 print(isinstance(c.cul, FunctionType)) # True 28 print(isinstance(Car.cul, FunctionType)) # True 29 print(isinstance(c.cul, MethodType)) # False 30 print(isinstance(Car.cul, MethodType)) # False 31 32 # 類方法都是方法 33 print(isinstance(c.jump, FunctionType)) # False 34 print(isinstance(Car.jump, FunctionType)) # False 35 print(isinstance(c.jump, MethodType)) # True 36 print(isinstance(Car.jump, MethodType)) # True判斷
三、反射(重點)
關於反射, 其實一共有4個函數:
1. hasattr(obj, str) 判斷obj中是否包含str成員
2. getattr(obj,str) 從obj中獲取str成員
3. setattr(obj, str, value) 把obj中的str成員設置成value 這裡的value可以是值, 也可以是函數或者方法
4. delattr(obj, str) 把obj中的str成員刪除掉
註意:
obj可以是模塊,類,實例對象
以上操作都是在記憶體中進行的, 並不會影響你的源代碼,但是在同一個py文件中,你通過反射修改了類,是會影響到其他對象的。
1 #反射用到的四個函數,常用的是hasattr 和getattr 2 # setattr(a,b,c) a是要操作的對象,b是操作對象中的成員字元串形式,c是修改的值 3 # getattr(a,b) 有返回值,返回值形式a.b a是要操作的對象,b是操作對象中的成員字元串形式 4 #delattr(a,b) a是要操作的對象,b是操作對象中的成員字元串形式 5 #hasatter(a,b) a是要操作的對象,b是操作對象中的成員字元串形式 6 7 class Car: 8 9 def __init__(self,color,pai,price): 10 self.color = color 11 self.pai = pai 12 self.price= price 13 14 def fly(self): 15 print('我的車會飛') 16 17 c = Car('blue','豐田','18888') 18 f = getattr(Car,"fly") #操作對象是類,返回值相當於Car.fly 19 print(f) #<function Car.fly at 0x0000000001EA9D08> 這裡是函數,沒有和類綁定,所以需要下麵手動傳值 20 f(c) # f是函數,沒有和類綁定,所以需要手動傳值Car.fly(c) ,它是等價於c.fly()的 21 22 #delattr(Car,"fly") #操作的是類,把類中fly方法刪除了 23 #c.fly() #報錯,沒有fly 24 25 c2 =Car("yellow","bmw",20000) 26 27 def fly(): 28 print("通過對象c修改fly方法") 29 30 setattr(c,"fly",fly) #並沒有改變類中的內容,相當於在當前對象中創建了一個fly方法,一個對象是不可能有修改類的許可權的 31 c.fly() #通過對象c修改fly方法 32 c2.fly() #我的車會飛 33 c3 = Car("blue","賓士",88888) 34 c3.fly() #我的車會飛 35 setattr(Car,'fly',lambda self:print('通過類名,修改fly方法')) #通過類名修改fly方法 36 c.fly() #通過對象c修改fly方法 37 c2.fly() #通過類名,修改fly方法 38 c3.fly() #通過類名,修改fly方法 39 c4 = Car("red","悍馬",66666) 40 c4.fly() #通過類名,修改fly方法