python里面类的高级知识

面向对象知识终结:
类 是一个模板，模板中包装了多个“函数”供使用（可以讲多函数中公用的变量封装到对象中）
对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
面向对象三大特性：封装、继承和多态

类成员:
 1.字段(普通字段和静态字段)
 2.方法（普通方法,类方法,静态方法）
 3.属性(普通属性)

字段:静态字段在内存中只保存一份,静态字段通过类访问，普通字段在每个对象中都要保存一份，普通字段需要通过对象来访问，如果每个对象都具有相同的字段，那么就使用静态字段

class studen:
    a='张扬'  # 这个就相当于静态字段
    def __init__(self,name):
 self.name = name  # 相当与普通字段

obj = studen('李四')
print(obj.name)
student.a
 
方法：
 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls;
 静态方法：由类调用；无默认参数；
eg
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 '静态方法'

 

属性:在普通方法的基础上添加 @property 装饰器,要求这个普通方法只有seft一个参数，那我们在调用的使用就不需要加括号了,访问属性时可以制造出和访问字段完全相同的假象
新式类中,具有三种@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 方法

 

property的构造方法中有个四个参数
第一个参数是方法名，调用 对象.属性 时自动触发执行方法
第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息

class Foo：

    def get_bar(self):
        return 'wupeiqi'

    # *必须两个参数
    def set_bar(self, value):
        return return 'set value' + value

    def del_bar(self):
        return 'wupeiqi'

    BAR ＝ property(get_bar, set_bar, del_bar, 'description...')

obj = Foo()

obj.BAR              # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex"     # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
del Foo.BAR          # 自动调用第三个参数中定义的方法：del_bar方法
obj.BAE.__doc__      # 自动获取第四个参数中设置的值：description...

上述说的类成员中又可以分为私有成员和公有成员：私有成员命名时，前两个字符是下划线,使用的相对于只有本类中可以访问,继承中部内

 

 

 

类的特色成员方法
1. __doc__　　表示类的描述信息

2.　　__module__ 表示当前操作的对象在那个模块
3.　　__class__     表示当前操作的对象的类是什么
4.__del__  析构方法，当对象在内存中被释放时，自动触发执行
5.__call__ 对象后面加括号，触发执行。构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
6. __dict__ 查看类或对象中的所有成员
7.__str__ 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
8.__getitem__、__setitem__、__delitem__可以像字典一样操作方法
eg
class Foo(object):
 
    def __getitem__(self, key):
        print('__getitem__',key)
 
    def __setitem__(self, key, value):
        print('__setitem__',key,value)
 
    def __delitem__(self, key):
        print('__delitem__',key)
 
 
obj = Foo()
 
result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'name'   # 自动触发执行 __setitem__
del obj['k1'] 

 

反射：
 
# #### 检查是否含有成员 ####
hasattr(obj, 'name')
hasattr(obj, 'func')
 
# #### 获取成员 ####
getattr(obj, 'name')
getattr(obj, 'func')  获取的是内存对象地址,加上()表示执行
 
# #### 设置成员 ####
setattr(obj, 'age', 18)
可以添加一个方法在类里面
def bulk(self):
    print("%s is yelling...." %self.name)

class Dog(object):
    def __init__(self,name):
        self.name = name

    def eat(self,food):
        print("%s is eating..."%self.name,food)

d = Dog("NiuHanYang")
choice = input(">>:").strip()

if hasattr(d,choice):
    func = getattr(d,choice)
    func('xue')
else:
    setattr(d,choice,bulk)  # 在里面添加一个方法
    func = getattr(d, choice)  # 然后可以执行这个方法
    func(d)

# #### 删除成员 ####
delattr(obj, 'name')
delattr(obj, 'func')