• 幕客老师召集小伙伴
  • 运维高手36项修炼
  • python自动化运维项目实战
  • nginx从入门到实战
  • 阿里云与Centos7实战

Jeson面试宝典-devops开发部分

一、python基础部分

二、python进阶部分

1、

In [20]: [lambda x, i=2 : i * x  for x in [1,2,3,4]]
Out[20]: 
[<function __main__.<listcomp>.<lambda>>,
 <function __main__.<listcomp>.<lambda>>,
 <function __main__.<listcomp>.<lambda>>,
 <function __main__.<listcomp>.<lambda>>]

如下方式执行for循环的是4个函数,其实lambda并没有执行,应该修改为如下:

In [3]: aa = lambda x, i=2 : i * x

In [4]: [aa(x)  for x in [1,2,3,4]]
Out[4]: [2, 4, 6, 8]

2、Python闭包错误

In [7]: def muls():
   ...:     return [lambda x : i * x  for i in range(4)]
   ...: 
   ...: 

In [8]: [m(2) for m in muls()]
Out[8]: [6, 6, 6, 6]

如上结果返回的是6,6,6,6 而不是0,2,4,6

原因:

(1)形成闭包的条件

http://www.iaskjob.com/admin/zinnia/entry/232/?_changelist_filters=q%3D%25E9%2597%25AD%25E5%258C%2585

(2)原因是闭包函数引用了外部的变量,导致出现使用了外部完成循环后的数值

 

类似如下:

In [14]: def muls3():
    ...:     alist = []
    ...:     for i in range(4):
    ...:         def aa(x,key=i):
    ...:             return i*x
    ...:         alist.append(aa)
    ...:     return alist
    ...: 

In [15]: [m(2) for m in muls3()]
Out[15]: [6, 6, 6, 6]

return i*x ,i是外部的变量的,所以这个时候就触发了问题

In [12]: def muls2():
    ...:     alist = []
    ...:     for i in range(4):
    ...:         def aa(x,key=i):
    ...:             return key*x
    ...:         alist.append(aa)
    ...:     return alist
    ...: 

In [13]: [m(2) for m in muls2()]
Out[13]: [0, 2, 4, 6]

return i*x 修改为key*x,成为内部变量,这个时候完成正常循环

3、单例模式的实现

单例模式模式的出现为了解决相同类被多次实例化后,导致严重的内存资源浪费。

默认,我们看下一个类的调用:

In [16]: class Myclass():
    ...:     a = 1
    ...:     

In [17]: a = Myclass()

In [18]: b = Myclass()

In [19]: id(a)
Out[19]: 4361723056

In [20]: id(b)
Out[20]: 4361726288

In [21]: a is b

实现单例模式调用,可以通过几种写法来实现:

第一种、使用__new__来控制

我们将类的实例和一个类变量 _instance 关联起来,如果 cls._instance 为 None 则创建实例,否则直接返回 cls._instance。

In [22]: class SingleClass(object):

    ...:     _instance = None

    ...:     def __new__(cls,*args,**kw):

    ...:         if not cls._instance:

    ...:             cls._instance = super(SingleClass,cls).__new__(cls,*args,**kw)

    ...:         return cls._instance

    ...:    

 

In [23]: class Myclass(SingleClass):

    ...:     a = 1

    ...:    

 

In [24]: a = Myclass()

 

In [25]: b = Myclass()

 

In [28]: id(a)

Out[28]: 4364931856

 

In [29]: id(b)

Out[29]: 4364931856

 

In [30]: a is b

Out[30]: True

 

 

第二种、使用元类实现

元类(metaclass)可以控制类的创建过程,它主要做三件事:

  • 拦截类的创建
  • 修改类的定义
  • 返回修改后的类

In [31]: class Singleton(type):

    ...:     _instances = {}

    ...:     def __call__(cls, *args, **kwargs):

    ...:         if cls not in cls._instances:

    ...:             cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)

    ...:         return cls._instances[cls]

    ...:

    ...: # Python2

    ...: class MyClass(object):

    ...:     __metaclass__ = Singleton

    ...:    

 

In [32]:

 

In [32]: a = MyClass()

 

In [33]: b = MyClass()

 

In [34]: a is b

Out[34]: True

 

第三种,使用装饰器的方式

 

定义了一个装饰器 singleton,它返回了一个内部函数 getinstance,该函数会判断某个类是否在字典 instances 中,如果不存在,则会将 cls 作为 key,cls(*args, **kw) 作为 value 存到 instances 中,否则,直接返回 instances[cls]

In [40]: from functools import wraps
    ...:  
    ...: def singleton(cls):
    ...:     instances = {}
    ...:     @wraps(cls)
    ...:     def getinstance(*args, **kw):
    ...:         if cls not in instances:
    ...:             instances[cls] = cls(*args, **kw)
    ...:         return instances[cls]
    ...:     return getinstance
    ...:  
    ...: @singleton
    ...: class MyClass(object):
    ...:     a = 1
    ...:     

In [41]: a = MyClass()

In [42]: b = MyClass()

In [43]: a is b
Out[43]: True

Jeson面试宝典-devops开发部分

Pingbacks已打开。

引用地址

暂无评论

发表评论