Python-常见面试题汇总

比眉伴天荒 2022-10-23 15:26 271阅读 0赞

**目录**

基础与特性

列举布尔值为False的常见值？

Python递归的最大层数？

print(\[i%2 for i in range(10)\])和print((i%2 for i in range(10)))的结果？

简述解释型语言和编译型语言？

解释器种类及特点

字符串格式化有哪几种？

简述字符串驻留机制？

什么是反射，举个例子

Python自省

Python作用域

函数及函数式编程

函数调用时参数传递方式？

什么是闭包？

什么是lambda函数？

装饰器

装饰器的作用和功能？

迭代器、生成器

迭代器和生成器的区别是什么？

拷贝

深拷贝和浅拷贝有什么区别？

线程、进程与协程

如何在Python中实现多线程？

协程

面向对象

Python的元类？

静态方法，类方法

类变量和实例变量

Python中单下划线和双下划线

重载

\_\_new\_\_和\_\_init\_\_的区别

文件

read,readline和readlines

内存管理

Python垃圾回收机制？

Python是如何进行内存管理的？

WEB

什么是wsgi,uwsgi,uWSGI?

Django、Flask的对比？

Django

django请求的生命周期？

列举django的内置组件？

简述什么是FBV和CBV？

django中csrf防御的实现机制

Django本身提供了runserver，为什么不能用来部署？

跨域问题如何解决？

参考

--------------------

# 基础与特性 #

## 列举布尔值为False的常见值？ ##

> 0,\[\],(),\{\},'',False,None

## Python递归的最大层数？ ##

> 998

def fun(num):
        if num == 0:
            return 0
        else:
            return fun(num - 1)
    
    
    if __name__ == '__main__':
        print(fun(998))

结果

> RecursionError: maximum recursion depth exceeded in comparison

## print(\[i%2 for i in range(10)\])和print((i%2 for i in range(10)))的结果？ ##

> >>> print(\[i%2 for i in range(10)\])  
> \[0, 1, 0, 1, 0, 1, 0, 1, 0, 1\]  
> >>> print((i%2 for i in range(10)))  
> <generator object <genexpr> at 0x00000283335C7F48>

一个是列表，一个是生成器/迭代器

## 简述解释型语言和编译型语言？ ##

> \-编译型（需要编译器，相当于用谷歌翻译）：编译型语言执行速度快，不依赖语言环境运行，跨平台差，如C/C++、Go执行速度快，调试麻烦
> 
> \-解释型（需要解释器，相当于同声传译）：解释型跨平台好，一份代码，到处使用，缺点是执行速度慢，依赖解释器运行，如Python、JAVA执行速度慢，调试方便

## 解释器种类及特点 ##

>     CPython是使用最广且被的Python解释器。  
>     IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。CPython用>>>作为提示符，而IPython用In\[序号\]：作为提示符。  
>     PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。  
>     Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。  
>     IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

## 字符串格式化有哪几种？ ##

占位符

> >>> 'hello,%s' % 'world'  
> 'hello,world'

format

> >>> 'hello,\{\}'.format('world')  
> 'hello,world'

f-string

> >>> f'hello,\{"world"\}'  
> 'hello,world'

## 简述字符串驻留机制？ ##

> 对于短字符串，将其照值给多个不同的对象时，内存中只有一个副本，多个对象共享该副本。**长字符串不遵守驻留机制。**  
> 驻留适用范围：由数字，字符和下划线组成的python标识符以及整数\[-5，256\]。

> >>> s1='hello\_world'  
> >>> s2='hello\_world'  
> >>> id(s1)  
> 2762526059824  
> >>> id(s2)  
> 2762526059824

> >>> s1='hello\_world'\*10000  
> >>> s2='hello\_world'\*10000  
> >>> id(s1)  
> 2762523045808  
> >>> id(s2)  
> 2762523155872

## 什么是反射，举个例子？ ##

反射是把字符串映射到实例的变量或者实例的方法然后可以去执行调用、修改等操作。利用以下四个内置函数：

*  getattr 获取指定字符串名称的对象属性
 *  setattr 为对象设置一个对象
 *  hasattr 判断对象是否有对应的对象（字符串）
 *  delattr 删除指定属性

例如：

> >>> s2='hello\_world'  
> >>> getattr(s2,'split')('\_')  
> \['hello', 'world'\]

## Python自省 ##

运行时获得对象的类型等，内置函数dir、type、isinstance等，利用了反射机制。

## Python作用域 ##

本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）

# 函数及函数式编程 #

## 函数调用时参数传递方式？ ##

函数传参是**引用传递**，函数外一直不变，需要区分对象是否可变。对于不可变类型，可以通过返回修改后的引用来改变它（指向其他地方）。

[函数基础总结与内置函数][Link 1]

## 什么是闭包？ ##

在一个函数内部的函数，具体来说：

*  必须有一个内嵌函数
 *  内嵌函数必须引用外部函数中的变量
 *  外部函数的返回值必须是内嵌函数

### **什么是lambda函数？** ###

lambda函数也叫**匿名函数**，该函数可以包含任意数量的参数，但只能**有一个执行操作的语句**。

## 装饰器 ##

### 装饰器的作用和功能？ ###

一句话：为已经存在的对象添加额外的功能

*  引入日志
 *  函数执行时间统计
 *  执行函数栈预备处理
 *  执行函数后的清理功能
 *  权限校验
 *  缓存

## 迭代器、生成器 ##

### 迭代器和生成器的区别是什么？ ###

**1、共同点**

生成器是一种特殊的迭代器。

**2、不同点**

a、语法上：

生成器是通过函数的形式中调用 **yield 或（）**的形式创建的，自动创建了\_\_iter\_\_()和next()方法，显得特别简洁，也是高效的。

迭代器可以通过iter()内置函数创建。

b、用法上：

生成器在调用next()函数或for循环中，所有过程被执行，且返回值，**需要的时候才返回**，生成器表达式比列表生成式更**节省内存**。

迭代器在调用next()函数或for循环中，所有值被返回，没有其他过程或动作。

## 拷贝 ##

### 深拷贝和浅拷贝有什么区别？ ###

在创建新实例类型时使用浅拷贝，并保留在新实例中复制的值。**浅拷贝用于复制引用指针**，就像复制值一样。这些引用指向原始对象，并且在类的任何成员中所做的更改也将影响它的原始副本。浅拷贝允许更快地执行程序，它取决于所使用的数据的大小。

**深拷贝用于存储已复制的值。**深拷贝不会将引用指针复制到对象。它引用一个对象，并存储一些其他对象指向的新对象。原始副本中所做的更改不会影响使用该对象的任何其他副本。由于为每个被调用的对象创建了某些副本，因此深拷贝会使程序的执行速度变慢。

浅拷贝拷贝数据集合的第一层数据，深拷贝拷贝数据集合的所有层。例如，一个列表list1，另一个列表list2中append了list1，使用copy标准库的copy和deepcopy分别浅拷贝和深拷贝为list3、list4，修改list1，list3会变化，list4不变。

# 线程、进程与协程 #

### 如何在Python中实现多线程？ ###

Python有一个多线程库，但是用多线程来加速代码的效果并不是那么的好，

Python有一个名为Global Interpreter Lock（GIL）的结构。GIL确保每次只能执行一个“线程”。一个线程获取GIL执行相关操作，然后将GIL传递到下一个线程。

虽然看起来程序被多线程并行执行，但它们实际上只是**轮流使用相同的CPU核心**。

所有这些GIL传递都增加了执行的开销。**这意味着多线程并不能让程序运行的更快。**

### 协程 ###

简单点说协程是进程和线程的升级版，进程和线程都面临着内核态和用户态的切换问题而耗费许多切换时间,而**协程就是用户自己控制切换的时机,不再需要陷入系统的内核态。**

Python里最常见的yield就是协程的思想!

# 面向对象 #

## Python的元类？ ##

先定义metaclass，就可以创建类，最后创建实例。

所以，**metaclass允许你创建类或者修改类**。换句话说，你可以把类看成是metaclass创建出来的“实例”。它指示Python解释器在创建`MyList`时，要通过`ListMetaclass.__new__()`来创建。

ORM就是一个典型的例子。

## 静态方法，类方法 ##

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>\</th> 
   <th>实例方法</th> 
   <th>类方法</th> 
   <th>静态方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>a = A()</td> 
   <td>a.foo(x)</td> 
   <td>a.class_foo(x)</td> 
   <td>a.static_foo(x)</td> 
  </tr> 
  <tr> 
   <td>A</td> 
   <td>不可用</td> 
   <td>A.class_foo(x)</td> 
   <td>A.static_foo(x)</td> 
  </tr> 
 </tbody> 
</table>

实例方法，类无法调用。类方法和静态方法类和实例都可以调用。A.class\_foo(x)可以理解为class\_foo(A,x)，a.class\_foo(x)可以理解为class\_foo(a,x)，a会转化为A。静态方法和类没有太大关系。

## 类变量和实例变量 ##

类变量是所有实例共享的

实例变量是实例单独拥有的

## Python中单下划线和双下划线 ##

双下划线"\_\_变量或函数\_\_"，是Python内部为了防止和用户自定义命名冲突。

双下划线"\_\_变量或函数"，解析器用`_classname__foo`来代替这个名字，以区别和其他类相同的命名,它无法直接像公有成员一样随便访问，通过对象名.\_类名\_\_xxx这样的方式可以访问。

单下划线"\_变量或函数"，是指定变量私有，不能通过from module import \*导入，其他地方和公有一样。

参考：[Python-面向对象编程总结][Python-]

## 重载 ##

1.  可变参数类型。
2.  可变参数个数。

基本的设计原则：仅仅当两个函数除了参数类型和参数个数不同以外，其功能是完全相同的，此时才使用函数重载。

## `__new__`和`__init__`的区别 ##

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

利用\_\_new\_\_可实现单例模式

# 文件 #

## read,readline和readlines ##

*  read 读取整个文件
 *  readline 读取下一行,使用生成器方法
 *  readlines 读取整个文件到一个迭代器以供我们遍历

# 内存管理 #

## Python垃圾回收机制？ ##

**垃圾回收：**

Python不像C++，Java等语言一样，他们可以不用事先声明变量类型而直接对变量进行赋值。对python语言来讲，对象的类型和内存都是在运行时确定的。这也是为什么我们称python语言为动态类型的原因（这里我们把动态类型语言可以简单的归结为对变量内存地址的分配是在运行时自动判断变量类型并对变量进行赋值）。

**引用计数：**

Python采用了类似windows内核对象一样的方式来对内存进行管理。每一个对象，都维护这一个**对指向该对象的引用的计数**。当变量被绑定在一个对象上的时候，该变量的引用计数就是1，，系统会自动维护这些标签，并定时扫描，当某标签的引用计数变为0的时候，该对象就会被回收。

**标记-清除：**

“标记-清除”不改动真实的引用计数，而是将集合中对象的引用计数复制一份副本，**改动该对象引用的副本**。对于副本做任何的改动，都不会影响到对象生命走起的维护。基本思路是先按需分配，等到没有空闲内存的时候**从寄存器和程序栈上的引用出发**，**遍历以对象为节点、以引用为边构成的图**，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。  
**分代回收：**

将系统中的所有内存块根据其存活时间划分为不同的集合，每一个集合就成为一个“代”，垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说，**活得越长的对象，就越不可能是垃圾**，就应该减少对它的垃圾收集频率。那么如何来衡量这个存活时间：通常是利用几次垃圾收集动作来衡量，如果一个对象经过的垃圾收集次数越多，可以得出：该对象存活时间就越长。

举例： 当某些内存块M经过了3次垃圾收集的清洗之后还存活时，我们就将内存块M划到一个集合A中去，而新分配的内存都划分到集合B中去。当垃圾收集开始工作时，大多数情况都只对集合B进行垃圾回收，而对集合A进行垃圾回收要隔相当长一段时间后才进行，这就使得垃圾收集机制需要处理的内存少了，效率自然就提高了。

## Python是如何进行内存管理的？ ##

**内存池机制：**

python的内存机制成金字塔形：

第-1，-2层主要有操作系统进行操作；

第0层是C中的malloc，free等内存分配和释放函数进行操作；

第1层和第2层是内存池，有python的接口函数PyMem\_Malloc函数实现，当对象小于256字节时由该层直接分配内存；

第三层是最上层，也就是我们对python对象的直接操作；

在C中如果频繁的调用malloc与free时，是会产生性能问题的，在加上频繁的分配和释放小块的内存会产生内存碎片。

python在这里主要干的工作有：

如果请求分配的内存在1~256字节之间就使用自己的内存管理系统，否则直接使用malloc。

这里还是会调用malloc分配内存，但每次回分配一块大小为256字节的大块内存。

经由内存池登记的内存到最后还是会回收到内存池，并不会调用C的free释放掉，以便下次使用。对于简单的python对象，例如数值、字符串、元组（tuple不允许被更改）采用的是复制的方式（深拷贝），也就是说当讲另一个变量B赋值给变量A时，虽然A和B的内存空间仍然相同，但是当A的值发生变化时，会重新给A分配空间，A和B的地址变得不再相同。

# WEB #

## 什么是wsgi,uwsgi,uWSGI? ##

WSGI:

web服务器网关接口，是一套协议。用于接收用户请求并将请求进行初次封装，然后将请求交给web框架。

实现wsgi协议的模块：wsgiref,本质上就是编写一socket服务端，用于接收用户请求（django)

werkzeug:本质上就是编写一个socket服务端，用于接收用户请求(flask)

uwsgi:与WSGI一样是一种通信协议，它是uWSGI服务器的独占协议，用于定义传输信息的类型。

uWSGI:是一个web服务器，实现了WSGI的协议，uWSGI协议，http协议

## Django、Flask的对比？ ##

1、 Django走的大而全的方向，开发效率高。它的MTV框架，自带的ORM,admin后台管理,自带的sqlite数据库和开发测试用的服务器，给开发者提高了超高的开发效率。 重量级web框架，功能齐全，提供一站式解决的思路，能让开发者不用在选择上花费大量时间。

自带ORM和模板引擎，支持jinja等非官方模板引擎。

自带ORM使Django和关系型数据库耦合度高，如果要使用非关系型数据库，需要使用第三方库

自带数据库管理app

成熟，稳定，开发效率高，相对于Flask，Django的整体封闭性比较好，适合做企业级网站的开发。python web框架的先驱，第三方库丰富

2、 Flask 是轻量级的框架，自由，灵活，可扩展性强，核心基于Werkzeug WSGI工具 和jinja2 模板引擎

适用于做小网站以及web服务的API,开发大型网站无压力，但架构需要自己设计

与关系型数据库的结合不弱于Django，而与非关系型数据库的结合远远优于Django

## Django ##

### django请求的生命周期？ ###

*  当用户在浏览器中输入url时，浏览器生成**请求头和请求体**发给服务端，请求头和请求体中包含浏览器的**动作(action)**，这个动作通常为Get或者Post
 *  url经过Django中的wsgi，再经过Django的中间件，最后url到**路由映射表**，在路由中一条一条进行匹配，一旦其中一条匹配成功就**执行对应的视图函数**，后面的路由就不再继续匹配了
 *  视图函数根据客户端的请求查询相应的数据，返回给Django，然后Django把客户端想要的数据返回
 *  客户端浏览器接收到返回的数据，经过渲染后显示给用户

### 列举django的内置组件？ ###

*  .Admin是对model中对应的数据表进行CRUD提供的组件
 *  .model组件：负责操作数据库
 *  .form组件：1.生成HTML代码 2.数据有效性校验 3校验信息返回并展示
 *  .ModelForm组件：用于数据库操作，也可用于用户请求的验证

### 简述什么是FBV和CBV？ ###

FBV和CBV本质是一样的，基于函数的视图叫做FBV，基于类的视图叫做CBV  
在python中使用CBV的优点：

*  提高了代码的复用性，可以使用**面向对象**的技术，例如Mixin（多继承）
 *  可以用**不同的函数**针对不同的**HTTP方法**处理，而不是通过很多if判断，提高代码可读性

### django中csrf防御的实现机制 ###

*  第一步：django第一次响应来自某个客户端的请求时，后端随机产生一个**token**值，把这个token保存在**SESSION**状态中，同时，后端把这个token放到**cookie**中交给前端页面
 *  第二步：下次前端需要发起请求的时候把这个token值加入到请求数据或者头信息中，一起传给后端；Cookies:\{csrf\_token:xxxxx\}
 *  第三步：后端校验前端请求带过来的token和SESSION里的token是否一致。

### Django本身提供了runserver，为什么不能用来部署？ ###

*  1.runserver方法是调试 Django 时经常用到的运行方式，它使用Django自带的**WSGI Server** 运行，主要在测试和开发中使用，并且 runserver 开启的方式也是单进程。
 *  2.uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http 等协议。注意uwsgi是一种通信协议，而uWSGI是实现uwsgi协议和WSGI协议的 Web 服务器。uWSGI具有**超快的性能、低内存占用和多app管理**等优点，并且搭配着Nginx就是一个生产环境了，能够将用户访问请求与应用 app 隔离开，实现真正的部署 。相比来讲，支持的并发量更高，方便管理多进程，发挥多核的优势，**提升性能**。

### 跨域问题如何解决？ ###

*  **cors：安装django-cors-headers**
 *  **jsonp**

不断更新中...

# 参考 #

某hub，写了审核不会通过，和牛客等平台

[Link 1]: https://blog.csdn.net/lady_killer9/article/details/108939273#%E4%BC%A0%E5%8F%82%E6%98%AF%E5%80%BC%E4%BC%A0%E9%80%92%E8%BF%98%E6%98%AF%E5%BC%95%E7%94%A8%E4%BC%A0%E9%80%92
[Python-]: https://blog.csdn.net/lady_killer9/article/details/109069147