面向对象2

类的成员

类的成员可以分为三大类：字段、方法和属性

所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。

一、字段

字段包含静态字段和普通字段，静态字段属于类，普通字段属于对象

class School(object):
    # 静态字段
    munbers = 0

    def __init__(self, name):
        # 普通字段
        self.name = name

# 通过对象访问普通字段
obj1 = School('Tsinghua')
print(obj1.name)

obj2 = School('Pking')
print(obj2.name)

# 通过类直接访问静态字段 print(School.munbers)

静态字段在仅在类中保存一份，而普通字段需要在每个对象中保存一份。如果每个对象都有相同的字段，可以将该字段保存为静态字段

二、方法

方法包含普通方法，静态方法，类方法，三种方法都保存在类中，区别在于调用的方式不同

• 普通方法:由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

class Foo(object):

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

    def ord_method(self):
        """定义一个普通方法，参数中至少要有一个 self"""
        print("普通方法")
        print(self.name)

    @classmethod
    def class_method(cls):
        """定义一个类方法，参数只要要有一个 cls，并且以 @classmethod 修饰"""
        print("类方法")

    @staticmethod
    def static_method():
        """定义一个静态方法，参数不能有 self，并且以 @staticmethod 修饰"""
        print("静态方法")


# 调用普通方法
obj = Foo('Name')
obj.ord_method()

# 调用类方法
Foo.class_method()

# 调用静态方法
Foo.static_method()

三、属性

属性是普通方法的变种，属性有两种定义方式。

属性的基本使用

class Foo(object):

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

    @property
    def show(self):
        """定义一个属性"""
        return self.name


# 通过对象调用属性
obj = Foo('www')
result = obj.show
print(result)

由属性的定义和调用要注意一下几点：

• 定义时，在普通方法的基础上添加 @property 装饰器；属性仅有一个self参数
• 调用时，无需括号
             方法：obj.func()
             属性：obj.show

注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象

        属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。

属性的两种定义方式

• 通过装饰器定义，即将方法进行装饰
• 通过静态字段定义，即在类中定义值为 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 Foo：

    def get_bar(self):
        return 'WenChong'

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

    def del_bar(self):
        return 'WenChong'

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

obj = Foo()

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

成员修饰符

对于类的每一个成员都有两种形式

• 公有成员：在任何地方都能访问
• 私有成员：只有在类内部才能访问

定义

私有成员以两个下划线开始(特殊成员例外)，其他的均为公有成员

class Foo(object):

    def __init__(self):
        self.name = '公有成员'
        self.__age = '私有成员'

访问

class Foo(object):

    def __init__(self):
        self.name = '公有成员'
        self.__age = '私有成员'

    def show(self):
        print(self.__age)


obj = Foo()
print(obj.name)   # 访问公有成员
print(obj.__age)  # 访问私有成员，报错
obj.show()        # 通过公有方法间接访问私有成员

可以通过 对象._类名__私有字段名 的方式强制访问私有字段，但是这种方式不建议使用

print(obj._Foo__age)

方法、属性的定义访问方式类似

类的特殊成员

1、__doc__

表示类的描述信息

class Foo(object):
    """__doc__ 显示的内容"""
    pass

2、__model__ 和 __class__

• __model__ 表示当前操作的类的模块
• __class__ 表示当前操作的类

3、__init__

构造方法，通过类创建对象时自动触发

4、__del__

析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

5、__call__

对象后面加()，触发执行

class Foo(object):

    def __call__(self, *args, **kwargs):
        print('call')

# 第一种
obj = Foo()
obj()
# 第二种
Foo()()

6、__dict__

显示类或对象中的所有成员

class Foo(object):

    def __init__(self):
        self.name = 'WenChong'


print(Foo.__dict__)

7、__str__

如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class Foo(object):

    def __str__(self):
        return 'str'

# 根据类创建对象，并打印对象
obj = Foo()
print(obj)

8、__getitem__, __setitem__,__delitem__

用于索引操作，如字典。以上分别表示获取、设置、删除数据

class Foo(object):

    def __getitem__(self, item):
        print(item)

    def __setitem__(self, key, value):
        print(key, value)

    def __delitem__(self, key):
        print(key)


obj = Foo()
obj['name']                 # 自动执行 __getitem__ 方法
obj['name'] = 'WenChong'    # 自动执行 __setitem__ 方法
del obj['name']             # 自动执行 __delitem__ 方法

9、__iter__

用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__

class Foo(object):

    def __iter__(self):
        return iter([11,22,33])


obj = Foo()

for i in obj:
    print(i)