1.函数装饰器有什么作用?请列举说明?

　　2. Python 垃圾回收机制?

　　3. 魔法函数 _call_怎么使用?

　　4. 如何判断一个对象是函数还是方法?

　　5. @classmethod 和 @staticmethod 用法和区别

　　6. Python 中的接口如何实现?

　　7. Python 中的反射了解么?

　　8. metaclass 作用?以及应用场景?

　　9. hasattr()、getattr()、setattr() 的用法

　　10. 请列举你知道的 Python 的魔法方法及用途。

　　11. 如何知道一个 Python 对象的类型?

　　12. Python 的传参是传值还是传址?

　　13. Python 中的元类 (metaclass) 使用举例

　　14. 简述 any() 和 all() 方法

　　15. filter 方法求出列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

　　16. 什么是猴子补丁?

　　17. 在 Python 中是如何管理内存的?

　　18. 当退出 Python 时是否释放所有内存分配?

　　1.函数装饰器有什么作用?请列举说明?

　　答： 装饰器就是一个函数，它可以在不需要做任何代码变动的前提下给一个函数增加额外功能，启动装饰的效果。 它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。 下面是一个日志功能的装饰器

　　from functools import wraps

　　def log(label)：

　　def decorate(func)：

　　@wraps(func)

　　def _wrap(*args,**kwargs)：

　　try：

　　func(*args,**kwargs)

　　print("name",func.__name__)

　　except Exception as e：

　　print(e.args)

　　return _wrap

　　return decorate

　　@log("info")

　　def foo(a,b,c)：

　　print(a+b+c)

　　print("in foo")

　　#decorate=decorate(foo)

　　if __name__ == '__main__'：

　　foo(1,2,3)

　　#decorate()

　　2.Python 垃圾回收机制?

　　答：Python 不像 C++，Java 等语言一样，他们可以不用事先声明变量类型而直接对变量进行赋值。对 Python 语言来讲，对象的类型和内存都是在运行时确定的。这也是为什么我们称 Python 语言为动态类型的原因。

　　主要体现在下面三个方法：

　　1.引用计数机制 2.标记-清除 3.分代回收

　　3.魔法函数 _call_怎么使用?

　　答： call 可以把类实例当做函数调用。 使用示例如下

　　class Bar：

　　def __call__(self, *args, **kwargs)：

　　print('in call')

　　if __name__ == '__main__'：

　　b = Bar()

　　b()

　　4.如何判断一个对象是函数还是方法?

　　答：看代码及结果就懂了

　　from types import MethodType, FunctionType

　　class Bar：

　　def foo(self)：

　　pass

　　def foo2()：

　　pass

　　def run()：

　　print("foo 是函数", isinstance(Bar().foo, FunctionType))

　　print("foo 是方法", isinstance(Bar().foo, MethodType))

　　print("foo2 是函数", isinstance(foo2, FunctionType))

　　print("foo2 是方法", isinstance(foo2, MethodType))

　　if __name__ == '__main__'：

　　run()

　　输出:

　　foo 是函数 False

　　foo 是方法 True

　　foo2 是函数 True

　　foo2 是方法 False

　　5.@classmethod 和 @staticmethod 用法和区别

　　答：

　　相同之处：@staticmethod 和@classmethod 都可以直接类名.方法名()来调用，不用在示例化一个类。

　　@classmethod 我们要写一个只在类中运行而不在实例中运行的方法。如果我们想让方法不在实例中运行，可以这么做：

　　def iget_no_of_instance(ins_obj)：

　　return ins_obj.__class__.no_inst

　　class Kls(object)：

　　no_inst = 0

　　def __init__(self)：

　　Kls.no_inst = Kls.no_inst + 1

　　ik1 = Kls()

　　ik2 = Kls()

　　print(iget_no_of_instance(ik1))

　　@staticmethod 经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法:

　　IND = 'ON'

　　class Kls(object)：

　　def __init__(self, data)：

　　self.data = data

　　@staticmethod

　　def check_ind()：

　　return (IND == 'ON')

　　def do_reset(self)：

　　if self.check_ind()：

　　print('Reset done for：', self.data)

　　def set_db(self)：

　　if self.check_ind()：

　　self.db = 'New db connection'

　　print('DB connection made for： ', self.data)

　　ik1 = Kls(12)

　　ik1.do_reset()

　　ik1.set_db()

　　6.Python 中的接口如何实现?

　　答：

　　接口提取了一群类共同的函数，可以把接口当做一个函数的集合，然后让子类去实现接口中的函数。但是在 Python 中根本就没有一个叫做 interface 的关键字，如果非要去模仿接口的概念，可以使用抽象类来实现。抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化。使用 abc 模块来实现抽象类。

　　7.Python 中的反射了解么?

　　答：Python 的反射机制设定较为简单，一共有四个关键函数分别是 getattr、hasattr、setattr、delattr。

　　8.metaclass 作用?以及应用场景?

　　答：

　　metaclass 即元类，metaclass 是类似创建类的模板，所有的类都是通过他来 create 的(调用new)，这使得你可以自由的控制创建类的那个过程，实现你所需要的功能。 我们可以使用元类创建单例模式和实现 ORM 模式。

　　9.hasattr()、getattr()、setattr() 的用法

　　答：无锡妇科医院排行 http://www.0510bhyy.com/

　　这三个方法属于 Python 的反射机制里面的，hasattr 可以判断一个对象是否含有某个属性，getattr 可以充当 get 获取对象属性的作用。而 setattr 可以充当 person.name = "liming"的赋值操作。代码示例如下：

　　class Person()：

　　def __init__(self)：

　　self.name = "liming"

　　self.age = 12

　　def show(self)：

　　print(self.name)

　　print(self.age)

　　def set_name(self)：

　　setattr(Person, "sex", "男")

　　def get_name(self)：

　　print(getattr(self, "name"))

　　print(getattr(self, "age"))

　　print(getattr(self, "sex"))

　　def run()：

　　if hasattr(Person, "show")：

　　print("判断 Person 类是否含有 show 方法")

　　Person().set_name()

　　Person().get_name()

　　if __name__ == '__main__'：

　　run()

　　10.请列举你知道的 Python 的魔法方法及用途。

　　答：

　　1 __init__：

　　类的初始化方法。它获取任何传给构造器的参数(比如我们调用 x = SomeClass(10, ‘foo’) ， __init__就会接到参数 10 和 ‘foo’ 。 __init__在 Python 的类定义中用的最多。

　　2 __new__：

　　__new__是对象实例化时第一个调用的方法，它只取下 cls 参数，并把其他参数传给 __init__ 。 __new__很少使用，但是也有它适合的场景，尤其是当类继承自一个像元组或者字符串这样不经常改变的类型的时候.

　　3 __del__：

　　__new__和 __init__是对象的构造器， __del__是对象的销毁器。它并非实现了语句 del x (因此该语

　　11.如何知道一个 Python 对象的类型?

　　答：

　　可以通过 type 方法

　　12.Python 的传参是传值还是传址?

　　答：

　　Python 中的传参即不是传值也不是传地址，传的是对象的引用。

　　13.Python 中的元类 (metaclass) 使用举例

　　答：

　　可以使用元类实现一个单例模式，代码如下:

　　class Singleton(type)：

　　def __init__(self, *args, **kwargs)：

　　print("in __init__")

　　self.__instance = None

　　super(Singleton, self).__init__(*args, **kwargs)

　　def __call__(self, *args, **kwargs)：

　　print("in __call__")

　　if self.__instance is None：

　　self.__instance = super(Singleton, self).__call__(*args, **kwargs)

　　return self.__instance

　　class Foo(metaclass=Singleton)：

　　pass # 在代码执行到这里的时候，元类中的__new__方法和__init__方法其实已经被执行了，而不是在 Foo 实例化的时候执行。且仅会执行一次。

　　foo1 = Foo()

　　foo2 = Foo()

　　print(foo1 is foo2)

　　14.简述 any() 和 all() 方法

　　答： any(x)：判断 x 对象是否为空对象，如果都为空、0、false，则返回 false，如果不都为空、0、false，则返回 true。 all(x)：如果 all(x) 参数 x 对象的所有元素不为 0、’’、False 或者 x 为空对象，则返回 True，否则返回 False。