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() # 執行該函數 復制代碼反射機制 上面說了那么多，到底什么是反射機制呢?
??其實，反射就是通過字符串的形式，導入模塊；通過字符串的形式，去模塊尋找指定函數，并執行。利用字符串的形式去對象（模塊）中操作（查找/獲取/刪除/添加）成員，一種基于字符串的事件驅動！
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):passpw = 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__ = UpperAttrMetaClassbar = 12money = '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 = 1def __init__(self, x=0):self.x = xa1 = A(2) a2 = A(3) 復制代碼使用類
class Singleton(object):def __init__(self):pass@classmethoddef instance(cls, *args, **kwargs):if not hasattr(Singleton, "_instance"):Singleton._instance = Singleton(*args, **kwargs)return Singleton._instance 復制代碼一般情況，大家以為這樣就完成了單例模式，但是這樣當使用多線程時會存在問題
class Singleton(object):def __init__(self):pass@classmethoddef 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 timetime.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)@classmethoddef instance(cls, *args, **kwargs):with Singleton._instance_lock:if not hasattr(Singleton, "_instance"):Singleton._instance = Singleton(*args, **kwargs)return Singleton._instancedef 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方法，改成下面的這樣就行：
@classmethoddef 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):passdef __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._instanceobj1 = 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._instanceclass Foo(metaclass=SingletonType):def __init__(self,name):self.name = name obj1 = Foo('name') obj2 = Foo('name') print(obj1,obj2) 復制代碼 識別圖中二維碼,領取python全套視頻資料總結
以上是生活随笔為你收集整理的python面试题~反射，元类，单例的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 构建Squid代理服务器-传统代理、透明
- 下一篇： 点击回退按钮刷新页面