委托:如果我们要把方法当做参数来传递的话,就要用到委托。简单来说,委托的类型可以是赋值一个方法的引用. 可以把一个方法赋值过来,通过这个委托变量调用这个方法 python函数是能作为参数输入函数的,这个相当于c里面的委托,将一个函数封装到一个委托对象里
首先我们看这个函数
__getattr__
getattr(object, name[, default])
- object -- 对象。
- name -- 字符串,对象属性。
- default -- 默认返回值,如果不提供该参数,在没有对应属性时,将触发 AttributeError。
该函数属于反射操作,用于获取 object 中名为 name 的属性(name 是以字符串表示的属性名), getattr(x, 'foobar') 等效于 x.foobar。如果 object 中含有 name 属性,则返回该属性;如果 object 没有 name 属性,则返回 default(如果提供),否则抛出 AttributeError 异常。
对于字段属性,会直接返回值;对于方法属性,会返回其引用(通过引用可调用方法属性)。
#字段包括普通字段和静态字段
class Province:
# 静态字段
country = '中国'
def __init__(self, name):
# 普通字段
self.name = name
# 直接访问普通字段
obj = Province('河北省')
print obj.name
# 直接访问静态字段
Province.country
class ObjectDict(dict):
def __init__(self, *args, **kwargs):
super(ObjectDict, self).__init__(*args, **kwargs)
def __getattr__(self, name):
value = self[name]
if isinstance(value, dict):
value = ObjectDict(value)
return value
if __name__ == '__main__':
od = ObjectDict(asf={'a': 1}, d=True)
print od.asf
print od.asf.a
print od.d
>>>{'a':1}
>>>1
>>>True
#方法包括普通方法、静态方法和类方法
三种方法在内存中都归属于类,区别在于调用方式不同。
普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self;
类方法:由类调用; 至少一个cls参数;执行类方法时,自动将调用该方法的类复制给cls;
静态方法:由类调用;无默认参数;
class Foo:
def __init__(self, name):
self.name = name
def ord_func(self):
""" 定义普通方法,至少有一个self参数 """
# print self.name
print '普通方法'
@classmethod
def class_func(cls):
""" 定义类方法,至少有一个cls参数 """
print '类方法'
@staticmethod
def static_func():
""" 定义静态方法 ,无默认参数"""
print '静态方法'
# 调用普通方法
f = Foo()
f.ord_func()
# 调用类方法
Foo.class_func()
# 调用静态方法
Foo.static_func()
相同点:对于所有的方法而言,均属于类(非对象)中,所以,在内存中也只保存一份。
不同点:方法调用者不同、调用方法时自动传入的参数不同。
#属性(普通方法的变种)
class Foo:
def func(self):
pass
# 定义属性
@property
def prop(self):
pass
# ############### 调用 ###############
foo_obj = Foo()
foo_obj.func()#这叫调用方法
foo_obj.prop #调用属性
-------------------------
由属性的定义和调用要注意一下几点:
定义时,在普通方法的基础上添加 @property 装饰器;
定义时,属性仅有一个self参数
调用时,无需括号
方法:foo_obj.func()
属性:foo_obj.prop
----------------------------------
属性的定义有两种方式:
装饰器 即:在方法上应用装饰器
静态字段 即:在类中定义值为property对象的静态字段
经典类具有一种@property装饰器
新式类(Object) 具有三种@property装饰器
class Goods(object):
@property
def price(self):
print '@property'
@price.setter
def price(self, value):
print '@price.setter'
@price.deleter
def price(self):
print '@price.deleter'
# ############### 调用 ###############
obj = Goods()
obj.price
# 自动执行 @property 修饰的 price 方法,并获取方法的返回值
obj.price = 123
# 自动执行 @price.setter 修饰的 price 方法,并将 123 赋值给方法的参数
del obj.price
# 自动执行 @price.deleter 修饰的 price 方法
class Wrapper:
def __init__(self, obj):
self.wrapper = obj
print self.wrapper
print type(self.wrapper)
print"-"*100
def __getattr__(self, item):
print("trace:", item)
return getattr(self.wrapper, item)
if __name__ == '__main__':
x = Wrapper([1, 2, 3, 4])
x.append(35)
x.remove(2)
print(x.wrapper) # [1,3,4,35]
在__init__(self,obj)方法中传入一个被委托对象。 通过重写__getattr__(self,item)方法,拦截外部对象的属性调用 在__getattr__(self,item)中,将拦截到的属性,让被委托对象去使用。 python 中的属性概念,和Java中的属性概念是不同的。Java中的属性,就是指类中定义的成员变量,绝对不包含方法。而在python中,任何能以obj.xx形式调用的东西,全部可以称为属性。无论是方法,还是变量,还是对象。 所以上述代码中调用x.append(N),实际上是让x的属性wrapper去调用append(N)方法。