python面试题~反射，元类，单例

1 什么是反射？以及应用场景？

test.py

def f1():
   print('f1')
def f2():
   print('f2')
def f3():
   print('f3')
def f4():
   print('f4')
a = 1
复制代码

import test as ss
ss.f1()
ss.f2()
print(ss.a)
复制代码

我们要导入另外一个模块,可以使用import.现在有这样的需求,我动态输入一个模块名，可以随时访问到导入模块中的方法或者变量，怎么做呢？

imp = input(“请输入你想导入的模块名:”)
CC = __import__(imp) 這种方式就是通过输入字符串导入你所想导入的模块 
CC.f1()  # 执行模块中的f1方法

#或者用importlib模块
import importlib
importlib.import_module(name="",package="")
复制代码

上面我们实现了动态输入模块名，从而使我们能够输入模块名并且执行里面的函数。但是上面有一个缺点，那就是执行的函数被固定了。那么，我们能不能改进一下，动态输入函数名，并且来执行呢？

#dynamic.py
imp = input("请输入模块:")
dd = __import__(imp)
# 等价于import imp
inp_func = input("请输入要执行的函数：")
f = getattr(dd,inp_func，None)#作用:从导入模块中找到你需要调用的函数inp_func,然后返回一个该函数的引用.没有找到就烦会None
f() # 执行该函数
复制代码

反射机制 上面说了那么多，到底什么是反射机制呢?

  其实，反射就是通过字符串的形式，导入模块；通过字符串的形式，去模块寻找指定函数，并执行。利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！

1. getattr()函数是Python自省的核心函数，具体使用大体如下：

class A: 
def __init__(self): 
  self.name = 'zhangjing'
  #self.age='24'
def method(self): 
  print"method print"
Instance = A() 
print getattr(Instance , 'name, 'not find') #如果Instance 对象中有属性
name则打印self.name的值，否则打印'not find'
print getattr(Instance , 'age', 'not find') #如果Instance 对象中有属性
age则打印self.age的值，否则打印'not find'
print getattr(a, 'method', 'default') #如果有方法method，否则打印其地址，
否则打印default 
print getattr(a, 'method', 'default')() #如果有方法method，运行函数并
打印None否则打印default 
复制代码

2. hasattr(object, name)

说明：判断对象object是否包含名为name的特性（hasattr是通过调用getattr(ojbect, name)
是否抛出异常来实现的）
复制代码

3. setattr(object, name, value)

这是相对应的getattr()。参数是一个对象,一个字符串和一个任意值。字符串可能
会列出一个现有的属性或一个新的属性。这个函数将值赋给属性的。该对象允许它提供
。例如,setattr(x,“foobar”,123)相当于x.foobar = 123。
复制代码

4. delattr(object, name)

与setattr()相关的一组函数。参数是由一个对象(记住python中一切皆是对象)和一
个字符串组成的。string参数必须是对象属性名之一。该函数删除该obj的一个由string
指定的属性。delattr(x, 'foobar')=del x.foobar


我们可以利用上述的四个函数,来对模块进行一系列操作.

r = hasattr(commons,xxx)判断某个函数或者变量是否存在
print(r)  
setattr(commons,'age',18)  给commons模块增加一个全局变量age = 18，创建成功返回none
setattr(config,'age',lambda  a:a+1)  //给模块添加一个函数
delattr(commons,'age')//删除模块中某个变量或者函数
注：getattr,hasattr,setattr,delattr对模块的修改都在内存中进行，并不会影响文件中真实内容。
复制代码

2 metaclass作用？以及应用场景？

元类(metaclass)的理解和简单运用 首先这里讨论的python类，都基于继承于object的新式类进行讨论。

首先在python中，所有东西都是对象。这句话非常重要要理解元类我要重新来理解一下python中的类

class Trick(object):
   pass
复制代码

当python在执行带class语句的时候，会初始化一个类对象放在内存里面。例如这里会初始化一个Trick对象

这个对象(类)自身拥有创建对象(通常我们说的实例，但是在python中还是对象)的能力。

为了方便后续理解，我们可以先尝试一下在新式类中最古老厉害的关键字type。

input:
class Trick(object):
   pass
print type('123')
print type(123)
print type(Trick)
output:
<type 'str'>
<type 'int'>
<class '__main__.Trick'>
复制代码

可以看到能得到我们平时使用的 str, int, 以及我们初始化的一个实例对象Trick()

但是下面的方法你可能没有见过，type同样可以用来动态创建一个类

type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)

这个怎么用呢，我要用这个方法创建一个类 让我们看下下面的代码

input:
print type('Trick', (), {})

output:
<class '__main__.Trick'>
同样我们可以实例化这个类对象

input:
print type('trick', (), {})()

output:
<__main__.trick object at 0x109283450>
可以看到，这里就是一个trick的实例对象了。
复制代码

同样的这个方法还可以初始化创建类的父类，同时也可以初始化类属性:

input:
class FlyToSky(object):
   pass

pw = type('Trick', (FlyToSky, ), {'laugh_at': 'hahahaha'})
print pw().laugh_at
print pw.__dict__
print pw.__bases__
print pw().__class__
print pw().__class__.__class__

output:
hahahaha
{'__module__': '__main__', 'laugh_at': 'hahahaha', '__doc__': None}
(<class '__main__.FlyToSky'>,)
<class '__main__.Trick'>
<type 'type'>
复制代码

下面我将依次理一下上面的内容，在此之前我必须先介绍两个魔法方法：

__class__这个方法用于查看对象属于是哪个生成的，这样理解在python中的所有东西都是对象，类对象也是对象。如果按照以前的思维来想的话就是类是元类的实例，而实例对象是类的实例。

__bases__这个方法用于得到一个对象的父类是谁，特别注意一下__base__返回单个父类，__bases__以tuple形式返回所有父类。
复制代码

好了知道了这两个方法我来依次说一下每行什么意思。

使用type创建一个类赋值给pw type的接受的三个参数的意思分辨是(类的名称， 类是否有父类(), 类的属性字典{})

这里初始化一个类的实例，然后尝试去获得类属性 的laugh_at 属性值，然后得到结果hahahaha

取一个pw的也就是我们常见类的类字典数据

拿到pw的父类，结果是我们指定的 FlyToSky

pw的实例pw()属于哪个类初始化的，可以看到是class Trick

我们再看class trick是谁初始化的？ 就是元类type了

什么是元类以及简单运用

这一切介绍完之后我们总算可以进入正题

到底什么是元类？通俗的就是说，元类就是创建类的类。。。这样听起来是不是超级抽象？

来看看这个

Trick = MetaClass()
MyObject = Trick()
复制代码

上面我们已经介绍了，搞一个Trick可以直接这样

Trick = type('Trick', (), {}) 可以这样其实就是因为，Type实际上是一个元类，用他可以去创建类。什么是元类刚才说了，元类就是创建类的类。也可以说他就是一个类的创建工厂。

类上面的__metaclass__属性，相信愿意了解元类细节的盆友，都肯定见过这个东西，而且为之好奇。不然我不知道是什么支撑你看到这里的?。使用了__metaclass__这个魔法方法就意味着就会用__metaclass__指定的元类来创建类了。

class Trick(FlyToSky):
   pass
复制代码

当我们在创建上面的类的时候，python做了如下的操作：

Trick中有__metaclass__这个属性吗？如果有，那么Python会在内存中通过__metaclass__创建一个名字为Trick的类对象，也就是Trick这个东西。如果Python没有找到__metaclass__，它会继续在自己的父类FlyToSky中寻找__metaclass__属性，并且尝试以__metaclass__指定的方法创建一个Trick类对象。如果Python在任何一个父类中都找不到__metaclass__，它也不会就此放弃，而是去模块中搜寻是否有__metaclass__的指定。如果还是找不到，好吧那就是使用默认的type来创建Trick。

那么问题来了，我们要在__metaclass__中放置什么呢？答案是可以创建一个类的东西，type,或者任何用到type或子类化type的东西都行。

自定义元类

自定义类的的目的，我总结了一下就是拦截类的创建，然后修改一些特性，然后返回该类。是不是有点熟悉？没错，就是感觉是装饰器干的事情，只是装饰器是修饰一个函数，同样是一个东西进去，然后被额外加了一些东西，最后被返回。

其实除了上面谈到的制定一个__metaclass__并不需要赋值给它的不一定要是正式类，是一个函数也可以。要创建一个使所有模块级别都是用这个元类创建类的话，在模块级别设定__metaclass__就可以了。先写一个来试试看

class UpperAttrMetaClass(type):
   def __new__(mcs, class_name, class_parents, class_attr):
       attrs = ((name, value) for name, value in class_attr.items() if not name.startswith('__'))
       uppercase_attrs = dict((name.upper(), value) for name, value in attrs)
       return super(UpperAttrMetaClass, mcs).__new__(mcs, class_name, class_parents, uppercase_attrs)


class Trick(object):
   __metaclass__ = UpperAttrMetaClass
   bar = 12
   money = 'unlimited'

print(Trick.bar)
print(Trick.money)
复制代码

3 用尽量多的方法实现单例模式。

单例模式 单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。

比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。

在 Python 中，我们可以用多种方法来实现单例模式

实现单例模式的几种方式 使用模块 其实，Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：

class Singleton(object):
   def foo(self):
       pass
singleton = Singleton()
复制代码

将上面的代码保存在文件 mysingleton.py 中，要使用时，直接在其他文件中导入此文件中的对象，这个对象即是单例模式的对象

from a import singleton

使用装饰器

def Singleton(cls):
   _instance = {}
   def _singleton(*args, **kargs):
       if cls not in _instance:
           _instance[cls] = cls(*args, **kargs)
       return _instance[cls]
   return _singleton

@Singleton
class A(object):
   a = 1
   def __init__(self, x=0):
       self.x = x

a1 = A(2)
a2 = A(3)
复制代码

使用类

class Singleton(object):
   def __init__(self):
       pass
   @classmethod
   def instance(cls, *args, **kwargs):
       if not hasattr(Singleton, "_instance"):
           Singleton._instance = Singleton(*args, **kwargs)
       return Singleton._instance
复制代码

一般情况，大家以为这样就完成了单例模式，但是这样当使用多线程时会存在问题

class Singleton(object):

   def __init__(self):
       pass

   @classmethod
   def instance(cls, *args, **kwargs):
       if not hasattr(Singleton, "_instance"):
           Singleton._instance = Singleton(*args, **kwargs)
       return Singleton._instance
import threading
def task(arg):
   obj = Singleton.instance()
   print(obj)

for i in range(10):
   t = threading.Thread(target=task,args=[i,])
   t.start()
程序执行后，打印结果如下：

<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
<__main__.Singleton object at 0x02C933D0>
复制代码

看起来也没有问题，那是因为执行速度过快，如果在init方法中有一些IO操作，就会发现问题了，下面我们通过time.sleep模拟

我们在上面__init__方法中加入以下代码：

def __init__(self):
       import time
       time.sleep(1)
复制代码

重新执行程序后，结果如下

<__main__.Singleton object at 0x034A3410>
<__main__.Singleton object at 0x034BB990>
<__main__.Singleton object at 0x034BB910>
<__main__.Singleton object at 0x034ADED0>
<__main__.Singleton object at 0x034E6BD0>
<__main__.Singleton object at 0x034E6C10>
<__main__.Singleton object at 0x034E6B90>
<__main__.Singleton object at 0x034BBA30>
<__main__.Singleton object at 0x034F6B90>
<__main__.Singleton object at 0x034E6A90>
复制代码

问题出现了！按照以上方式创建的单例，无法支持多线程

解决办法：加锁！未加锁部分并发执行,加锁部分串行执行,速度降低,但是保证了数据安全

import time
import threading
class Singleton(object):
   _instance_lock = threading.Lock()

   def __init__(self):
       time.sleep(1)

   @classmethod
   def instance(cls, *args, **kwargs):
       with Singleton._instance_lock:
           if not hasattr(Singleton, "_instance"):
               Singleton._instance = Singleton(*args, **kwargs)
       return Singleton._instance

def task(arg):
   obj = Singleton.instance()
   print(obj)
for i in range(10):
   t = threading.Thread(target=task,args=[i,])
   t.start()
time.sleep(20)
obj = Singleton.instance()
print(obj)
打印结果如下：

<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
<__main__.Singleton object at 0x02D6B110>
复制代码

这样就差不多了，但是还是有一点小问题，就是当程序执行时，执行了time.sleep(20)后，下面实例化对象时，此时已经是单例模式了，但我们还是加了锁，这样不太好，再进行一些优化，把intance方法，改成下面的这样就行：

@classmethod
   def instance(cls, *args, **kwargs):
       if not hasattr(Singleton, "_instance"):
           with Singleton._instance_lock:
               if not hasattr(Singleton, "_instance"):
                   Singleton._instance = Singleton(*args, **kwargs)
       return Singleton._instance
复制代码

这种方式实现的单例模式，使用时会有限制，以后实例化必须通过 obj = Singleton.instance()

如果用 obj=Singleton() ,这种方式得到的不是单例

基于__new__方法实现（推荐使用，方便） 通过上面例子，我们可以知道，当我们实现单例时，为了保证线程安全需要在内部加入锁

我们知道，当我们实例化一个对象时，是先执行了类的__new__方法（我们没写时，默认调用object.new），实例化对象；然后再执行类的__init__方法，对这个对象进行初始化，所有我们可以基于这个，实现单例模式

import threading
class Singleton(object):
   _instance_lock = threading.Lock()

   def __init__(self):
       pass


   def __new__(cls, *args, **kwargs):
       if not hasattr(Singleton, "_instance"):
           with Singleton._instance_lock:
               if not hasattr(Singleton, "_instance"):
                   Singleton._instance = object.__new__(cls)  
       return Singleton._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1,obj2)

def task(arg):
   obj = Singleton()
   print(obj)

for i in range(10):
   t = threading.Thread(target=task,args=[i,])
   t.start()
复制代码

采用这种方式的单例模式，以后实例化对象时，和平时实例化对象的方法一样 obj = Singleton()

基于metaclass方式实现 """ 1.类由type创建，创建类时，type的__init__方法自动执行，类() 执行type的 __call__方法(类的__new__方法,类的__init__方法) 2.对象由类创建，创建对象时，类的__init__方法自动执行，对象()执行类的 call 方法 """

import threading
class SingletonType(type):
   _instance_lock = threading.Lock()
   def __call__(cls, *args, **kwargs):
       if not hasattr(cls, "_instance"):
           with SingletonType._instance_lock:
               if not hasattr(cls, "_instance"):
                   cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
       return cls._instance

class Foo(metaclass=SingletonType):
   def __init__(self,name):
       self.name = name
obj1 = Foo('name')
obj2 = Foo('name')
print(obj1,obj2)
复制代码

识别图中二维码,领取python全套视频资料