Python面试题

函数参数传递

嵌套函数

闭包

深拷贝与浅拷贝

深拷贝:赋值时值完全复制,完全的copy,对其中一个作出改变,不会影响另一个
浅拷贝:赋值时,引用赋值,相当于取了一个别名。对其中一个修改,会影响另一个

赋值:简单地拷贝对象的引用,两个对象的id相同。
浅拷贝:创建一个新的组合对象,这个新对象与原对象共享内存中的子对象。
深拷贝:创建一个新的组合对象,同时递归地拷贝所有子对象,新的组合对象与原对象没有任何关联。虽然实际上会共享不可变的子对象,但不影响它们的相互独立性。
对于数字、字符串以及其它“原子”类型,没有拷贝一说,产生的都是原对象的引用。

import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象

b = a #赋值,传对象的引用
c = copy.copy(a) #对象拷贝,浅拷贝
d = copy.deepcopy(a) #对象拷贝,深拷贝

a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象

print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d

输出结果:

a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c = [1, 2, 3, 4, ['a', 'b', 'c']]
d = [1, 2, 3, 4, ['a', 'b']]

装饰器

@outest
@outer
def test()
pass

相当于outer(test)

比较参数

def outer(func):
lastCall = ()
lastResult = None
def inner(*arg):
nonlocal lastCall, lastResult
if lastCall == arg:
print("same")
return lastResult
else:
print("diff")
lastCall = arg
lastResult = func(*arg)
return lastResult
return inner

@outer
def test(a):
return a

print(test(1))
print(test(2))
print(test(2))
print(test(1))

装饰器函数传递参数


def Before(request,kargs):
print 'before'

def After(request,kargs):
print 'after'


def Filter(before_func,after_func):
def outer(main_func):
def wrapper(request,kargs):
before_result = before_func(request,kargs)
if(before_result != None):
return before_result;

main_result = main_func(request,kargs)
if(main_result != None):
return main_result;

after_result = after_func(request,kargs)
if(after_result != None):
return after_result;
return wrapper
return outer

@Filter(Before, After)
def Index(request,kargs):
print 'index'

装饰器实现单例模式

def singleton(cls, *args, **kw):  
instance={}
def _singleton():
if cls not in instance:
instance[cls]=cls(*args, **kw)
return instance[cls]
return _singleton

@singleton
class test_singleton(object):
def __init__(self):
self.num_sum=0
def add(self):
self.num_sum=100

参考