【面试复习】Python基础复习

前言

相信一些学习python的朋友找不到一些python的的朋友找不到相对应的python面经，所以博主就推荐大家可以去牛客上面看看哦，各种大厂面经和习题哦！

地址： 面经地址

new与init方法的区别

new在init之前被调用，new的返回值（实例）将传递给init方法的第一个参数(self)，然后init方法对这个实例(self)进行初始化;
new方法至少要有一个参数cls，此参数在实例化的时候python解释器自动提供，并且new方法必须要将实例化的实例对象返回；当然，继承自object的新式类才有new；
而init的第一个参数则为self，这个self就是new方法返回的实例对象，init的作用是为了初始化实例对象，而init方法则不需要有返回值；
new方法也可以认为，在init方法之前，开辟了一个实例对象的地址空间，然后将这个地址空间返回给init方法，让其在此地址空间进行开垦。

字典的键可以用于哪些类型

可变类型包括dict,list都不可以作为字典的key，而原子类型以及tuple则可以。

Python中的生成器

参考：

python 迭代器_和_生成器

生成器是一种特殊的迭代器，生成器自动实现了“迭代器协议”（即__iter__和next方法），不需要再手动实现两方法。

生成器在迭代的过程中可以改变当前迭代值，而修改普通迭代器的当前迭代值往往会发生异常，影响程序的执行。

其余

吐血总结！50道Python面试题集锦（附答案）

GC机制

GC机制也就是垃圾回收机制，在每个高级语言中都有自己的垃圾回收机制，在python中通过应用技术，标记清除和分代回收三种方案来实现
引用计数指: 每添加一个新的引用对象，对象引用就加1，每减少一个，对象应用就减1，一旦引用数为0时，改内存就被释放，这一点是因为python底层采用的是引用传递有关，而不是像go语言中采取的值传递标记清除：首先是标记对象，然后后一次性清除对象    分代回收：垃圾回收器会将不同的对象划分成不同的区域，然后每个区域处理间隔不同，通常根据对象的创建时间来定，对新对象会更加频繁的处理，对于经过几个时间周期之后仍然存在的对象会将该对象移入下一代中，处理间隔时间变长

引用计数为主，分代回收为辅。

引用计数

引用计数机制的优点：
1、简单
2、实时性：一旦没有引用，内存就直接释放了，不用像其他机制得等到特定时机。实时性还带来一个好处：处理回收内存的时间分摊到了平时。
引用计数机制的缺点：
1、维护引用计数消耗资源
2、循环引用

python中一切皆为对象，核心是一个结构体 PyObject其中维护了一个 int 型变量 ob_refcnt。

当对象有新的引用时候ob_refcnt就会增加1，同理删除就会减少。其中还有小整数对象池，大整数对象池等概念。此处就不在赘述。

引用计数为0时，该对象生命就结束了。

但此时会有一个十分严重的问题就是循环引用无法回收

什么是循环引用呢，就是如果⼀个数据结构引⽤了它⾃身，即如果这个数据结构是⼀个循环数据结构，那么某些引⽤计数值是肯定⽆法变成零的。比如循环链表，此处举一个简单的例子

class ClassA():def __init__(self):print('Object born,id:%s'%str(hex(id(self))))
def f2():while True:c1=ClassA()c2=ClassA()c1.t=c2c2.t=c1del c1del c2f2()

在执行del c1和c2时候，由于c1有指向c2的引用，c2有指向c1的引用。del之后两者引用数只会减少到1，并不会被回收。

分代回收

分代回收是一种以空间换时间的操作方式，Python将内存根据对象的存活时间划分为不同的集合，每个集合称为一个代，Python将内存分为了3“代”，分别为年轻代（第0代）、中年代（第1代）、老年代（第2代），他们对应的是3个链表，它们的垃圾收集频率随着对象存活时间的增大而减小。
新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推，老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。
同时，分代回收是建立在标记清除技术基础之上。分代回收同样作为Python的辅助垃圾收集技术处理那些容器对象

垃圾回收

有三种情况会触发垃圾回收：

调用gc.collect(),需要先导入gc模块。
当gc模块的计数器达到阈值的时候。
程序退出的时候。

标记清除

标记清除（Mark—Sweep）』算法是一种基于追踪回收（tracing GC）技术实现的垃圾回收算法。它分为两个阶段：第一阶段是标记阶段，GC会把所有的『活动对象』打上标记，第二阶段是把那些没有标记的对象『非活动对象』进行回收。那么GC又是如何判断哪些是活动对象哪些是非活动对象的呢？

对象之间通过引用（指针）连在一起，构成一个有向图，对象构成这个有向图的节点，而引用关系构成这个有向图的边。从根对象（root object）出发，沿着有向边遍历对象，可达的（reachable）对象标记为活动对象，不可达的对象就是要被清除的非活动对象。根对象就是全局变量、调用栈、寄存器。 mark-sweepg 在上图中，我们把小黑圈视为全局变量，也就是把它作为root object，从小黑圈出发，对象1可直达，那么它将被标记，对象2、3可间接到达也会被标记，而4和5不可达，那么1、2、3就是活动对象，4和5是非活动对象会被GC回收。

参考文章：python垃圾回收机制_Python 中的垃圾回收机制

collections模块

在内置数据类型的基础上，提供了几个额外的数据类型:nametuple  具名元组queue   队列deque    双端队列OrderdDict  有序字典defaultdict  默认值字典Counter     计数

装饰器

装饰器是由 名称空间，函数对象，闭包函数组合使用的一种方法
其核心是在不改变被装饰对象内部代码的前提下，给被装饰对象添加新的功能，当然可以通过面向对象的继承特性来实现同样的效果
装饰器可以分为无参装饰器和有参装饰器，多个装饰器的加载顺序是从下而上，执行顺序是从上而下

生成器和迭代器

生成器说白了就是一个函数对象，只不过在函数里面采用了yield关键字，在定义时是函数，被调用时就是一个生成器
生成器内置__iter__和__next__方法，所以生成器本身就是一个迭代器
生成器的优点: 能够返回多次值，可以挂起来保存函数的运行状态，能够减少内存的使用，在scrapy框架中，大量应用到了生成器，也可用用到大数据的获取或redis缓存时使用
迭代器特点是不依赖索引取值，有__iter__和__next__方法称为迭代器对象，有__iter__方法称为可迭代对象，可迭代对象，调用__iter__方法生成迭代器对象。for循环的本质就是想将可迭代对象生成迭代器对象，然后循环执行__next__方法取值，加上异常捕获出来，取不到值时结束取值

三元表达式、列表生成式、生成器对象

三元表达式，是python提供的一种简化代码的解决方案， 通过一行代码，使用if-else判断获取不同的值
列表生成式，就相当于把for循环写在列表中，一行代码完成一个功能，可以结合if-else使用
生成器对象，就是把列表生成式的[]换成()即可，不同的是，列表生成式返回的是一个列表，生成器表达式生成的是一个对象，相比之下，生成器表达式能够更节省内存
匿名函数: 需要将一个函数对象作为参数传递时,并且只有在一个地方会使用这个函数时，可以直接用lambda定义，通常与python的内置函数配合使用，如max,map,min等

函数递归

在调用一个函数的内部又调用自己，所以递归的本质就是一个循环，是用函数递归的大前提是一定要有一个结束条件，否则，会形成一个死循环。python解释器限制的递归深度大约为1000
递归分为递推和回溯两个阶段，递推，一层一层往下推，回溯一层一层向上返回

面向对象

面向对象编程的核心是对象两字，对象就是一个用来盛放数据与功能的容器，其优点是，扩展性强，但是也有缺点，就是提高了编程的复杂度在程序中，是先定义类，后产生对象。这里的对象就是一个个容器，类也可以看成一个容器，用来存放同类对象共有的数据和方法面向对象的三大特性: 封装，继承，多态封装: 就是将多个属性和方法封装都一个抽象的类中，所有类的对象都可以调用。针对封装的方法和属性，可以通过__将其隐藏起来，设置成私有属性，但这仅仅是一种变形操作，在外部可以通过_类名__属性名的方法调用,隐藏是对外不对内。
继承: 能够实现代码的重用、继承父类、重用父类的属性和方法、减少代码的冗余。继承是子类和父类之间的关系，需要先抽象再继承抽象: 最主要的作用是划分类别，总结类与类，对象与对象之间的相似之处，类与类之间的相似之处就可以拉出来写一个类用来继承python2中，有经典类和新式类之分，没有显示继承object的类及其子类都是经典类，显示继承object的类就是新式类
python3中，只有新式类，默认继承object类
差别:经典类的继承查找是深度优先新式类的继承查找是广度优先多态: 指的是一类事物有多种形态，多态性值得是可以在不用考虑对象具体类型的情况下而直接使用       多态性的本质在于不同的类中定有相同的方法名，这样就可以不用同一类而使用同一种方法来使用对象，python中一切皆对象，本身就支持多态性需要注意的是: 1. 多态指的的方法的多态，属性没有多态2. 多态存在两个必要的条件: 继承和方法重写可以通过父类中使用abstractmethod方法或raise抛异常的方法来限制子类中必须有某种方法应用:drf的源码中BaseSerializer类应用了这个方法鸭子类型: 是动态类型的一种风格，不管对象属于那个，也不管声明的具体接口是什么，只要对象实现了相应的方法，函数就可以在对象上执行操作。忽略了对象的真正类型，只关注对象又没有实现所需的方法。简单点说，只要你有同样的方法，就属于同一个类。我个人感觉，鸭子类型就是多态的进一步扩展，不需要继承和方法重写

继承原理 MRO方法

MRO列表会遵循如下三条准则
1. 子类会优先于父类被检查
2. 多个父类会根据它们在列表中的顺序被检查
3. 如果对下一个类存在两个合法的选择，选择第一个父类super()获得父类定义
在子类中，如果想要获得父类的方法，可以通过super()来做，super()代表父类的定义，而不是父类对象

绑定方法和非绑定方法

但凡在类中定义一个函数，默认就是绑定给对象的，应该由对象来调用，会将对象当作第一个参数自动传入
classmethods：绑定给类的方法，由类来调用，自动将类本身当作第一个参数传入
staticmethod：非绑定方法，不与类和对象绑定，类和对象都可以调用，普通函数，没有自动传值 property：一种特殊属性、访问它时会执行一段功能，用来绑定给对象的方法，将函数对象伪装成数据属性，然后返回值
应用：django模型类中写子序列化的方法，跨表操作abstractmethod: 实现多态性的一种限制，用来限制子类必须实现某种方法，也可以用raise抛异常的方式实现，在drf序列化源码baseserializer中有应用

反射

python的反射就是通过字符串操作对象相关的属性，python中一切皆对象，都可以用到反射
反射机制指的是在程序运行状态中对任意一个类，都可以知道这个类的所有属性和方法；对任意一个对象，都能调用他的任意方法和属性。这种动态获取程序信息以及动态调用对象的功能称为反射机制hasattr  检查是否含有属性getattr  获取属性setattr  设置属性delattr  删除属性好处:  可以提前定义好接口、接基于类的视图CBV源码中应用很多

CBV源码简述

根据请求方式的不同自动匹配执行对应的方法，在url路由中的views.类名.as_view()的源码下可以看到@classmethods修饰的类方法。内部定义闭包函数传参并返回闭包函数名、在django启动的时候会执行urls的as_view()产生变形为views.view,在接受请求的时候会触发view方法，通过view下的self使用用类产生对象。返回self.dispatch属性、在父类中的dispatch函数通过反射机制就通过字符串操作对象属性，执行对应的方法drf的APIView源码: 继承view,新增一点功能，使csrf认证在drf中失效

元类、魔法方法、猴子补丁

元类: 创建类的类就是元类，函数type其实就是一个元类,type就是python在背后用来创建所有类的元类。  object继承type类，type类又是object类的元类， type是type的元类魔法方法:__call__,__init__,__new__,__str__,__enter__,__exit__猴子补丁:猴子补丁主要功能就是动态的属性替换。用ujson替换json

进程线程协程

进程是CPU资源分配的基本单位，线程是独立运行和独立调度的基本单位（CPU上真正运行的是线程）
进程拥有自己的资源空间，一个进程包含若干个线程，线程与cpu资源分配无关，多个线程共享同一进程内的资源
线程的调度与切换比进程快很多协程是单线程下的并发，是一种用户态的轻量级线程，即协程是有用户程序自己控制调度的对于多核CPU，利用多进程+协程的方式，能充分利用CPU，获得极高的性能'''
通过gevent模块，实现并发同步或者异步编程，在gevent中用到的主要模式是Greenlet,
'''四种IO模型: 阻塞IO,非阻塞IO(发送请求后开始轮询直到数据返回),IO多路复用 利用select来监管多个程序 一旦某个程序需要的数据存在于内存中了 那么立刻通知该程序去取即可,异步IO 只需要发起一次系统调用 之后无需频繁发送 有结果并准备好之后会通过异步回调机制反馈给调用者

同步和异步

同步: 指提交一个任务，任务提交后在原地等待提交结束，之后再去提交下一个任务。没有得到结果之前，改调用就不会返回
异步: 提交一个任务，提交之后不能提交的任务运行完直接提交下一个任务。同步就是当一个进程发起一个函数（任务）调用的时候，一直等到函数 （任务）完成，而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数 返回，而是继续往下执行当，函数返回的时候通过状态、通知、事件等方式通知进程任务完成。

GIL锁/互斥锁

GIL锁: 全局解释器锁，它不是python的特性，它是cpython解释器，为了保证同一时刻只有一个线程可以执行代码而设计的。
只有当前线程遇到I/O,或者字节码执行100行(python中计时器时间达到阙值),才会释放GIL锁。线程的运行仍然有先后顺序，并不是同时进行python使用多进程可以利用多核CPU的优势多线程爬取比单线程性能有提升，因为遇到IO阻塞会自动释放GIL锁。多进程可以充分使cpu的两个内核，而多线程不能充分使用cpu的两个内核。GIL锁，导致我们使用多线程的时候无法实现并行解决方案:1. 更换解释器2. 使用其他语言，c go3. 采用多进程完成多任务的处理
采用多进程操作同一份数据，会出现数据错乱的问题
针对上述问题，解决方案就是进行加锁处理。将并发变成串行，通过牺牲效率保证数据安全
行锁，表锁，

HTTP/HTTPS协议

HTTP协议，又叫超文本传输协议，是一个基于请求响应，无状态，短链接，作用于tcp/ip应用层上的协议。规定了浏览器和服务端之间的数据交互的格式。缺点: 明文传输,不安全
HTTPS协议
安全超文本协议，HTTP+SSL/TLS，采用密文传输HTTP特点： (1)无状态：协议对客户端没有状态存储，对事物处理没有“记忆”能力，比如访问一个网站需要反复进行登录操作 (2)无连接：HTTP/1.1之前，由于无状态特点，每次请求需要通过TCP三次握手四次挥手，和服务器重新建立连接。比如 某个客户机在短时间多次请求同一个资源，服务器并不能区别是否已经响应过用户的请求，所以每次需要重新响应请 求，需要耗费不必要的时间和流量。 (3)基于请求和响应：基本的特性，由客户端发起请求，服务端响应 (4)简单快速、灵活 (5)通信使用明文、请求和响应不会对通信方进行确认、无法保护数据的完整性 HTTPS特点： (1)基于HTTP协议，通过SSL或TLS提供加密处理数据、验证对方身份以及数据完整性保护 (2)内容加密：采用混合加密技术,中间者无法直接查看明文内容 (3)验证身份：通过证书认证客户端访问的是自己的服务器 (4)保护数据完整性：防止传输的内容被中间人冒充或者篡改websocket协议  数据传输是密文
请求首行
请求头
请求体响应首行
响应头
响应体

tcp/udp协议

tcp协议:也叫流式协议，可靠传输协议，通过3次握手建立链接，四次挥手断开链接，数据通过连接通道传输，tcp提供超时重发，丢弃重复数据，检验数据，流量控制等功能，确保数据传输安全有保障。
udp协议:又叫不可靠传输协议，是一个简单的面向数据报的传输层协议。udp不可靠，只负责把数据报发送出去，不确保数据的安全抵达，没有超时重发等机制，因此传输速度很快

django

MTV

Django是一个由python 编写的一个开放源代码的 web 应用框架，特点是大而全，功能强大，有很多内置的中间件，可重用性高。能实习快速开发
Django的MTV模式本质上和MVC是一样的，只是在定义上有些许不同，
M: 模型  负载业务对象和数据库的关系映射ORM
T: 模板  负责如何把页面展示给用户
V: 视图  负责业务逻辑

docker

docker-compose单机下的容器编排工具,批量管理docker容器docker-compose中可以通过haproxy做负载均衡

Redis

Redis适合做计数器原因1.incr, decr  自增自检      incr ageincrby, decrby  增加减少指定数  incrby age 10 2. redis单线程架构(6.0之前的版本),无竞争,无线程切换
redis 单线程快的原因1. 基于内存2. 底层采用基于epll的io多路复用3. 避免了线程之间的切换和竞态消耗注意:做持久化的是另外的线程
计算网站每个用户主页的访问量可以用 hincrby 实现
muti 开启事务  watch + muti 实现乐观锁  网站日活用set类型,优化 hyperLogLog(或者布隆过滤器)完成日活统计乐观锁: 乐观的认为取出数据不一定修改,数据不加锁,修改前会再次取出数据,数据没改变,执行修改操作,改 变了就重新执行,或者不执行
悲观锁: 悲观的认为取出数据就一定修改,就给数据加锁,直到数据处理完,释放锁,别的线程才能拿到数据

Mysql索引原理

通过不断地缩小想要获取的数据的范围来筛选出最终想要的结果,同时把随机的事件变成顺序的事件
B+树特点,1. 非叶子结点不存储数据,只存储键(树的一个结点就是一个页,数据库中的页的大小是固定的,innodb存储引擎默认一页为16kb),所以在页大小固定的前提下,能放入更多的结点,相应的树的高度就会更矮,查找磁盘的IO操作就会更少,数据查询的效率也会更快2. B+树的所有数据都存储在叶子结点,并且是按找循序排序的。主键和唯一索引得区别主键是一种约束,唯一索引是一种索引,两者在本质上就不同主键创建后一定包含一个唯一索引,唯一索引并不一定就是主键唯一性索引允许为空,主键不允许为空  不为空+唯一索引主键索引可以被引用为外键,而唯一索引不能一个表只能由一个主键,唯一索引又多个

django_celery的使用流程

celery 提供异步任务,延迟任务(需要通过utc时间)和定时任务(也可以用linux的crontab来执行),
包结构:    1. 建一个celery_task包2. 在包里面建一个celery.py的文件，加载django环境(去manage.py中copy)3. 在reids中添加broker任务队列和任务执行完的结果存储在哪4. 生成一个celery对象,对象里面传入任务和任务路径5. 然后把任务分类建在不同的py文件中即可,最后启动worker和beat(触发器:到时间就把任务提交给celery)

冒泡排序

def hubble_sort(li):for i in range(len(li)-1):exchange = Falsefor j in range(len(li)-i-1):if li[j] > li[j+1]:li[j], li[j+1] = li[j+1], li[j]exchange = Trueif not exchange:return
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。        原理按照索引先获取一个值，然后比较这个值和后面值的大小，顺序，如果这个值小于后面的值，值做交换后，继续往后比较
可以通过for循环嵌套实现

选择排序

简单版本，每次取出列表中最小的值，append追加到一个空列表中def select_sort(li):for i in range(len(li) - 1):min_loc = i# 每一次循环，l[min_loc] 就是当前的最小值for j in range(i+1, len(li))if li[j] < li[min_loc]:min_loc = j# 交叉赋值，把最小的值放在前面if min_loc != i:li[i], li[min_loc] = li[min_loc], li[i]
通过循环,每次取出乱序列表中的最小值,然后把值追加到排好序的列表最后面

插入排序

def insert_sort(li):for i in range(1, len(li)):  # 排好序的最后一个值得索引tmp = li[i]j = i-1  # j 指得是手里得拍得下表while j >= 0 and li[j] > tmp:li[j+1] = li [j]j -= 1li[j+1] = tmp
1. 默认列表中第一个值是已经排好序的
2. 从乱序列表中,挨个取值j,与顺序列表的值从后往前依次做比较,当j的值小于已经排好序的列表中的值,把j的插入那个值前面,直到乱序列表中的值取完

Python中的Self详解

参考： Python中self_个人_理解

列表和元组的区别、哪个查询数据更快?

参考： python 元组(tuple)和列表（list）区别

tuple 不可变的好处

相对于 list 而言，tuple 是不可变的，这使得它可以作为 dict 的 key，或者扔进 set 里，而 list 则不行。

tuple 放弃了对元素的增删（内存结构设计上变的更精简），换取的是性能上的提升：创建 tuple 比 list 要快，存储空间比 list 占用更小。所以就出现了“能用 tuple 的地方就不用 list”的说法。

多线程并发的时候，tuple 是不需要加锁的，不用担心安全问题，编写也简单多了。

Python中的深浅拷贝

参考： _python_之浅_拷贝_和深_拷贝_的区别

浅拷贝：

浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。使用浅拷贝的时候，分为两种情况。

第一种，如果最外层的数据类型是可变的，比如说列表，字典等，浅拷贝会开启新的地址空间去存放。
第二种，如果最外层的数据类型是不可变的，比如元组，字符串等，浅拷贝对象的时候，还是引用对象的地址空间。

深拷贝：

深拷贝对一个对象是所有层次的拷贝（递归），内部和外部都会被拷贝过来。

深拷贝也分两种情况：

第一种，最外层数据类型可变。这个时候，内部和外部的都会拷贝过来。
第二种，外层数据类型不可变，如果里面是可变数据类型，会新开辟地址空间存放。如果内部数据类型不可变，才会如同浅拷贝一样，是对地址的引用。

深拷贝的作用：

减少内存的使用
以后在做数据的清洗、修改或者入库的时候，对原数据进行复制一份，以防数据修改之后，找不到原数据。

其他面经

地址：更多面经