类：特殊方法&slots&使用property

类的特殊成员方法：

1. __doc__:打印类的描述信息

#!/usr/bin/env python2.7
# -*- coding=utf-8 -*-


class Person(object):
    """
    这里是关于该类的一个介绍性的文档
    """
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex

print(Person.__doc__) 
# >>> '这里是关于该类的一个介绍性的文档'

2. __module__ & __class__ :查看当前操作对象所在模块，查看当前操作对象所在类

#!/usr/bin/env python2.7
# -*- coding=utf-8 -*-


# test12 文件下有Person类

class Person(object):
    """
    这里是关于该类的一个介绍性的文档
    """
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex



# 当前文件(test13)中的引用
from test12 import Person

p = Person('wang','f')
print(p.__module__) # >>> test12
print(p.__class__) # >>> <class 'test12.Person'>

3. __init__: 构造方法（创建实例对象的时候就会触发）【不再过多赘述】

#!/usr/bin/env python2.7
# -*- coding=utf-8 -*-


class Person(object):
    # 每次创建实例对象的时候都会触发该构造方法
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex


p1 = Person('wang','f')
p2 = Person('lee','m')

4. __del__:析构方法（用于实例对象的释放）

#!/usr/bin/env python2.7
# -*- coding=utf-8 -*-




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

    def __del__(self):
        print('im running')

neighbour_wang = Person('wang','f')
# >>> im running

5. __call__ : 对象后边加括号，进行执行

#!/usr/bin/env python2.7
# -*- coding=utf-8 -*-


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

    def __call__(self,*arg,**kw):
        print('__call__ is running')


p = Person('wang','f')
p()
# >>>__call__ is running

6. __dict__:查看类或者实例对象的属性

#!/usr/bin/env python2.7
# -*- coding=utf-8 -*-

p = Person()
print(Person.__dict__)  # >>> 打印类中的所有属性，不包含实例属性
print(p.__dict__) # >>> # >>> 打印实例中的所有属性，不包含类中属性

7. __str__: 打印实例对象的时候，默认打印__str__方法的返回值

#!/usr/bin/env python2.7
# -*- coding=utf-8 -*-


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

    # 注意返回的一定要是字符串，其他的报错
    def __str__(self):
        return '%s,%s'%(self.name, self.sex)


p = Person('wang','f')
print(p) # >>> wang,f

8. __getitem__, __setitem__, __delitem__:用于索引操作，（获取 设置 删除）

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'] = 'alex'   # 自动触发执行 __setitem__
del obj['k1']

"""
('__getitem__', 'k1')
('__setitem__', 'k2', 'alex')
('__delitem__', 'k1')
"""

slots方法的使用：

在使用python实例对象过程中，我们可以动态的给实例对象绑定“属性”&“方法”，正常情况下我们先定义一个类：

class Person(object):
    pass

创建类的实例对象，并尝试给这个实例对象动态的添加一个实例属性

p = Person()
s = Person()
p.name = 'wang'
print p.name # >>> wang
print s.name

"""
Traceback (most recent call last):
  File "/Users/info/Desktop/happy_work/test/test15.py", line 9, in <module>
    print s.name
AttributeError: 'Person' object has no attribute 'name'


解释：单独给p实例绑定的属性并不会所有的属性通用，比如说我会吹牛，其他人不一定会，我就是那个P, 别人就是那个s
"""

我们还可以给实例对象动态的绑定一个实例方法

def set_age(self, age): # 定义一个函数作为实例方法
    self.age = age

from types import MethodType
s.set_age = MethodType(set_age, s, Person) # 给实例绑定一个方法
s.set_age(25)
s.age # >>>25


b = Person()
b.set_age(22)
"""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'set_age'
"""

但是，如果我们想要限制class的属性怎么办？比如，只允许对Person实例添加name和sex属性。

为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class能添加的属性：

class Person(object):
    __slots__ = ('name', 'sex') # 用tuple定义允许绑定的属性名称


# 这个时候我们再去实验一下是否可以动态绑定name和sex之外的属性

s = Person()
s.age = 18
"""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute 'age'
"""

小tips：继承的子类中假设没有定义__slots__的话，子类上述代码中添加其他属性不会报错

property的使用 

在绑定属性时，如果我们直接把属性赋值给对象，比如：

p = Person()
p.name= 'Mary'

我们先看个详细的例子(注意双下划线name和age定义为私有变量)：

class Person(object):    
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def get_age(self):
        return self.__age

    def set_age(self, values):
        if not isinstance(value, int):
            raise ValueError('年龄必须是数字!')
        if value < 0 or value > 100:
            raise ValueError('年龄必须是0-100')
        self.__age = value

    def print_info(self):
        print('%s: %s' % (self.__name, self.__age))


p = Person('wang',20)
p.__age = 17
print(p.__age) # >>>17
print(p.get_age_fun()) # >>>20
p.set_age_fun(35)
print(p.get_age_fun()) # 35
print(p.print_info()) # wang: 35


"""
表面上看，外部代码“成功”地设置了__age变量 17，但实际上这个_age变量和class内部的_age变量不是一个变量！内部的_age变量已经被Python解释器自动改成了_Person_age，而外部代码给p新增了一个_age变量。 所以调用 get_age_fun输出的是初始值 20,而set_age_fun 通过class内部改变了age变量值,所以最终输出 35
"""

简单的使用perporty 【学习地址】

class Person(object):
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    @property
    def get_age_fun(self):
         return self.__age

    @get_age_fun.setter # get_age_fun是上面声明的方法
    def set_age_fun(self, value):
        if not isinstance(value, int):
            raise ValueError('年龄必须是数字!')
        if value < 0 or value > 100:
            raise ValueError('年龄必须是0-100')
        self.__age = value

    def print_info(self):
        print('%s: %s' % (self.__name, self.__age))


p = Person('balala',20)
p.__age = 17
print(p.__age) # 17
print(p.get_age_fun) # 20 注意这里不带()

#p.set_age_fun(35) 注意不能这样调用赋值了
p.set_age_fun = 35 #  这里set_age_fun 就是 声明的函数不带()
print(p.get_age_fun) # 35
print(p.print_info()) # balala: 35

当然我们根据这个property还可以创建只读属性啥的（只定义getter方法，不定义setter方法就是一个只读属性）【廖雪峰-property】

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

    @property
    def age(self):
        return 2014 - self._birth