python之'定制类'

python版本:3.6.5

1.__slots__()
当我们定义了一个 class,创建了一个 class 的实例后,我们可以给该实例绑定任何属性
和方法,通过 __slots__ 我们想要限制实例的属性

 

# 定义 Student 类，只允许对 Student 实例添加 name 属性:
class Student(object):
    __slots__ = ('name') # 用tuple定义允许绑定的属性名称
  
s = Student() # 创建新的实例
s.name = 'Michael' # 绑定属性'name'
#由于'score'没有被放到__slots__中，所以不能绑定score属性，试图绑定score将得到AttributeError的错误。
s.score = 99 # 绑定属性'score' 

注:__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用：

class GraduateStudent(Student):
     pass
g = GraduateStudent()
g.score = 9999

2.__str__()和__repr__()

#定义一个 Student 类，打印一个实例：
class Student(object):
    def __init__(self, name):
        self.name = name
        
print(Student('Michael'))

output:
<__main__.Student object at 0x109afb190>

打印出一堆<__main__.Student object at 0x109afb190>，不好看。
怎么才能打印得好看呢？只需要定义好__str__()方法，返回一个好看的字符串就可以了：

class Student(object):
     def __init__(self, name):
         self.name = name
     def __str__(self):
         return 'Student object (name: %s)' % self.name

print(Student('Michael'))

output:
Student object (name: Michael)

这样打印出来的实例，不但好看，而且容易看出实例内部重要的数据。
但是细心的朋友会发现直接敲变量不用print，打印出来的实例还是不好看：

s = Student('Michael')
s

output:
<__main__.Student object at 0x109afb310>

这是因为直接显示变量调用的不是__str__()，而是__repr__()，两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的。
解决办法是再定义一个__repr__()。但是通常__str__()和__repr__()代码都是一样的，所以，有个偷懒的写法：

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__

3.__iter__()

如果一个类想被用于for ... in循环，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。
以斐波那契数列为例，写一个Fib类，可以作用于for循环：

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):
        return self # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 退出循环的条件
            raise StopIteration()
        return self.a # 返回下一个值

for n in Fib():
     print(n)

output：
1
1
2
3
5
...
46368
75025

4.__getitem__()
如果一个类像要像list那样按照下标取出元素，需要实现__getitem__()方法：

class Fib(object):
    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a

f = Fib()
f[0]

output :
1

实现切片:

class Fib(object):
    def __getitem__(self, n):
        if isinstance(n, int): # n是索引
            a, b = 1, 1
            for x in range(n):
                a, b = b, a + b
            return a
        if isinstance(n, slice): # n是切片
            start = n.start
            stop = n.stop
            if start is None:
                start = 0
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    L.append(a)
                a, b = b, a + b
            return L

f = Fib()
f[0:5]

output:
[1, 1, 2, 3, 5]

注:没有对step( list[start:end:step] ),负数等作处理

5.__getattr__()
实例instance通过instance.name访问属性name，只有当属性name没有在实例的__dict__或它构造类的__dict__或基类的__dict__中，才会调用__getattr__。当属性name可以通过正常机制追溯到时，__getattr__是不会被调用的。如果在__getattr__(self, attr)存在通过self.attr访问属性，会出现无限递归错误。

class ClassA(object):

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

    def __getattr__(self, attr):
        return('__getattr__', attr)

a = ClassA('A')

print(a.__dict__) # 实例insA已经有classname属性了
print(a.name) # 不会调用__getattr__
print(a.grade) # grade属性没有找到，调用__getattr__

output:
{'name': 'A'}
A
('__getattr__', 'grade')

6.__setattr__()
常规的对实例属性赋值，被赋值的属性和值会存入实例属性字典__dict__中。
如果类自定义了__setattr__方法，当通过实例获取属性尝试赋值时，就会调用__setattr__。类定义中的self.attr也同样，所以在__setattr__下还有self.attr的赋值操作就会出现无线递归的调用__setattr__的情况。自己实现__setattr__有很大风险，一般情况都还是继承object类的__setattr__方法。

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

a = ClassA('A')
print('__dict__=',a.__dict__)

a.tag = 'B'
print('__dict__=',a.__dict__)

output:
__dict__= {'name': 'A'}
__dict__= {'name': 'A', 'tag': 'B'}

 如下类自定义了__setattr__,对实例属性的赋值就会调用它。

class ClassA(object):
    def __init__(self, name):
        self.name = name
    def __setattr__(self, name, value):
        super().__setattr__(name, value)
        # self.name = value  # 如果还这样调用会出现无限递归的情况
        print('invoke __setattr__')

a = ClassA('A')
print('__dict__=',a.__dict__)

a.tag = 'B'
print('__dict__=',a.__dict__)


output:
invoke __setattr__
__dict__= {'name': 'A'}
invoke __setattr__
__dict__= {'name': 'A', 'tag': 'B'}

7.__call__()
允许将类当做函数一样使用

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

    def __call__(self):
        print('self_name=',self.name)

s = Student('Michael')
s()

output:
self_name= Michael

    __call__()使用场景和优点：
        1.简化方法调用
        2.对象下只有一个方法
        3.频繁使用

 

参考:

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014319117128404c7dd0cf0e3c4d88acc8fe4d2c163625000

http://www.cnblogs.com/elie/p/6685429.html