基础篇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