面试八股文-Python基础

py的语言特性: 动态强类型

静/动态: 编绎/运行 时确定变量类型

弱/强类型: 会/不会发生隐式类型转换

py作为后端语言的优缺点

什么是duck type?

鸭子类型更关注对象的行为，只要实现了某种接口方法就行，而不在乎是什么类型

比如说定义了 __iter__魔法方法的类实例对象都可以用for来迭代

什么是monkey patch?

monkey patch就是运行时替换对象，本质上是对象的重新赋值

py3和py2的区别

可变对象与不可变对象

函数传递中*args，**kwargs

用来处理可变参数，接收参数后，args会变成一个tuple，kwargs会变成一个dict

什么时候需要捕获异常?

什么是CPython GIL?

GIL，Global Interpreter Lock，即全局解释器锁

引入GIL是因为CPython的内存管理并不是线程安全的,

为了保护多线程下对python对象的访问，每个线程在执行过程中都需要先获取GIL，保证同一时刻只有一个线程在执行代码

GIL使得python的多线程不能充分发挥多核CPU的性能，对CPU密集型程序的影响较大

什么是生成器?

生成器是一种可迭代对象，可以挂起并保持当前的状态

生成器遇到yield处会停止执行，调用next()或send()才会继续执行

定义一个生成器有两种方式，一种是生成器推导式，一种是在普通函数中添加yield语句并实例化

浅拷贝和深拷贝

浅拷贝出来的是一个独立的对象，但它的子对象还是原对象中的子对象

深拷贝会递归地拷贝原对象中的每一个子对象，因此拷贝后的对象和原对象互不相关。

迭代器与可迭代对象的区别

可迭代对象类，必须自定义__iter__()魔法方法，range，list类的实例化对象都是可迭代对象

迭代器类，必须自定义__iter__()和__next__()魔法方法，用iter()函数可以创建可迭代对象的迭代器

闭包

闭包就是一个嵌套函数，它的内部函数 使用了 外部函数的变量或参数,它的外部函数 返回了 内部函数

可以保存外部函数内的变量，不会随着外部函数调用完而销毁

python垃圾回收机制

引用计数为主，标记清除 和 分代回收为辅

引用计数机制是这样的

当对象被创建，被引用，作为参数传递，存储到容器中，引用计数+1

当对象离开作用域，引用指向别的对象，del，从容器中移除，引用计数-1

当引用计数降为0，python就会自动回收该对象所在的内存空间，

但是引用计数无法解决循环引用的问题，所以引入了标记清除和分代回收机制

async和await的作用

async: 声明一个函数为异步函数，函数内只要有await就要声明为async

await: 搭配asyncio.sleep()时会切换协程，当切换回来后再继续执行下面的语句

内置的数据结构和算法

collections模块

collections模块提供了一些好用的容器数据类型，其中常用的有: namedtuple，deque，Counter，OrderedDict，defaultdict

为什么dict查找的时间复杂度是O(1)?

dict底层是哈希表，哈希表类似于C语言的数组，可以实现按索引随机访问

但dict的key不一定是整数，需要先通过哈希函数，再经过取余操作转换为索引

list tuple的底层结构

list和tuple底层都是顺序表结构

list底层是可变数组，数组里存放的是元素对象的指针

set的底层结构

哈希表，key就是元素，value都是空

class方法 和 static方法的区别

class方法的第一个参数是cls，可以访问类属性，类方法

static方法和普通函数一样，只不过是放在类里，要通过类或实例来调用，但是它不能访问类和实例的属性和方法

什么是装饰器?

装饰器是一个接收函数作为参数的闭包函数

它可以在不修改函数内部源代码的情况下，给函数添加额外的功能

import time

def calc_time(func):
    def inner():
        t1 = time.time()
        func()
        t2 = time.time()
        print('cost time: {}s'.format(t2-t1))
    return inner

什么是元类? 使用场景

元类是创建类的类，type还有继承自type的类都是元类

作用: 在类定义时（new, init）和 类实例化时(call) 可以添加自定义的功能

使用场景: ORM框架中创建一个类就代表数据库中的一个表，但是定义这个类时为了统一需要把里面的类属性全部改为小写，这个时候就要用元类重写new方法，把attrs字典里的key转为小写

实现单例模式的三种方式

单例模式: 一个类只能创建一个实例化对象

class Foo():
    __instance = None

    def __new__(cls):
        if cls.__instance is None:
            cls.__instance = super().__new__(cls)
        return cls.__instance

class MyType(type):
    def __init__(self):
        super().__init__()
        self.__instance = None

    def __call__(self，*args，**kwargs):
        if not self.__instance:
            self.__instance = super().__call__(*args，**kwargs)
        return self.__instance
    
class Foo(metaclass=MyType):
    ...

def outter(cls):
    dct = {}
    def inner(*args，**kwargs):
        if cls not in dct:
            dct[cls] = cls(*args，**kwargs)
        return dct[cls]
    return inner

@outter
class Foo():
    ...

工厂模式

根据不同条件创建不同的类实例化对象

class CarFactory():
    def produce(self，name):
        if name == 'BYD':
            return BYD()
        elif name == 'BMW':
            return BMW()
        
class BYD():
    pass
    
class BMW():
    pass

car = CarFactory().produce('BMW')

来源：wslynn