定制类

亦凉 2022-01-13 21:07 276阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

# **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个参数：

1、class的名称；
    
    2、继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
    
    3、class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。

通过type()函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。

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

转载于:https://my.oschina.net/u/2474096/blog/824544

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220113/05db9a0303aa4604a3d8758bed7b3529.png