Python学习Day8(上) ---- 一些魔法方法

1. _ _ dict _ _

Python中类的普通方法、类方法、静态方法、全局变量以及一些内置属性都是放在类对象字典dict里面

class Person:
    myName = 'jsl'
print(Person.myName)
print(Person.__dict__['myName'])
>>> jsl
>>> jsl

Person.dict['myName']就是字典的读取方式,也可以通过 . 号读取

p = Person()
print(p.__dict__)
>>> {}

将类实例化,实例属性dict是空的,因为myName是类的属性

class Person:
    myName = 'jsl'
    def __init__(self):
        self.name = 'j'
        self.age = 20
    def get_name(self):
        return self.name

print(Person.__dict__)

p = Person()
print(p.__dict__)
>>> {'__module__': '__main__', 'myName': 'jsl', '__init__': , 'get_name': , '__dict__': , '__weakref__': , '__doc__': None}
>>> {'name': 'j', 'age': 20}

在类中添加属性,方法,但创建实例对象之后,实例对象并没有get_name方法,只有self.XX这些属性,说明Python中类的普通方法、类方法、静态方法、全局变量以及一些内置属性都是放在类对象字典dict里面,实例对象只存储实例属性。
既然实例属性没有类方法但为什么还能调用?因为实例属性与self建立了对应关系,一个外,一个内,相当于类方法在类外的指针。

2.属性访问控制

通常访问类或者实例对象时,会牵扯到一些属性访问的魔法方法:

  • getattr(self, name):访问不存在的属性时调用;
  • getattribute(self, name):访问所有属性的方法,它覆盖了getattr方法,毕竟“所有属性”包含了“不存在的属性”,故而在访问时先调用getattribute方法,若不存在则调用getattr方法;
  • setattr(self, name, value):设置实例对象的新的属性时调用,包括在_ _ init _ _中初始化的设置行为;
  • delattr(self, name):删除一个实例对象的属性时调用。
class Foo:
    x = 1
    def __init__(self, y):
        self.y = y

    def __getattr__(self, item):
        print('from getattr:你找的属性不存在')

    def __setattr__(self, key, value):
        print('from setattr:设置了一个属性')
        # self.key=value #这就无限递归了
        self.__dict__[key] = value #应该使用它

    def __delattr__(self, item):
        print('from delattr:删除了一个属性')
        # del self.item #无限递归了
        self.__dict__.pop(item)

    def __getattribute__(self, item):
        print('from getattribute:访问了一个属性')
        return super().__getattribute__(item)

f = Foo(10)
print('-'*50 + '\n')
f.z = 3
print('-'*50 + '\n')
f.__dict__['a'] = 3
print('-'*50 + '\n')
del f.a
print('-'*50 + '\n')
f.adasd
>>> from setattr:设置了一个属性
>>> from getattribute:访问了一个属性
>>> --------------------------------------------------
>>> 
>>> from setattr:设置了一个属性
>>> from getattribute:访问了一个属性
>>> --------------------------------------------------
>>> 
>>> from getattribute:访问了一个属性
>>> --------------------------------------------------
>>> 
>>> from delattr:删除了一个属性
>>> from getattribute:访问了一个属性
>>> --------------------------------------------------
>>> 
>>> from getattribute:访问了一个属性
>>> from getattr:你找的属性不存在

3.描述符

在前面我们了解的对象属性访问和行为控制的一些特殊方法,例如_ _ getattribute_ _、 _ _ getattr _ _、 _ _ setattr _ _ 、 _ _ delattr _ _ 。这些方法应当具有属性的”普适性”,可以用于属性查找、设置、删除的一般方法,也就是说所有的属性都可以使用这些方法实现属性的查找、设置、删除等操作。但是,这并不能很好地实现对某个具体属性的访问控制行为。如果单单去修改 _ _ setattr _ _ 方法满足它,那这个方法便有可能不能支持其他的属性设置。

在类中设置属性的控制行为不能很好地解决问题,Python给出的方案是上述访问控制方法用来实现属性查找、设置、删除的一般逻辑,而对属性的控制行为就由属性对象来控制。这里单独抽离出来一个属性对象,在属性对象中定义这个属性的查找、设置、删除行为。这个属性对象就是描述符。

实现了 _ _ get _ _ () 、_ _ set _ _ () 、_ _ delete _ _ () 、中至少一个方法的类,称描述符,细分的话,称:

  • 数据描述符:实现了 _ _ get _ _ () 、_ _ set _ _ ()方法,可读写
  • 非数据描述符:仅实现 _ _ get _ _ ()方法,只能被读取

描述符的方法具体作用是:

  • get(self, instance, owner):定义当试图取出描述符的值时的行为。
  • set(self, instance, value):定义当描述符的值改变时的行为。
  • delete(self, instance):定义当描述符的值被删除时的行为。

在访问对象属性obj.attr时,一般调用_ _ getattribute _ _方法,顺序为:(1)数据描述符;(2) _ _ dict _ _ 属性;(3)非数据描述符

class RevealAccess:
    def __init__(self, initval=None, name='var'):
        self.val = initval
        self.name = name

    def __get__(self, instance, owner):
        print('获取..', self.name)
        return self.val

    def __set__(self, instance, value):
        print('设置值:', self.name)
        self.val = value

class Myclass:
    x = RevealAccess(10, 'var "x"')
    y = 5
    def __init__(self):
        self.x = self.y

m = Myclass()
print(m.x)
m1 = Myclass()
m1.x = 20
print(m1.x)
>>> 设置值: var "x"
>>> 获取.. var "x"
>>> 5
>>> 设置值: var "x"
>>> 设置值: var "x"
>>> 获取.. var "x"
>>> 20

上述RevealAccess类的实例作为Myclass类的一个x属性,RevealAccess类实现了get、set方法,是一个描述符。对Myclass类中的x属性进行访问、赋值操作时,getattribute、setattr等方法也执行了,但x作为描述符属性,会特殊的执行get、set方法。

4.运算符重载

运算符重载,就是对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型。

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 加法重载
    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Vector2D(x, y)

    # 减法重载
    def __sub__(self, other):
        return Vector2D(self.x - other.x, self.y - other.y)

    def __str__(self):
        return "Vector2D({}, {})".format(self.x, self.y)

    # 乘法重载
    def __mul__(self, other):
        return Vector2D(self.x * other.x, self.y * other.y)

    # 除法重载
    def __truediv__(self, other):
        return Vector2D(self.x / other.x, self.y / other.y)

    # a += b , 就地操作
    def __iadd__(self, other):
        return self.__add__(other)

v1 = Vector2D(2, 3)
v2 = Vector2D(1, 2)
print(v1 - v2)
print(v1 + v2)
print(v1 * v2)
print(v1 / v2)
print(v1.__iadd__(v1))
>>> Vector2D(1, 1)
>>> Vector2D(3, 5)
>>> Vector2D(2, 6)
>>> Vector2D(2.0, 1.5)
>>> Vector2D(4, 6)

5.序列

  • 如下例子,声明一副扑克牌(无大小王)
import collections
Card = collections.namedtuple('Card', ['rank', 'suit'])

class Puke:
    ranks = [str(n) for n in list(range(2, 11)) + list('JQKA')]
    suit = '黑桃 方块 梅花 红心'.split()

    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suit for rank in self.ranks]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, item):
        return self._cards[item]

    def __setitem__(self, key, value):
        self._cards[key] = value

p = Puke()
print(list(p))
>>> [Card(rank='2', suit='黑桃'), Card(rank='3', suit='黑桃'), Card(rank='4', suit='黑桃'), ...........

认为实现了_ _ len _ _方法和 _ _ getitem _ _方法就会认为是序列

6.上下文管理器

用with open操作文件就是一个上下文管理的例子

  1. 上下文表达式:with open('test.txt') as f:
  2. 上下文管理器:open('test.txt')
  3. f 不是上下文管理器,应该是资源对象。

在一个类中定义了__ enter __方法和 __ exit __ 方法,这个类的实例称上下文管理器。

import sys
class lookingGlass:
    def __enter__(self):
         #stdout函数  输出到控制台
        self.original_write = sys.stdout.write
        sys.stdout.write = self.reverse_write
        return '这是正常的句子'

    def reverse_write(self, text):
        self.original_write(text[::-1])

    def __exit__(self, exc_type, exc_val, exc_tb):#处理异常
        """
        :param exc_type: 异常的类型
        :param exc_val: 异常实例 except
        :param exc_tb: traceback最终对象
        :return:
        """
        sys.stdout.write = self.original_write
        return True#返回True代表已经正确处理,否则代表异常未处理

with lookingGlass() as what:
    print('123456')
    print(what)
>>> 654321
>>> 子句的常正是这

处理异常,通常都是使用 try...execept.. 来捕获处理的。这样做一个不好的地方是,在代码的主逻辑里,会有大量的异常处理代理,这会很大的影响我们的可读性,使用 with 将异常的处理隐藏起来。
上下文管理协议的一个强大之处在于异常可以在__ exit__ 进行捕获并由你自己决定如何处理,是抛出呢还是在这里就解决了。在__ exit__ 里返回 True(没有return 就默认为 return False),就相当于告诉 Python解释器,这个异常我们已经捕获了,不需要再往外抛了。

  • contextlib装饰器
    上面的例子中,我们只是为了构建一个上下文管理器,却写了一个类。如果只是要实现一个简单的功能,写一个类未免有点过于繁杂。这时候,我们就想,如果只写一个函数就可以实现上下文管理器就好了。
    这个点Python早就想到了。它给我们提供了一个contextlib 装饰器,你只要按照它的代码协议来实现函数内容,就可以将这个函数对象变成一个上下文管理器。
import sys
import contextlib
@contextlib.contextmanager
def looking_glass():
    original_write = sys.stdout.write
    def rever_write(text):
        original_write(text[::-1])
    sys.stdout.write = rever_write
    try:
        yield '123456'
    except Exception:
        print('处理异常')
    sys.stdout.write = original_write
    # 以yield为分界点,yield之后的代码,相当于exit中的代码,
    # yield的值,相当于enter中的返回值
    # yield之前的代码相当于enter中的代码
with looking_glass() as what:
    print('abcdefg')
    print(what)
>>> gfedcba
>>> 654321

你可能感兴趣的:(Python学习Day8(上) ---- 一些魔法方法)