美文网首页
Python 面试题(待更新...)

Python 面试题(待更新...)

作者: JackYao | 来源:发表于2017-12-19 12:52 被阅读37次

    一、Python中单下划线和双下划线的区别

    1、_xxx 不能用于’from module import *’ 以单下划线开头的表示的是protected类型的变量。即保护类型只能允许其本身与子类进行访问。
    
    2、__xxx 双下划线的表示的是私有类型的变量。只能是允许这个类本身进行访问了。连子类也不可以
    
    3、__xxx___ 定义的是特列方法。像__init__之类的
    

    二、类变量 和 实例变量

    1、类变量可以使用className.类变量和self.类变量两种方式访问。
    2、如果使用self.类变量的方式访问并重新赋值后,这个变量就会成为实例变量和self绑定,实际上就变成了一个实例变量,实例变量会屏蔽掉类变量的值。
    3、类变量是共享的,最好使用类名的方式来访问类变量。
    4、类变量通过sel访问时,就会被转化成实力变量,被绑定到特定的实例上。
    5、实例变量(self)的形式对类变量重新赋值后,类变量的值不会随之变化。
    6、实例变量对每一个对象是不可见的,每一个对象拥有着可能不同的值。
    

    三、newinit的区别

    __new__是一个静态方法,而__init__是一个实例方法.
    __new__方法会返回一个创建的实例,而__init__什么都不返回.
    只有在__new__返回一个cls的实例时后面的__init__才能被调用.
    当创建一个新实例时调用__new__,初始化一个实例时用__init__.
    

    四、单例模式

    使用new方法

    class Singleton(object):
        def __new__(cls, *args, **kw):
            if not hasattr(cls, '_instance'):
                orig = super(Singleton, cls)
                cls._instance = orig.__new__(cls, *args, **kw)
            return cls._instance
     
    class MyClass(Singleton):
        a = 1
    

    共享属性
    创建实例时把所有实例的dict指向同一个字典,这样它们具有相同的属性和方法.

    class Borg(object):
        _state = {}
        def __new__(cls, *args, **kw):
            ob = super(Borg, cls).__new__(cls, *args, **kw)
            ob.__dict__ = cls._state
            return ob
     
    class MyClass2(Borg):
        a = 1
    

    装饰器版本

    def singleton(cls, *args, **kw):
        instances = {}
        def getinstance():
            if cls not in instances:
                instances[cls] = cls(*args, **kw)
            return instances[cls]
        return getinstance
     
    @singleton
    class MyClass:
      ...
    

    import方法

    # mysingleton.py
    class My_Singleton(object):
        def foo(self):
            pass
     
    my_singleton = My_Singleton()
     
    # to use
    from mysingleton import my_singleton
     
    my_singleton.foo() 
        
    

    五、copy, deepcopy()

    赋值(=),就是创建了对象的一个新的引用,修改其中任意一个变量都会影响到另一个。
    浅拷贝:创建一个新的对象,但它包含的是对原始对象中包含项的引用(如果用引用的方式修改其中一个对象,另外一个也会修改改变){
    1,完全切片方法;
    2,工厂函数,如list();
    3,copy模块的copy()函数
    }

    深拷贝:创建一个新的对象,并且递归的复制它所包含的对象(修改其中一个,另外一个不会改变){copy模块的deep.deepcopy()函数}

    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']]
    

    六、Python垃圾回收机制

    Python GC主要使用引用计数(reference counting)来跟踪和回收垃圾。在引用计数的基础上,通过“标记-清除”(mark and sweep)解决容器对象可能产生的循环引用问题,通过“分代回收”(generation collection)以空间换时间的方法提高垃圾回收效率。

    七、关于 is 与 ==

    is是对比地址,==是对比值

    八、如何在一个function里面设置一个全局的变量

    #解决方法是在function的开始插入一个global声明:
    def f()
        global x
    

    九、单引号,双引号,三引号的区别

    答:单引号和双引号是等效的,如果要换行,需要符号(\),三引号则可以直接换行,并且可以包含注释
    
    如果要表示Let’s go 这个字符串
    
    单引号:s4 = ‘Let\’s go’
    
    双引号:s5 = “Let’s go”
    
    s6 = ‘I realy like“python”!’
    
    """
    这里的东西不会被转义
    """
    
    
    这就是单引号和双引号都可以表示字符串的原因了
    

    十、匿名函数

    def multipliers():
        return [lambda x : i * x for i in range(4)]
     
    print [m(2) for m in multipliers()]
    
    输出 [6, 6, 6, 6]
    

    十一、队列

    Queue.Queue()对多线程是安全的,对多进程是非进程安全的
    multiprocessing.Queue()对多进程是安全的

    十二、logging

    logging 是线程安全的, 但是非多进程安全
    可使用ConcurrentLogHandler,自动创建一个.lock文件,通过锁的方式来安全的写日志文件

    十三、IO密集型任务、计算密集型任务

    多线程适合IO密集型任务
    多进程适合计算密集型任务

    十四、高并发解决方案

    https://www.google.com/search?q=python高并发解决方案
    twisted->tornado->gevent,能扯到golang,erlang更好

    相关文章

      网友评论

          本文标题:Python 面试题(待更新...)

          本文链接:https://www.haomeiwen.com/subject/cvpbwxtx.html