• 中美研究人员发现新型狗流感病毒 2019-05-29
  • 豫园商城升级改造:这些楼顶可见最好的风景--旅游频道 2019-05-14
  • 头条 —频道 春城壹网 七彩云南 一网天下 2019-05-14
  • 人为某种意识而奋斗是幸福的,获得成绩或成就更幸福。 2019-05-10
  • 【专题】省违反中央八项规定精神和“四风”问题线索举报平台 2019-05-09
  • 确定这是热身赛?吴前拼到大腿抽筋 拆绷带继续干 2019-05-09
  • 应对排放新规 大众德国工厂计划短暂停产 2019-04-26
  • 一师一团土地确权登记颁证工作全面展开 2019-04-26
  • 一语惊坛(5月31日):“我们不一样”,中国向世界许下一个承诺。 2019-04-22
  • 俄罗斯世界杯F组:球迷风采 2019-04-10
  • 5月份国民经济数据发布:中国经济持续稳中向好 2019-04-10
  • 贵州宣讲十九大:干部争当宣讲员 群众心窝暖洋洋 2019-03-25
  • 别空谈,说说看,这个“简单的逻辑关系”是什么关系? 2019-03-25
  • 快过闪电,MIUI 10与MIUI 9速度对比 2019-03-21
  • 泽州去年“免费教育”资金达5211万元 2019-03-19
  • Python面向对象之魔术方法

    __str__

    快乐彩开奖号码 www.752o.com 改变对象的字符串显示??梢岳斫馕褂胮rint函数打印一个对象时,会自动调用对象的__str__方法

    class Student:
        def __init__(self, name, age):
            self.name = name
            self.age = age
            
        # 定义对象的字符串表示
        def __str__(self):
            return self.name
        
    s1 = Student('张三', 24)
    print(s1)  # 会调用s1的__str__方法

    __repr__

    在python解释器环境下,会默认显示对象的repr表示。

    >>> class Student:
    ...     def __init__(self, name, age):
    ...         self.name = name
    ...         self.age = age
    ...     def __repr__(self):
    ...         return self.name
    ... 
    >>> s1 = Student('张三', 24)
    >>> s1
    张三

    总结:

    str函数或者print函数调用的是obj.__str__()
    repr函数或者交互式解释器调用的是obj.__repr__()

    注意:
    如果__str__没有被定义,那么就会使用__repr__来代替输出。
    __str__和__repr__方法的返回值都必须是字符串。

    __format__

    class Student:
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        __format_dict = {
            'n-a': '名字是:{obj.name}-年龄是:{obj.age}',  # 名字是:lqz-年龄是:18
            'n:a': '名字是:{obj.name}:年龄是:{obj.age}',  # 名字是:lqz:年龄是:18
            'n/a': '名字是:{obj.name}/年龄是:{obj.age}',  # 名字是:/年龄是:18
        }
    
        def __format__(self, format_spec):
            if not format_spec or format_spec not in self.__format_dict:
                format_spec = 'n-a'
            fmt = self.__format_dict[format_spec]
            print(fmt) #{obj.name}:{obj.age}
            return fmt.format(obj=self)
    
    s1 = Student('lqz', 24)
    ret = format(s1, 'n/a')
    print(ret)  # lqz/24

     __del__

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

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

    class A:
        def __del__(self):
            print('删除了...')
    
    a = A()
    print(a)  # <__main__.A object at 0x10164fb00>
    del a  # 删除了...
    print(a)  # NameError: name 'a' is not defined

    __dict__和__slots__

    Python中的类,都会从object里继承一个__dict__属性,这个属性中存放着类的属性和方法对应的键值对。一个类实例化之后,这个类的实例也具有这么一个__dict__属性。但是二者并不相同。

    class A:
        some = 1
    
        def __init__(self, num):
            self.num = num
    
    a = A(10)
    print(a.__dict__)  # {'num': 10}
    a.age = 10
    print(a.__dict__)  # {'num': 10, 'age': 10}

    从上面的例子可以看出来,实例只保存实例的属性和方法,类的属性和方法它是不保存的。正是由于类和实例有__dict__属性,所以类和实例可以在运行过程动态添加属性和方法。

    但是由于每实例化一个类都要分配一个__dict__变量,容易浪费内存。因此在Python中有一个内置的__slots__属性。当一个类设置了__slots__属性后,这个类的__dict__属性就不存在了(同理,该类的实例也不存在__dict__属性),如此一来,设置了__slots__属性的类的属性,只能是预先设定好的。

    当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的小型数组来构建的,而不是为每个实例都定义一个__dict__字典,在__slots__中列出的属性名在内部被映射到这个数组的特定索引上。使用__slots__带来的副作用是我们没有办法给实例添加任何新的属性了。

    注意:尽管__slots__看起来是个非常有用的特性,但是除非你十分确切的知道要使用它,否则尽量不要使用它。比如定义了__slots__属性的类就不支持多继承。__slots__通常都是作为一种优化工具来使用。--摘自《Python Cookbook》8.4

    class A:
        __slots__ = ['name', 'age']
        
    a1 = A()
    # print(a1.__dict__)  # AttributeError: 'A' object has no attribute '__dict__'
    a1.name = '张三'
    a1.age = 24
    # a1.hobby = '泡妞'  # AttributeError: 'A' object has no attribute 'hobby'
    print(a1.__slots__)

    注意事项:
    __slots__的很多特性都依赖于普通的基于字典的实现。
    另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。大多数情况下,你应该只在那些经常被使用到的用作数据结构的类上定义__slots__,比如在程序中需要创建某个类的几百万个实例对象 。
    关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。它更多的是用来作为一个内存优化工具。

    __item__系列

    class Foo:
        def __init__(self, name):
            self.name = name
    
        def __getitem__(self, item):
            print(self.__dict__[item])
    
        def __setitem__(self, key, value):
            print('obj[key]=lqz赋值时,执行我')
            self.__dict__[key] = value
    
        def __delitem__(self, key):
            print('del obj[key]时,执行我')
            self.__dict__.pop(key)
    
        def __delattr__(self, item):
            print('del obj.key时,执行我')
            self.__dict__.pop(item)
    
    
    f1 = Foo('sb')
    print(f1.__dict__)
    f1['age'] = 18
    f1.hobby = '泡妞'
    del f1.hobby
    del f1['age']
    f1['name'] = 'lqz'
    print(f1.__dict__)

    __init__

    使用Python写面向对象的代码的时候我们都会习惯性写一个 __init__ 方法,__init__ 方法通常用在初始化一个类实例的时候。例如:

    class Person:
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def __str__(self):
            return '<Person: {}({})>'.format(self.name, self.age)
    
    p1 = Person('张三', 24)
    print(p1)

    上面是__init__最普通的用法了。但是__init__其实不是实例化一个类的时候第一个被调用的方法。当使用 Persion(name, age) 来实例化一个类时,最先被调用的方法其实是 __new__ 方法。

    __new__

    其实__init__是在类实例被创建之后调用的,它完成的是类实例的初始化操作,而 __new__方法正是创建这个类实例的方法

    class Person:
    
        def __new__(cls, *args, **kwargs):
            print('调用__new__,创建类实例')
            return super().__new__(Person)
    
        def __init__(self, name, age):
            print('调用__init__,初始化实例')
            self.name = name
            self.age = age
    
        def __str__(self):
            return '<Person: {}({})>'.format(self.name, self.age)
    
    p1 = Person('张三', 24)
    print(p1)

    输出:

    调用__new__,创建类实例
    调用__init__,初始化实例
    <Person: 张三(24)>

    __new__方法在类定义中不是必须写的,如果没定义的话默认会调用object.__new__去创建一个对象(因为创建类的时候默认继承的就是object)。

    如果我们在类中定义了__new__方法,就是重写了默认的__new__方法,我们可以借此自定义创建对象的行为。

    举个例子:

    重写类的__new__方法来实现单例模式。

    class Singleton:
        # 重写__new__方法,实现每一次实例化的时候,返回同一个instance对象
        def __new__(cls, *args, **kw):
            if not hasattr(cls, '_instance'):
                cls._instance = super().__new__(Singleton)
            return cls._instance
    
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
    
    s1 = Singleton('张三', 24)
    s2 = Singleton('李四', 20)
    print(s1, s2)  # 这两实例都一样
    print(s1.name, s2.name)

    __call__

    __call__ 方法的执行是由对象后加括号触发的,即:对象()。拥有此方法的对象可以像函数一样被调用。

    class Person:
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def __call__(self, *args, **kwargs):
            print('调用对象的__call__方法')
    
    a = Person('张三', 24)  # 类Person可调用
    a()  # 对象a可以调用

    注意: 

    __new__、__init__、__call__等方法都不是必须写的。

    __doc__

    定义类的描述信息。注意该信息无法被继承。

    class A:
        """我是A类的描述信息"""
        pass
    
    print(A.__doc__)

    __iter__和__next__

    如果一个对象拥有了__iter__和__next__方法,那这个对象就是可迭代对象

    class A:
        def __init__(self, start, stop=None):
            if not stop:
                start, stop = 0, start
            self.start = start
            self.stop = stop
    
        def __iter__(self):
            return self
    
        def __next__(self):
            if self.start >= self.stop:
                raise StopIteration
            n = self.start
            self.start += 1
            return n
    
    a = A(1, 5)
    from collections import Iterator
    print(isinstance(a, Iterator))
    
    for i in A(1, 5):
        print(i)
    
    for i in A(5):
        print(i)
    aaa=A(1)
    print(next(aaa))
    print(next(aaa)) #抛异常

    __enter__和__exit__

    一个对象如果实现了__enter__和___exit__方法,那么这个对象就支持上下文管理协议,即with语句

    class A:
        def __enter__(self):
            print('进入with语句块时执行此方法,此方法如果有返回值会赋值给as声明的变量')
            return 'oo'
    
        def __exit__(self, exc_type, exc_val, exc_tb):
            print('退出with代码块时执行此方法')
            print('1', exc_type)
            print('2', exc_val)
            print('3', exc_tb)
    
    with A() as f:
        print('进入with语句块')
        # with语句中代码块出现异常,则with后的代码都无法执行。
        # raise AttributeError('sb')
        print(f) #f打印出oo
    print('嘿嘿嘿')

    上下文管理协议适用于那些进入和退出之后自动执行一些代码的场景,比如文件、网络连接、数据库连接或使用锁的编码场景等。

    __len__

    拥有__len__方法的对象支持len(obj)操作。

    class A:
        def __init__(self):
            self.x = 1
            self.y = 2
    
        def __len__(self):
            return len(self.__dict__)
    
    a = A()
    print(len(a))

    __hash__

    拥有__hash__方法的对象支持hash(obj)操作。

    class A:
        def __init__(self):
            self.x = 1
            self.x = 2
    
        def __hash__(self):
            return hash(str(self.x) + str(self.x))
    
    a = A()
    print(hash(a))

    __eq__

    拥有__eq__方法的对象支持相等的比较操作

    class A:
        def __init__(self,x,y):
            self.x = x
            self.y = y
    
        def __eq__(self,obj):
            # 打印出比较的第二个对象的x值
            print(obj.x)
            if self.x +self.y == obj.x+obj.y:
                return True
            else:
                return False
    
    a = A(1,2)
    b = A(2,1)
    print(a == b)

     

    posted @ 2019-03-16 19:54 伍萬磊 阅读(...) 评论(...) 编辑 收藏
  • 中美研究人员发现新型狗流感病毒 2019-05-29
  • 豫园商城升级改造:这些楼顶可见最好的风景--旅游频道 2019-05-14
  • 头条 —频道 春城壹网 七彩云南 一网天下 2019-05-14
  • 人为某种意识而奋斗是幸福的,获得成绩或成就更幸福。 2019-05-10
  • 【专题】省违反中央八项规定精神和“四风”问题线索举报平台 2019-05-09
  • 确定这是热身赛?吴前拼到大腿抽筋 拆绷带继续干 2019-05-09
  • 应对排放新规 大众德国工厂计划短暂停产 2019-04-26
  • 一师一团土地确权登记颁证工作全面展开 2019-04-26
  • 一语惊坛(5月31日):“我们不一样”,中国向世界许下一个承诺。 2019-04-22
  • 俄罗斯世界杯F组:球迷风采 2019-04-10
  • 5月份国民经济数据发布:中国经济持续稳中向好 2019-04-10
  • 贵州宣讲十九大:干部争当宣讲员 群众心窝暖洋洋 2019-03-25
  • 别空谈,说说看,这个“简单的逻辑关系”是什么关系? 2019-03-25
  • 快过闪电,MIUI 10与MIUI 9速度对比 2019-03-21
  • 泽州去年“免费教育”资金达5211万元 2019-03-19
  • 幸运飞艇彩票计划软件免费 今晚七星彩开奖结果i 全天1分快三计划软件 pk10软件平刷王 时时彩后三组六的玩法 网球冠军女 中国体彩网开奖结果 幸运飞艇时间几点封盘 山东体彩十一运夺金开奖结果查询 欢乐斗地主电脑版单机 河南快三基本走势图一定牛 荒野行动pc官方网站 丛林巨兽卡组2018 手机版助赢免费软件 网上选号软件 千年老妖&公式三肖中特