python几个面试题目：单例模式，浅拷贝与深拷贝

主要参考git上一篇面试题目，链接如下https://github.com/taizilongxu/interview_python#2-python%E4%B8%AD%E7%9A%84%E5%85%83%E7%B1%BBmetaclass

实现单例模式，对每种方式添加更详细的分析。

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls)
            cls._instance.__init__(*args, **kwargs)
        return cls._instance
    def __init__(self, *args, **kwargs):
        pass
a = Singleton()
b = Singleton()
print(id(a))
print(id(b))

每个对象的初始化会先调用__new__生成对象，再调用__init__完成后续的初始化，super(para1, cls)中的para1表示，在mro序列中从para1开始寻找下一个类，也就是继承树中的para1之前的第一个类，后边的__new__为寻找到的类的函数，由于所有类都继承自object，而object类的__new__函数被定义为static类型，故还要再传入cls参数。

class Singleton(object):
    __instance = None
    def __init__(self, *args, **kwargs):
        pass
    @classmethod
    def get_instance(cls, *args, **kwargs):
        if Singleton.__instance is None:
            Singleton.__instance = Singleton(*args, **kwargs)
        return Singleton.__instance

a = Singleton.get_instance()
b = Singleton.get_instance()
print(id(a))
print(id(b))

这个方式生成对象要调用类方法get_instance，不够方便，可以使用装饰器方法实现。

def singleton(cls):
    _instance = None
    def get_instance(*args, **kwargs):
        if not _instance:
            obj = cls(*args, **kwargs)
        return obj
    return get_instance

@singleton
#想达到的目的代码obj = MyClass(*args, **kwargs)
#装饰器作用MyClass = singleton(MyClass)，将MyClass指向get_instance函数
#实际运行代码obj = get_instance(*args, **kwargs)
class MyClass(object):
    pass

a = MyClass()
b = MyClass()
print(id(a))
print(id(b))

import模块是天然的单例模式，在模块里建好实例，每次使用从模块中引入实例。

#singelton.py
class Singeton(object):
    def __init__(*args, **kwargs):
        pass
    def foo(self):
        pass
singelton_obj = Singeton()

#to use
from singleton import singelton_obj
print(id(singelton_obj))
from singleton import singelton_obj
print(id(singelton_obj))

再整理下引用，copy与deepcopy的区别。

import copy
a = [1, 2, 3, 4, ['a', 'b']]
b = a#传对象的引用
c = copy.copy(a)#对象拷贝，浅拷贝
d = copy.deepcopy(a)#对象拷贝，深拷贝

a.append(5)
a[4].append('c')

print(a)#[1, 2, 3, 4, ['a', 'b', 'c'], 5]
print(b)#[1, 2, 3, 4, ['a', 'b', 'c'], 5]
print(c)#[1, 2, 3, 4, ['a', 'b', 'c']]
print(d)#[1, 2, 3, 4, ['a', 'b']]

赋值只是改变引用，原来对象数据变化，b也跟着变化。浅拷贝后为两个独立对象，但子对象为引用，仍然指向原来的子对象，故改变子对象数据，c也会跟着改变。深拷贝将所有对象数据独立，原对象的改变不会影响d。