python类之特殊属性和魔术方法

4 总结

运算符重载的应用场景
往往是面向对象实现的类，需要做大量的运算，而运算符是这种运算在数学上最常见的表达方式，int 类中，几乎实现了所有操作符，可以作为参考

7 容器相关方法

1 简介

2 实例

#!/usr/local/bin/python3.6
#coding:utf-8
class  Item:
    def __init__(self,name,*args):
        self.name=name
        self.lst=list(args)
    def  __len__(self):
        return len(self.lst)
    def __iter__(self):
        return iter(self.lst)  # 此处返回是一个迭代器,必须是一个迭代器
    def __add__(self, other):  # 此处使用+ 号返回一个列表
        self.lst.append(other)
        return self
    def __getitem__(self, index):  # 此处应用于列表时，表示为索引，此处应用于字典时，表示key
        if  index   > len(self.lst):
            print ('Key Error')
        else:
            return self.lst[index]
    def __setitem__(self, index, value): # 此处表示修改属性列表中的值
        if  index   > len(self.lst):
            print ('Key Error')
        else:
            self.lst[index]=value
            return   self
    # def __missing__(self, key): # 此方法只能适用于字典的处理
    #     pass
    def  __repr__(self):
        return str(self.lst)  # 此处对其进行可视化处理
a=Item('MySQL',12,3,45,678,8909)
print (len(a))
# 此处调用了__iter__方法
for i  in a:
    print (i)
print ('++++++++++++++++')
print (a[2])  # 此处调用了__getitem__方法，用于获取值
a+10  # 此处使用__add__方法进行加入，此处追加到列表的末尾
print (a[-1])  # 获取列表的最后一个元素，则得到此值
a[1]=20  # 使用__setitem__方法修改属性
print (a[1])  #返回对应位置的值
a+10+20+30+40  # 此处进行连加操作，因为其add方法返回是self,因此每次赋值后都会增加
print (a)

结果如下

8 可调用对象

1 简介

在python中一切皆对象，函数也不例外
可调用对象
方法
__call__类中出现该方法，实例就可以像函数一样调用，
可调用对象： 定义一个类，并实例化得到其实例，将实例像函数一样调用。调用是实例的，不是类的。

2 实例

#!/usr/local/bin/python3.6
#coding:utf-8
def  foo():
    print (foo.__module__,foo.__name__)

foo.__call__()# 此处的方法和下面的相同，皆是调用该函数
foo()
print (dir(foo))

结果如下

函数的可调用原因是函数实现了\call()方法

#!/usr/local/bin/python3.6
#coding:utf-8
def  foo():
    print (foo.__module__,foo.__name__)

print (foo.__call__) # 此处返回一个函数对象是一个wrapper
foo.__call__()# 此处的方法和下面的相同，皆是调用该函数
foo()

结果如下

#!/usr/local/bin/python3.6
#coding:utf-8
class  A:
    def __init__(self):
        self.x=1
    def __call__(self, *args):  # 此处的第一个是self，表明其是给实例使用的，并不是给类使用的
        return   args  # 此处返回一个元组

print (A()(12344))  # 此处第一个括号是实例化，第二个是传递参数并调用实例

3 练习

利用封装完成斐波那契额数列

方法1

#!/usr/local/bin/python3.6
#coding:utf-8
class  A:
    def  __call__(self,num):
        a,b=0,1
        for  i in  range(num):
            print (b)
            a,b=b,a+b
A()(10)

结果如下

方法2

#!/usr/local/bin/python3.6
#coding:utf-8
class  A:
    def __init__(self):
        self.lst=[1,1,2]
    def  __call__(self,num):
        if  num < 3:
            return   self.lst[:num]
        else:
            for  i in range(num-3):
                self.lst.append(self.lst[-1]+self.lst[-2])
            return  self.lst
print (A()(10))

结果如下

添加功能如下

#!/usr/bin/poython3.6
#conding:utf-8
class  A:
    def __init__(self):
        self.lst=[1,1,2]
    def  __len__(self):
        return len(self.lst)
    def  __call__(self,x):
        if  len(self.lst)  >  x:
            return  self.lst[:x]
        for  i  in   range(2,x):
            self.lst.append(self.lst[i]+self.lst[i-1])
        return  self.lst
    def __getitem__(self, item):
        if item < 0:
            return  None
        if  len(self) > item:
            return self.lst[item]
    def __iter__(self):
        return  iter(self.lst)

a=A()
print (a(10))
print (a[4])
for x in a:
    print (x)

结果如下

9 上下文管理

1 推导过程

文件IO操作可以对文件对象进行上下文管理，使用with...as语法
推导过程

#!/usr/bin/poython3.6
#conding:utf-8
# 此处为默认的上下文管理
# with   open('test')  as f:
#     pass

class A:
    pass

with  A()  as  f:
    pass

结果如下

提示需要添加 __enter__属性
添加如下

#!/usr/bin/poython3.6
#conding:utf-8
# 此处为默认的上下文管理
# with   open('test')  as f:
#     pass

class A:
    def  __enter__(self):
        pass

with  A()  as  f:
    pass

结果如下

提示需要添加 __exit__属性

#!/usr/bin/poython3.6
#conding:utf-8
# 此处为默认的上下文管理
# with   open('test')  as f:
#     pass

class A:
    def  __enter__(self):
        pass
    def  __exit__(self, exc_type, exc_val, exc_tb):
        pass
with  A()  as  f:
    pass

结果如下

#!/usr/bin/poython3.6
#conding:utf-8
class A:
    def  __enter__(self):
        print ('__enter__')
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
with  A()  as  f:
    pass

由此图可知，其调用顺序是先调用_enter_，后调用_exit_

2 属性

exit 中变量的含义：
1 exc_type： 异常类型，如果没有异常，则返回是None
2 exc_tb:异常追踪信息，如果没有异常，则是None
3 exc_va ：异常对应的值，如果没异常，则是None
此处的return 用于压制异常，若此处是False,则会抛出异常，等效True 或 False

缺少了enter 进不去，缺少了exitc出不来

#!/usr/bin/poython3.6
#conding:utf-8
class A:
    def  __init__(self):
        print ('init instance')
    def  __enter__(self):
        print ('__enter__')
        return 1
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
p=A()
with  p  as  f:  # 此处的p是__enter__的返回值，是f的参数，若此处__enter__无return，则默认返回为None，无意义
    print (p==f) # 此处用于比较p和f的关系 
    print (p is f)
    print (p)
    print (f)

上述结论如下：
实例化对象的时候，并不会调用enter，进入with语句块会调用__enter__方法，然后执行语句体，最后离开with语句块的时候，调用__exit__方法

with 可以开启一个上下文运行环境，在执行前做一些准备工作，执行后做一些收尾工作。

3 上下文管理对异常的处理方式

#!/usr/bin/poython3.6
#conding:utf-8
class A:
    def  __init__(self):
        print ('init instance')
    def  __enter__(self):
        print ('__enter__')
        return 1
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
p=A()
with  p  as  f:  # 此处的p是__enter__的返回值，是f的参数，若此处__enter__无return，则默认返回为None，无意义
    raise Exception('Error')  # 此处抛出异常,一般的，抛出异常后，语句将不会再次执行
    print (p==f) # 此处用于比较p和f的关系
    print (p is f)
    print (p)
    print (f)

结果如下

由此证明，当异常抛出时，exit对应的语句仍然会被执行。

#!/usr/bin/poython3.6
#conding:utf-8
import  sys
class A:
    def  __init__(self):
        print ('init instance')
    def  __enter__(self):
        print ('__enter__')
        return 1
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
p=A()
with  p  as  f:  # 此处的p是__enter__的返回值，是f的参数，若此处__enter__无return，则默认返回为None，无意义
    sys.exit()  # 此处的是直接退出
    print (p==f) # 此处用于比较p和f的关系
    print (p is f)
    print (p)
    print (f)

结果如下

上述证明，此处满足上述清理工作，上下文管理非常安全，能够保证变量的顺利清除工作。

#!/usr/bin/poython3.6
#conding:utf-8
import  sys
class A:
    def  __init__(self):
        print ('init instance')
    def  __enter__(self):
        print ('__enter__')
        return self
    def  __exit__(self, exc_type, exc_val, exc_tb):
        print ('__exit__')
        print (exc_tb) #追踪信息
        print (exc_type)  # 类型
        print (exc_val)  # 值
        return  1  # 此处设置为1 是压制异常，不让其出现
p=A()
with  p  as  f:  # 此处的p是__enter__的返回值，是f的参数，若此处__enter__无return，则默认返回为None，无意义
    raise   Exception('Error1234454')
    print (p==f) # 此处用于比较p和f的关系
    print (p is f)
    print (p)
    print (f)

结果如下

4 通过此方法进行函数执行时长计算

之前的计算时长方式

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import  time
import  sys
def  wapper(fn):
    def _wapper(*args,**kwargs):
        start_time=datetime.datetime.now()
        ret  =  fn(*args,**kwargs)
        delta=(datetime.datetime.now()-start_time).total_seconds()
        print ("{} 函数的执行时间为: {}".format(fn.__name__,delta))
        return  ret
    return  _wapper
@wapper
def  add(x,y):
    time.sleep(2)
    return  x+y

add(4,5)

结果如下

使用上下文管理的方式统计函数执行时间

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import  time
class Timer:
    def  __init__(self,fn):
        self.fn=fn
    def  __enter__(self):
        self.start_time=datetime.datetime.now()
        return  self.fn  # 此处对应的是as前面的值
    def __exit__(self, exc_type, exc_val, exc_tb):
        delat=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("函数{} 的执行时间为: {}".format(self.fn.__name__,delat))
        return  1
def  add(x,y):
    return  x+y
p=Timer(add)
with   p  as f:  # 此处调用的是__enter__的返回值，重命名为f
    time.sleep(2)
    print (f(4,5))

结果如下

5 类装饰器的应用

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import time
from functools import  wraps
class A:
    def __init__(self,fn):
        self.fn=fn
    def __call__(self,*args,**kwargs):  #实例调用支持的方法
        self.start_time=datetime.datetime.now()
        ret = self.fn(*args,**kwargs)
        delta=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("{} 函数的执行时间为: {}".format(self.fn.__name__,delta))
        return  ret
@A   #add=A(add)
def add(x,y):
    time.sleep(2)
    return  x+y
print  (add(10,20))

结果如下

6 进行属性覆盖如下

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import time
from functools import  wraps
class A:
    def __init__(self,fn):
        self.fn=fn
    def __call__(self,*args,**kwargs):  #实例调用支持的方法
        self.start_time=datetime.datetime.now()
        ret = self.fn(*args,**kwargs)
        delta=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("{} 函数的执行时间为: {}".format(self.fn.__name__,delta))
        return  ret
@A   #add=A(add)
def add(x,y):
    '''this is function'''
    time.sleep(2)
    return  x+y
print  (add(10,20))
print  (add.__doc__) # 此处打印出文档

结果如下

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import time
from functools import  wraps
class A:
    def __init__(self,fn):
        self.__doc__=fn.__doc__  # 此处只能进行部分的属性覆盖操作
        self.__name__=fn.__name__
        self.fn=fn
    def __call__(self,*args,**kwargs):  #实例调用支持的方法
        self.start_time=datetime.datetime.now()
        ret = self.fn(*args,**kwargs)
        delta=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("{} 函数的执行时间为: {}".format(self.fn.__name__,delta))
        return  ret
@A   #add=A(add)
def add(x,y):
    '''this is function'''
    time.sleep(2)
    return  x+y
print  (add(10,20))
print  (add.__doc__) # 此处打印出文档

结果如下

#!/usr/bin/poython3.6
#conding:utf-8
import  datetime
import time
from functools import  wraps
class A:
    def __init__(self,fn):
        wraps(fn)(self)  # 调用此方法完成属性的覆盖操作，此处第一个是原函数，后面是现在的函数
        self.fn=fn
    def __call__(self,*args,**kwargs):  #实例调用支持的方法
        self.start_time=datetime.datetime.now()
        ret = self.fn(*args,**kwargs)
        delta=(datetime.datetime.now()-self.start_time).total_seconds()
        print ("{} 函数的执行时间为: {}".format(self.fn.__name__,delta))
        return  ret
@A   #add=A(add)
def add(x,y):
    '''this is function'''
    time.sleep(2)
    return  x+y
print  (add(10,20))
print  (add.__doc__) # 此处打印出文档

结果如下

7 contextlib.contextmanager

是一个装饰器实现上下文管理，装饰一个函数，而不像类一样可以实现__enter__和__exit__方法

对下面的函数有要求，必须有yield，也就是这个函数必须返回一个和生成器，且只有一个yield的值。

#!/usr/bin/poython3.6
#conding:utf-8
import   contextlib
@contextlib.contextmanager
def foo():
    print ('enter')
    yield
    print ('exit')

with  foo() as f:
    pass

结果如下

#!/usr/bin/poython3.6
#conding:utf-8
import   contextlib
@contextlib.contextmanager
def foo():
    print ('enter')
    yield  [1,2,34,56,5867,856,867,]  # 此处相当分界线，用于分割上面和下面的执行
    print ('exit')

with  foo() as f:
    print (f)

#!/usr/bin/poython3.6
#conding:utf-8
import   contextlib
@contextlib.contextmanager
def foo():
    print ('enter')
    yield  [1,2,34,56,5867,856,867,]  # 此处相当分界线，用于分割上面和下面的执行
    print ('12344exit')

with  foo() as f:
    try:
        raise Exception
    finally:
        print ('exit')
    print (f)

结果如下

修改异常捕获如下

#!/usr/bin/poython3.6
#conding:utf-8
import   contextlib
@contextlib.contextmanager
def foo():
    print ('enter')
    try:
        yield  [1,2,34,56,5867,856,867,]  # 此处相当分界线，用于分割上面和下面的执行
    finally:  # 放置在此处能够执行后面的相关操作
        print ('12344exit')

with  foo() as f:
    raise  Exception
    print (f)

结果如下

总结： 如果业务逻辑简单可以使用函数加装饰器的方式，如果业务复杂，用类的方式加__enter__和__exit__更方便

8 上下文的应用场景

1 增强功能
在代码执行的前后增加代码，以增强其功能，类似装饰器的功能

2 资源管理
打开了资源需要关闭，例如文件对象，网络链接，数据库链接等

3 权限验证

在执行代码之前，做权限的验证，在enter中处理
在代码进入的时候进行处理，在权限出去则不管

10 反射

1 概述

运行时：区别于编译时，指的是程序被加载到内存中执行的时候。

反射：python中，能够通过一个对象，找出其type,class,attribute或method的能力，成为反射或自醒。

具有反射能力的函数type(),isinstance(),callable()(查看对象能否被调用),dir(),getattr()

2 内建函数

object 可以是类或实例 
语法格式:
getattr(object,name[,default]) : 通过name 返回object的属性值，当属性不存在时，将使用default返回，如果没有default，则抛出attributeError，name 必须位字符串 

setattr(object,name,value) object 的属性存在，则覆盖，若不存在，则新增。

hasattr(object,name)  判断对象是否有这个名字属性，name必须时字符串

3 实例

#!/usr/bin/poython3.6
#conding:utf-8
class  A:
    x=10
    def __init__(self):
        self.x=5

setattr(A,'y',20)  # 动态添加类属性位y=20
print (A.__dict__)  # 打印属性信息列表
a=A()
setattr(a,'z',100)  # 实例动态增加属性
print (getattr(A,'y')) # 查看增加的属性是否存在
print (getattr(A,'x'))  # 定义属性是否存在
print (getattr(a,'y'))  # 查看实例中是否存在该属性
print (a.__dict__) # 查看实例属性信息中是否具有'z'属性
print (A.__dict__)  # 打印属性信息列表，此处查看当实例属性信息增加后，类属性信息是否增加

if hasattr(a,'z'):
    print ("{} 函数存在此属性 {}".format('a','y'))

结果如下

进阶

#!/usr/bin/poython3.6
#conding:utf-8
class  A:
    x=10
    def __init__(self,y):
        self.x=5
        self.y=y
a=A(20)
setattr(A,'printf',lambda  self: 1 ) #此处增加一个类的属性，并通过参数调用

setattr(a,'myclass',lambda  : 10 ) # 此处增加一个实例属性
print (a.printf())  # 打印此类的属性结果如下
print (getattr(a,'printf')())  # 因为此处是函数，因此需要通过()来进行调用
print (getattr(a,'myclass')())
if not  hasattr(A,'sub'):  # 此处添加一个类的函数属性，实现函数之前的差运算
    setattr(A,'sub',lambda self,other : A(self.y- other.y) )
if not  hasattr(A,'add'): # 此处添加一个类的属性，实现函数之间的和的计算
    setattr(A,'add',lambda self,other: (self.y + other.y))
print (a.__dict__)
print (A.__dict__)
b1=A(10)
b2=A(20)
print (b2.sub(b1))
print (b1.add(b2))

结果如下

注意：
这种动态增加属性的方式是运行时改变类或者实例的方式，比装饰器和Mixin更加灵活，其具有更大的使用用途

4 实例应用

实现分发器
简单雏形

#!/usr/bin/poython3.6
#conding:utf-8
class  Dispatcher:
    def cmd1(self):  # 此处在内部定义一个方法
        print ('cmd10')
    def run(self):  # 此处用于执行
        while True:
            cmd=input("plase  input str:")  #退出程序命令
            if  cmd.strip() == 'q'  or  cmd.strip() == 'quit':
                return
            getattr(self,cmd.strip(),self.__defaltfun)()  # 此处用于获取该方法，若不存在，则执行默认程序
    def __defaltfun(self):
        print ('default')
a=Dispatcher()
a.run()

结果如下

#!/usr/bin/poython3.6
#conding:utf-8
class  Dispatcher:
    def cmd1(self):  # 此处在内部定义一个方法
        print ('cmd10')
    def  reg(self,cmd,fn):
        if isinstance(cmd,str):
            setattr(self.__class__,cmd.strip(),fn)  # 此处使用的是类，若是实例化，则需要进行下面将self传入进去的方式进行调用
        else:
            print ('TypeError')
    def run(self):
        while True:
            cmd = input("plase  input str:")
            if  cmd.strip()  == 'q'  or  cmd.strip() == 'quit':
                return
            getattr(self,cmd.strip(),self.defaultfun)()
    def defaultfun(self):
        print ('default')

a=Dispatcher()
a.reg('cmd2',lambda  self :print (2)) 
a.reg('cmd3',lambda  self :print (3))
a.run()

结果如下

5 反射相关魔术方法

实例如下：

#!/usr/bin/poython3.6
#conding:utf-8

class  Base:
    a=5

class A(Base):
    m=6
    def __init__(self,x):
        print ('init')
        self.x=x  #此处定义了属性，所以下面的__setattr__被执行了一次，初始化先执行，之后__setattr__这个属性再执行一次
    def __getattr__(self, item):#针对上述无法查找到的属性，则执行此属性，可配置其值为None来弥补此属性值
        print ('__getattr__',item)
        self.__dict__[item]=None
    def __setattr__(self, key, value): #设置一个属性时，一定要执行，至于是否生效，则另当别论
        print ('__setattr__',key,value)
    def __delattr__(self, item): #此处在删除一个实例的属性进行的操作，只要实例能找到，都能够删除
        print ('__delattr__',item)
A.n=50 # 此处是正常的添加类属性，不会产生其他的报错
a=A(20)
print (a.__dict__)
a.b  # 针对不存在的属性进行调用
a.x=30 # 设置实例的属性变化
a.c=200 #添加一个不存在的属性
del  a.a # 删除一个实例的属性
print (a.__dict__)

结果如下

#!/usr/bin/poython3.6
#conding:utf-8

class  Base:
    a=5

class A(Base):
    m=6
    def __init__(self,x):
        print ('init')
        self.x=x  #此处定义了属性，所以下面的__setattr__被执行了一次，初始化先执行，之后__setattr__这个属性再执行一次
    def __getattr__(self, item):#针对上述无法查找到的属性，则执行此属性，可配置其值为None来弥补此属性值
        print ('__getattr__',item)
        self.__dict__[item]=None
    def __setattr__(self, key, value): #设置一个属性时，一定要执行，至于是否生效，则另当别论
        print ('__setattr__',key,value)
    def __delattr__(self, item): #此处在删除一个实例的属性进行的操作，只要实例能找到，都能够删除
        print ('__delattr__',item)

    def __getattribute__(self, item):  #此处是在字典属性之前进行拦截执行
        print ('__getattribute__',item)
a=A(20)

print (a.x)

结果如下

实例的所有属性的访问，第一个都会调用__getattribute__方法，其阻止了属性查找，该方法应该返回(计算后)值或者抛出一个attributeError 异常
他的return 值将作为属性查找的结果，如果抛出attributeError 异常，则会直接调用__getattr__方法，因为表示属性没有找到

#!/usr/bin/poython3.6
#conding:utf-8

class  Base:
    a=5

class A(Base):
    m=6
    def __init__(self,x):
        print ('init')
        self.x=x  #此处定义了属性，所以下面的__setattr__被执行了一次，初始化先执行，之后__setattr__这个属性再执行一次
    def __getattr__(self, item):#针对上述无法查找到的属性，则执行此属性，可配置其值为None来弥补此属性值
        print ('__getattr__',item)
        # self.__dict__[item]=None
    def __setattr__(self, key, value): #设置一个属性时，一定要执行，至于是否生效，则另当别论
        print ('__setattr__',key,value)
    def __delattr__(self, item): #此处在删除一个实例的属性进行的操作，只要实例能找到，都能够删除
        print ('__delattr__',item)

    def __getattribute__(self, item):  #此处是在字典属性之前进行拦截执行
        print ('__getattribute__',item)
        raise  AttributeError(item)  # 此处若属性不存在，抛出异常，则直接进入getattr中机型处理
a=A(20)

print (a.x)

#!/usr/bin/poython3.6
#conding:utf-8

class  Base:
    a=5

class A(Base):
    m=6
    def __init__(self,x):
        print ('init')
        self.x=x  #此处定义了属性，所以下面的__setattr__被执行了一次，初始化先执行，之后__setattr__这个属性再执行一次
    def __getattr__(self, item):#针对上述无法查找到的属性，则执行此属性，可配置其值为None来弥补此属性值
        print ('__getattr__',item)
        # self.__dict__[item]=None
    def __setattr__(self, key, value): #设置一个属性时，一定要执行，至于是否生效，则另当别论
        print ('__setattr__',key,value)
    def __delattr__(self, item): #此处在删除一个实例的属性进行的操作，只要实例能找到，都能够删除
        print ('__delattr__',item)

    def __getattribute__(self, item):  #此处是在字典属性之前进行拦截执行
        print ('__getattribute__',item)
        # raise  AttributeError(item)  # 此处若属性不存在，抛出异常，则直接进入getattr中机型处理
        return object.__getattribute__(self,item)  #此处表示若不存在，则直接去object中进行查找，并得到其访问的值
a=A(20)

print (a.b)

结果如下

注意：\getattribute\ 方法中为了避免在该方法中无限递归，实现了应该永久调用基类的同名方法以访问需要的任何属性，除非你明确知道\getattribute\方法用来做什么，否则不要使用它。

6 总结：

本文标题：python类之特殊属性和魔术方法
文章起源：http://www.cdkjz.cn/article/pojcih.html