定制类

str、repr

• str()返回用户看到的字符串
• repr()返回程序开发者看到的字符串，也就是说，repr()是为调试服务的

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

    def __str__(self):
        return "Student object name:{}".format(self.name)

    __repr__ = __str__

iter

若是一个类想被用于for ... in循环，相似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，而后，Python的for循环就会不断调用该迭代对象的next()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环,咱们以斐波那契数列为例，写一个Fib类，能够做用于for循环：

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

    def __iter__(self):
        return self  # 实例自己就是迭代器,返回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

getitem

Fib实例虽然能做用于for循环，看起来和list有点像，可是，把它当成list来使用仍是不行，好比，取第5个元素,要表现得像list那样按照下标取出元素，须要实现__getitem__()方法：

class Fab(object):
    def __getitem__(self, item):
        a, b = 1, 1
        for x in xrange(item):
            a, b = b, a + b
        return a



f = Fab()
print f[1]
print f[2]

getattr

正常状况下，当咱们调用类的方法或属性时，若是不存在，就会报错。StudentTest类.调用name属性，没问题，可是，调用不存在的arg属性，就有问题了,在getattr里面能够作判断而且返回一个对象：

代码实现:

class StudentTest(object):
    def __init__(self):
        self.name = "Hero"

    def __getattr__(self, item):
        if item == 'arg':
            return 27
        else:
            raise ValueError("The key is not found")

st = StudentTest()
print st.name
print st.arg
print st.sexy

实际用例: 将一个字典设置成类属性访问

经常使用方法：

class Eleme(object):
    def __init__(self):
        self._dict = {"method": "get"}
        self._list = ["name", "sexy"]
        for key,val in self._dict.items():
            setattr(self, key,val)

    



e = Eleme()

print e.method

# result : get

更好的方法:

# -*- coding: utf-8 -*-

class Eleme(object):
    def __init__(self):
        self._dict = {"method": "get"}
        self._list = ["name", "sexy"]

    def __getattr__(self, item):
        return self._dict[item]



e = Eleme()

print e.method

# result : get

call

一个对象实例能够有本身的属性和方法，当咱们调用实例方法时，咱们用instance.method()来调用。能不能直接在实例自己上调用呢？相似instance()？在Python中，答案是确定的。 任何类，只须要定义一个__call__()方法，就能够直接对实例进行调用。请看示例：

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

    def __call__(self, arg = None):
        return "My name is {}. {} old".format(self.name,arg)



c = CallTest("hero")
print c(12)

My name is hero. 12 old

#仿django orm

# -*- coding: utf-8 -*-

class User(object):
    class objects():
        @classmethod
        def create(cls, **kwargs):
            key, val = kwargs.items()[0]
            return "Create successful.key is {key} values is {val}".format(
                key=key, val=val)


print User.objects.create(name="Hero")

# 输出结果: Create successful.key is name values is Hero

type() 使用元类

动态语言和静态语言最大的不一样，就是函数和类的定义，不是编译时定义的，而是运行时动态建立的。 比方说咱们要定义一个Hello的class，就写一个hello.py模块：

class Hello(object):
    def hello(self, name='world'):
        print('Hello, %s.' % name)

当Python解释器载入hello模块时，就会依次执行该模块的全部语句，执行结果就是动态建立出一个Hello的class对象，测试以下：

>>> from hello import Hello
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class 'hello.Hello'>

type()函数能够查看一个类型或变量的类型，Hello是一个class，它的类型就是type，而h是一个实例，它的类型就是class Hello。

咱们说class的定义是运行时动态建立的，而建立class的方法就是使用type()函数。

type()函数既能够返回一个对象的类型，又能够建立出新的类型，好比，咱们能够经过type()函数建立出Hello类，而无需经过class Hello(object)...的定义：

>>> def fn(self, name='world'): # 先定义函数
...     print('Hello, %s.' % name)
...
>>> Hello = type('Hello', (object,), dict(hello=fn)) # 建立Hello class
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class '__main__.Hello'>

要建立一个class对象，type()函数依次传入3个参数：

一、class的名称；

二、继承的父类集合，注意Python支持多重继承，若是只有一个父类，别忘了tuple的单元素写法；

三、class的方法名称与函数绑定，这里咱们把函数fn绑定到方法名hello上。

经过type()函数建立的类和直接写class是彻底同样的，由于Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，而后调用type()函数建立出class。

正常状况下，咱们都用class Xxx...来定义类，可是，type()函数也容许咱们动态建立出类来，也就是说，动态语言自己支持运行期动态建立类，这和静态语言有很是大的不一样，要在静态语言运行期建立类，必须构造源代码字符串再调用编译器，或者借助一些工具生成字节码实现，本质上都是动态编译，会很是复杂。