zoukankan      html  css  js  c++  java
  • 基础篇3--【python】面试题汇总

    1.python常用魔法函数

      

    __init__():
            所有类的超类object,都有一个默认包含pass的__init__()实现,这个函数会在初始化的时候调用
    
    __str__():
            直接打印对象的实现方法,__str__是被print函数调用的
    
    __unicode__():
            在django中,虽然没有定义__str__,但是django会将__unicode__转为了str,当然你调用unicode更加是没有问题的。
    
    __call__():
            对象通过提供__call__()方法可以模拟函数的行为,如果一个对象提供了该方法,就可以像函数一样使用它
    
    __len__():
            调用后会调用对象的__len__函数,我们可以为其定制输出
    
    __repr__():
            函数str() 用于将值转化为适于人阅读的形式,而repr() 转化为供解释器读取的形式,某对象没有适于人阅读的解释形式的话,str() 会返回与repr(),所以print展示的都是str的格式
    __setarrt__():
    __new__():
    __getattr__():
    __getattribute__():
    __delattr__():
    __setitem__():
    __delitem__():
    __iter__():
            可以使用迭代器访问
    __del__():

    2.如何判断是函数还是方法?

      函数:
              函数是封装了一些独特功能,可以被直接调用
         方法:
              方法和函数类似,同样封装了独立的功能,但是方法是需要通过对象来调用的。

    3.静态方法和类方法区别?

      静态方法不需要传入self参数,类成员方法需要传入代表本类的cls参数
        静态方法是无妨访问实例变量和类变量的,类方法无法访问实例变量但是可以访问类变量

    4.列举面向对象中的特殊成员以及应用场景

       __doc__ 描述类的信息
          __call__ 对象后面加括号,触发执行
          __dict__查看类或对象中的所有成员

    5.什么是反射?以及应用场景?

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

    7.用尽量多的方法实现单例模式

      

    1.模块单例
        python的模块就是天然的单例模式,模块在首次导入时,会生成.pyc文件,当第二次导入时,就会直接加载.pyc文件,而不会再次执行模块代码
        class Singleton(object):
        def foo(self):
            pass
        singleton = Singleton()
    
        from foo1 import singleton
    
    2.静态变量
        先执行了类的__new__方法,实例化对象,然后再执行类的__init__方法,对这个对象进行初始化,所以我们可以基于这个,实现单例模式
        class Singleton(object):
        def __new__(cls,a):
            if not hasattr(cls, "_instance"):
            cls._instance = object.__new__(cls)
            return cls._instance
        def __init__(self,a):
            self.a = a
    
        def aa(self):
            print(self.a)
        a = Singleton("a")
    
        本质上是手动版的__new__方法
    
    3.元类方法
        执行元类的__new__方法和__init__方法来实例化类对象,__call__方法用来对实例化的对象的实例也就是累的对象进行控制,__call__方法会调用实例类的__new__方法,用于创建对象。返回对象给__call__方法,然后调用类对象的__init__方法,用于对对象初始化
        class Singleton1(type):
          def __init__(self, *args, **kwargs)
               self._instance = None
               super(Singleton1,self).__init__(*args,**kwargs)
           def __call__(self,*args,**kwargs):
               if self._instance is None:
                   self.__instance = super(Singleton1,self).__call__(*args,**kwargs)
                   return self.__instance
    
       class Singleton2(type):
           _inst = {}
    
           def __call__(cls, *args, **kwargs):
               print(cls)
               if cls not in cls._inst:
                   cls._inst[cls] = super(Singleton2,cls).__call__(*args)
               return cls._inst[cls]
       class C(metaclass=Singleton1):
           pass
    
    4.装饰器
        装饰器用来控制类调用__call__方法
            def singleton(cls,*args,**kwargs)
                instance = {}
                def __singleton(args):
                    if cls not in instance:
                        instance[cls] = cls(*args,**kwargs)
                    return instance[cls]
                return __singleton
            @singleton
            class A:
                pass

    8.装饰器的写法以及应用场景

      1.授权
            装饰器能有助于检查某个人是否被授权去使用一个web应用的端点。
            from functools import wraps
    
            def requires_auth(f):
                @wraps(f)
                def decorated(*args,**kwargs):
                    auth = request.authorization
                    if not auth or not check_auth(auth.username,auth.password):
                        authenticate()
                    return f(*args,**kwargs)
    
                return decorated
    
        2.日志
            日志是装饰器运用的另一个亮点
    
            from functools import wraps
            def logit(func):
                @wraps(func)
                def with_logging(*args,**kwargs):
                    print(func.__name__ + "was called")
                    return func(*args,**kwargs)
                return with_logging
            @logit
            def addition_func(x):
                """
                    Do some math
                """
                return x + x
            return = addition_func(4)
    
        3.带参数的装饰器
            带参数的装饰器是典型的闭包函数
    
        4.在函数中嵌入装饰器
        from functools import wraps
        def logit(logfile='out.log'):
            def logging_decorator(func):
                @wraps(func)
                def wrapped_function(*args,**kwargs):
                    log_string = func.__name__ + "was called"
                    print(log_string)
    
                    with open(logfile, "a") as opened_file:
                        opened_file.write(log_string + '
    ')
    
                    return func(*args,**kwargs)
                return wrapped_function
            return logging_decorator
    
        @logit()
        def myfunc1():
            pass
    
        myfunc1()
        # Output: myfunc1 was called
        # 现在一个叫做 out.log 的文件出现了,里面的内容就是上面的字符串
    
    
        @logit(logfile='func2.log')
        def myfunc2():
            pass
    
        myfunc2()
        # Output: myfunc2 was called
        # 现在一个叫做 func2.log 的文件出现了,里面的内容就是上面的字符串
    
    
        5.装饰器类
    
    

    9.异常处理写法以及如何主动抛出异常(应用场景)

      

    class MyException(Exception):
        def __init__(self,msg):
            self.msg = msg
        def __str__(self):
            return self.msg
    try:
        raise MyException("自定义的异常")
    except MyException as e:
        print(e)
    
    finally:
        print(123)

    10.什么是面向对象的mro

      

      1.python多继承
          一个类可以继承多个无关的类,一个类可以被多个无关的类继承
        2.经典类的mro
            在经典类中采用的是深度优先遍历方案
        3.新式类的mro
            merge方法
            class A(O):pass
            class B(O):pass
            class C(O):pass
            class E(A,B):pass
            class F(B,C):pass
            class G(E,F):pass
            mro(G)  = [G] + merge(mro[E], mro[F], [E,F])
                       = [G] + merge([E,A,B,O], [F,B,C,O], [E,F])
                       = [G,E] + merge([A,B,O], [F,B,C,O], [F])
                       = [G,E,A] + merge([B,O], [F,B,C,O], [F])
                       = [G,E,A,F] + merge([B,O], [B,C,O])
                       = [G,E,A,F,B] + merge([O], [C,O])
                       = [G,E,A,F,B,C] + merge([O], [O])
                       = [G,E,A,F,B,C,O]
        4.super()
            super()可以帮我们执行mro下一个父类的方法。通常super()有两个使用的地方
                1.可以访问父类的构造方法
                2.当子类方法想调用父类(mro)中的方法
            super是查找mro顺序中的下一个
            单继承中我们可以认为super是对父类中的属性或方法的引入
    
        class Init(object):
            def __init__(self, v):
                print("init")
                self.val = v
        class Add2(Init):
            def __init__(self, val):
                print("Add2")
                super(Add2, self).__init__(val)
                print(self.val)
                self.val += 2
        class Mult(Init):
            def __init__(self, val):
                print("Mult")
                super(Mult, self).__init__(val)
                self.val *= 5
        class HaHa(Init):
            def __init__(self, val):
                print("哈哈")
                super(HaHa, self).__init__(val)
                self.val /= 5
        class Pro(Add2,Mult,HaHa): #
            pass
        class Incr(Pro):
            def __init__(self, val):
                super(Incr, self).__init__(val)
                self.val+= 1
        # Incr Pro Add2 Mult HaHa Init
        p = Incr(5)
        print(p.val)
        c = Add2(2)
        print(c.val)
        提示. 先算MRO.然后看清楚self是谁.
        结论: 不管super()写在哪儿.在哪儿执行. 一定先找到MRO列表 根据MRO列列表的顺序往下找.否则⼀一切都是错的

    11.isinstance作用以及应用场景?

      isinstance作用:来判断一个对象是否是一个已知的类型;

    12.找到一个数组中两个值得和等于固定值(target)返回这俩值得索引

      

      def twoSum(self,nums,target):
            if len(nums) <= 1:
                return False
            buff_dict = {}
            for i in range(len(nums)):
                if nums[i] in buff_dict:
                    return [buff_dict[nums[i]],i]
                else:
                    buff_dict[target - nums[i]] = i

    13.json序列化时,可以处理的数据类型有哪些?如何定制支持datetime类型

      

    自定义时间序列化转换器
    import json
    from json import JSONEncoder
    from datetime import datetime
    class ComplexEncoder(JSONEncoder):
        def default(self,obj):
            if isinstance(obj,datetime):
                return obj.strftime("%Y-%m-%d %H:%M:%S")
            else:
                return super(ComplexEncoder,self).dafault(obj)
    d = {"name":"zhangw","date":datetime.now()}
    print(json.dumps(d,cls=ComplexEncoder))

    14.json序列化时遇到中文会默认转换成unicode  ,如何让他保留中文形式

    import json
    a = json.dumps({"ddf":"你好"},ensure_ascii=False)
    print(a)

    15.什么是断言?应用场景?

      python的assert是用来检查一个条件,如果它为真,就不做任何事。如果它为假,则  会抛出AssertError并且包含错误信息

      防御型编程
      运行时检查程序逻辑
      检查约定
      程序常量
      检查文档

    16.有用过with statement吗?它的好处是什么?

      with语句的作用是通过某种方法简化异常处理,它是所谓的上下文管理器的一种
         with语句会在嵌套的代码执行之后,自动关闭文件

    17.使用代码实现查看列举目录下的所有文件

      

    import os
     
    def dirpath(lpath, lfilelist):
        list = os.listdir(lpath)
        for f in list:
            file = os.path.join(lpath, f)  #拼接完整的路径
            if os.path.isdir(file):        #判断如果为文件夹则进行递归遍历
                dirpath(file, lfilelist)
            else:
                lfilelist.append(file)
        return lfilelist
     
     
    lfilelist = dirpath(os.getcwd(), [])
    for f in lfilelist:
        print(f)

    18.简述 yield和yield from关键字

      

    当一个函数中出现yield关键字时,这个函数就是一个生成器,可以用for循环或者next()函数来迭代
    yield可以接收到外界传入的变量
    
    yield from iterable == for item in iterable:yield item
  • 相关阅读:
    设计模式之享元模式
    延时任务的实现
    Git代码分支开发工作流程
    设计模式之责任链模式
    Docker 三剑客 到 k8s 介绍
    写操作系统之实现进程
    写操作系统之开发加载器
    写操作系统之开发引导扇区
    写操作系统之搭建开发环境
    怎么实现系统调用wait和exit
  • 原文地址:https://www.cnblogs.com/bk770466199/p/12671383.html
Copyright © 2011-2022 走看看