面向对象高级（重点）

反射

通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

四个可以实现自省的函数：hasattr，getattr，setattr，delattr

这四个函数适用于类和对象（一切皆对象，类本身也是对象）

# hasattr（object，name）   判断object中有没有一个name字符串对应的方法和属性

# getattr（object，name，default=None）  调用object中name对应的方法和属性，如果没有会报错，所以我们平时会在最后写一个None

class Foo:
     def run(self):
         while True:
             cmd=input('>>:').strip()
             if hasattr(self,cmd):
                 func=getattr(self,cmd)
                 func()
     def Download(self):
         print('download...')

     def upload(self):
         print('upload...')
 obj=Foo()
 obj.run()

# setattr（x，y，v）   设置属性

# delattr（x，y）  删除属性

class People:
    country='China'
    def __init__(self,name):
        self.name=name
    def tell(self):
        print('%s is aaa'%self.name)
obj=People('egon')

People.X=111
setattr(People,'X',111)
print(People.X)

setattr(obj,'age',18)
print(obj.__dict__)

delattr(People,'country')
print(People.__dict__)

 

class Foo(object):
    staticField = "old boy"

    def __init__(self):
        self.name = 'wupeiqi'

    def func(self):
        return 'func'

    @staticmethod
    def bar():
        return 'bar'


print(getattr(Foo, 'staticField'))
print(getattr(Foo, 'func'))
print(getattr(Foo, 'bar'))

类也是对象

使用反射的好处

好处一：实现可插拔机制

有俩程序员，一个lili，一个是egon，lili在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，lili想到了反射，使用了反射机制lili可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

总之反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能

View Code

__str__

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def __str__(self):
        return '<名字：%s 年龄：%s 性别：%s >'%(self.name,self.age,self.sex)
obj=People('egon',18,'male')
print(obj)

#__str__改变对象的字符串显示

__del__

注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__

class Mysql:
    def __init__(self,file,mocode='r',encoding='utf-8'):
        self.file=file
        self.mocode=mocode
        self.encodeing=encoding
        self.fobj=open(file,mode=mocode,encoding=encoding)
    def __str__(self):
        msg='''
        file:%s
        mocode:%s
        encoding:%s
        '''%(self.file,self.mocode,self.encodeing)
    def __del__(self):
        self.fobj.close()
f=Mysql('D:\Python\第五周\day22\settings.py',mocode='r',encoding='utf-8')

res=f.fobj.read()
print(res)

# __del__析构方法，当对象在内存中被释放时，自动触发执行。主要是用来回收资源，

典型的应用场景：

创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中

当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源

f=open('a.txt') #做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件
del f #只回收用户空间的f，操作系统的文件还处于打开状态

#所以我们应该在del f之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是
f=open('a.txt')
读写...
f.close()
很多情况下大家都容易忽略f.close,这就用到了with上下文管理

__call__

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

#  对象后加括号触发执行__call__，然后将对象的本省当做第一个参数传给self将调用括号内的值传给*args，**kwargs

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

元类（metaclass）

正如一直讲的一句话 “一切皆对象” ，类也是对象，而类的类就叫做元类

exec（可以调用执行字符串当中的代码）
exec：三个参数

参数一：字符串形式的命令

参数二：全局作用域（字典形式），如果不指定，默认为globals()

参数三：局部作用域（字典形式），如果不指定，默认为locals(
#可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中
g={
    'x':1,
    'y':2
}
l={}

exec('''
global x,z
x=100
z=200

m=300
''',g,l)

print(g) #{'x': 100, 'y': 2,'z':200,......}
print(l) #{'m': 300}

exec

python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)，因而我们可以将类当作一个对象去使用，同样满足第一类对象的概念，可以：

  1、把类赋值给一个变量

  2、把类作为函数参数进行传递

  3、把类作为函数的返回值

  4、在运行时动态地创建类 

class Foo:
    pass

f1=Foo() #f1是通过Foo类实例化的对象

1 #type函数可以查看类型，也可以用来查看对象的类，二者是一样的
2 print(type(f1)) # 输出：<class '__main__.Foo'>     表示，obj 对象由Foo类创建
3 print(type(Foo)) # 输出：<type 'type'> 

f1是由Foo产生的对象，我们可以通过type（f1）查看他的类是Foo，我们使用
type（Foo）可以看到类Foo的类是type，这个类就叫做元类

元类是类的类，是类的模板

元类是用来控制如何创建类的，正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为

元类的实例化的结果为我们用class定义的类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)

type是python的一个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象

自定义控制元类

一个类没有声明自己的元类，默认他的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类

 

#知识储备：
    #产生的新对象 = object.__new__(继承object类的子类)

#步骤一：如果说People=type(类名,类的父类们,类的名称空间)，那么我们定义元类如下，来控制类的创建
class Mymeta(type):  # 继承默认元类的一堆属性
    def __init__(self, class_name, class_bases, class_dic):
        if '__doc__' not in class_dic or not class_dic.get('__doc__').strip():
            raise TypeError('必须为类指定文档注释')

        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')

        super(Mymeta, self).__init__(class_name, class_bases, class_dic)


class People(object, metaclass=Mymeta):
    country = 'China'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        print('%s is talking' % self.name)


#步骤二：如果我们想控制类实例化的行为，那么需要先储备知识__call__方法的使用
class People(object,metaclass=type):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __call__(self, *args, **kwargs):
        print(self,args,kwargs)


# 调用类People，并不会出发__call__
obj=People('egon',18)

# 调用对象obj(1,2,3,a=1,b=2,c=3)，才会出发对象的绑定方法obj.__call__(1,2,3,a=1,b=2,c=3)
obj(1,2,3,a=1,b=2,c=3) #打印：<__main__.People object at 0x10076dd30> (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}

#总结：如果说类People是元类type的实例，那么在元类type内肯定也有一个__call__，会在调用People('egon',18)时触发执行，然后返回一个初始化好了的对象obj


#步骤三：自定义元类，控制类的调用（即实例化）的过程
class Mymeta(type): #继承默认元类的一堆属性
    def __init__(self,class_name,class_bases,class_dic):
        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')

        super(Mymeta,self).__init__(class_name,class_bases,class_dic)

    def __call__(self, *args, **kwargs):
        #self=People
        print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}

        #1、实例化People，产生空对象obj
        obj=object.__new__(self)


        #2、调用People下的函数__init__，初始化obj
        self.__init__(obj,*args,**kwargs)


        #3、返回初始化好了的obj
        return obj

class People(object,metaclass=Mymeta):
    country='China'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def talk(self):
        print('%s is talking' %self.name)



obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}


#步骤四：
class Mymeta(type): #继承默认元类的一堆属性
    def __init__(self,class_name,class_bases,class_dic):
        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')

        super(Mymeta,self).__init__(class_name,class_bases,class_dic)

    def __call__(self, *args, **kwargs):
        #self=People
        print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}

        #1、调用self，即People下的函数__new__，在该函数内完成：1、产生空对象obj 2、初始化 3、返回obj
        obj=self.__new__(self,*args,**kwargs)

        #2、一定记得返回obj，因为实例化People(...)取得就是__call__的返回值
        return obj

class People(object,metaclass=Mymeta):
    country='China'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def talk(self):
        print('%s is talking' %self.name)


    def __new__(cls, *args, **kwargs):
        obj=object.__new__(cls)
        cls.__init__(obj,*args,**kwargs)
        return obj


obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}


#步骤五：基于元类实现单例模式
# 单例：即单个实例，指的是同一个类实例化多次的结果指向同一个对象，用于节省内存空间
# 如果我们从配置文件中读取配置来进行实例化，在配置相同的情况下，就没必要重复产生对象浪费内存了
#settings.py文件内容如下
HOST='1.1.1.1'
PORT=3306


import settings

class Mysql:
    __instance=None
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance=cls(settings.HOST,settings.PORT)
        return cls.__instance


obj1=Mysql('1.1.1.2',3306)
obj2=Mysql('1.1.1.3',3307)
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True



#应用：定制元类实现单例模式
import settings

class Mymeta(type):
    def __init__(self,name,bases,dic): #定义类Mysql时就触发

        # 事先先从配置文件中取配置来造一个Mysql的实例出来
        self.__instance = object.__new__(self)  # 产生对象
        self.__init__(self.__instance, settings.HOST, settings.PORT)  # 初始化对象
        # 上述两步可以合成下面一步
        # self.__instance=super().__call__(*args,**kwargs)


        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs): #Mysql(...)时触发
        if args or kwargs: # args或kwargs内有值
            obj=object.__new__(self)
            self.__init__(obj,*args,**kwargs)
            return obj

        return self.__instance




class Mysql(metaclass=Mymeta):
    def __init__(self,host,port):
        self.host=host
        self.port=port



obj1=Mysql() # 没有传值则默认从配置文件中读配置来实例化，所有的实例应该指向一个内存地址
obj2=Mysql()
obj3=Mysql()

print(obj1 is obj2 is obj3)

obj4=Mysql('1.1.1.4',3307)

View Code

 

补充__init__和__new__：

对于”new”和”init”可以概括为： 

“new”方法在Python中是真正的构造方法（创建并返回实例），通过这个方法可以产生一个”cls”对应的实例对象，所以说”new”方法一定要有返回。
 
对于”init”方法，是一个初始化的方法，”self”代表由类产生出来的实例对象，”init”将对这个对象进行相应的初始化操作。

重写_new_ 
如果（新式）类中没有重写”new”方法，Python默认是调用该类的直接父类的”new”方法来构造该类的实例，如果该类的父类也没有重写”new”，那么将一直按照同样的规则追溯至object的”new”方法，因为object是所有新式类的基类。

而如果新式类中重写了”new”方法，那么可以选择任意一个其他的新式类（必须是新式类，只有新式类有”new”，因为所有新式类都是从object派生）的”new”方法来创建实例，包括这个新式类的所有前代类和后代类，只要它们不会造成递归死循环

_init_的调用

“new”决定是否要使用该类的”init”方法，因为”new” 可以调用其他类的构造方法或者直接返回别的类创建的对象来作为本类的实例。 
通常来说，新式类开始实例化时，”new”方法会返回cls（cls指代当前类）的实例，然后调用该类的”init”方法作为初始化方法，该方法接收这个实例（即self）作为自己的第一个参数，然后依次传入”new”方法中接收的位置参数和命名参数。 
但是，如果”new”没有返回cls（即当前类）的实例，那么当前类的”init”方法是不会被调用的。

派生不可变类型

关于”new”方法还有一个重要的用途就是用来派生不可变类型 
例如，python中的float类型是一个不可变类型，如果想要从float中派生出一个子类，就可以使用”new”方法