49个Python基础面试题，看完轻松斩下offer

哈喽，小伙伴们还在找工作吗，还在为面试苦恼吗，还在为面试官会出什么题目而思绪万千吗，看完这篇文章，我相信小伙伴们的面试会水到渠成，加油，你们是最棒的。

1.、Python和Java、PHP、C、C#、C++等其他语言的对比？

（1）python代码，简介，明确，优雅，简单易懂

（2）开发效率高

（3）可扩展性强

2、简述解释型和编译型编程语言？

解释型：在执行程序时，计算机才一条一条的将代码解释成机器语言给计算机来执行

编译型：是把源程序的每一条语句都编译成机器语言，并保存成二进制文件，这样计算机运行该程序时可以直接以机器语言来运行此程序，运行速度很快。

3、Python解释器种类以及特点？

Cpython，IPython，Jpython，pypy，Ironpython

Python是一门解释器语言，代码想运行，必须通过解释器执行，Python存在多种解释器，分别基于不同语言开发，每个解释器有不同的特点，但都能正常运行Python代码，以下是常用的五种Python解释器：

CPython：当 从Python官方网站下载并安装好Python2.7后，就直接获得了一个官方版本的解

释器：Cpython，这个解释器是用C语言开发的，所以叫 CPython，在命名行下运行python，

就是启动CPython解释器，CPython是使用最广的Python解释器。

IPython：IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方

式上有所增强，但是执行Python代码的功能和CPython是完全一样的，好比很多国产浏览器

虽然外观不同，但内核其实是调用了IE。

PyPy：PyPy是另一个Python解释器，它的目标是执行速度，PyPy采用JIT技术，

对Python代进行动态编译，所以可以显著提高

Python代码的执行速度。

Jython：Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

IronPython：IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，

可以直接把Python代码编译成.Net的字节码。

在Python的解释器中，使用广泛的是CPython，对于Python的编译，除了可以采用以上解释器

进行编译外，技术高超的开发者还可以按照自己的需求自行编写Python解释器来执行Python代码，十分的方便！

4、请至少列举5个 PEP8 规范

（1）缩进：每一级4个缩进。连续跨行应该使用圆括号或大括号或者使用悬挂缩进。

（2）代码长度约束

一行列数：PEP8 规定最大为79列，如果拼接url很容易超限

一个函数：不可以超过30行；直观来讲就是完整显示一个函数一个屏幕就够了，不需要上下拖动

一个类：不要超过200行代码，不要超过10个方法

一个模块：不要超过500行

（3）import   不要在一句import中引用多个库

（4）命名规范

（5）注释   总体原则，错误的注释不如没有注释。所以当一段代码发生变化时，第一件事就是要修改注释！

5、通过代码实现如下转换：

答案： 二进制转换成十进制：v = “0b1111011”

print(int('0b1111011',2))

十进制转换成二进制：v = 18

print(bin(18))

八进制转换成十进制：v = “011”

print(int('011',8))

十进制转换成八进制：v = 30

print(oct(30))

十六进制转换成十进制：v = “0x12”

print(int('0x12',16))

十进制转换成十六进制：v = 87

print(hex(87))

6、请编写一个函数实现将IP地址转换成一个整数。

如 10.3.9.12 转换规则为：

10 00001010

3 00000011

9 00001001

12 00001100

再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？

答案： def func(x):

lis = x.strip().split('.')

li = [bin(int(i)) for i in lis]

li2 = [i.replace('0b',(10-len(i))*'0') for i in li]

return int(''.join(li2),2)

ret = func('10.3.9.12')

print(ret)

7、python递归的最大层数？

一般计算机默认的最大递归深度在1000左右，python最大递归深度一般在4000左右，跟计算

机的性能有关系，这个数不是一个定数，可通过一下方式测试

import sys

print(sys.getrecursionlimit())

print(sys.setrecursionlimit(10000))

8、求结果：

v1 = 1 or 3 -------------->1

v2 = 1 and 3-------------->3

v3 = 0 and 2 and 1-------->0

v4 = 0 and 2 or 1--------->1

v5 = 0 and 2 or 1 or 4---->1

v6 = 0 or Flase and 1----->False

9、ascii、unicode、utf-8、gbk 区别？

ASCII码：使用一个字节编码，所以它的范围基本是只有英文字母、数字和一些特殊符号 ，只有256个字符。

Unicode：能够表示全世界所有的字节

GBK：是只用来编码汉字的，GBK全称《汉字内码扩展规范》，使用双字节编码。

UTF-8：是一种针对Unicode的可变长度字符编码，又称万国码。

需要更多面试题的答案和资料，可以点击这里哦

10、三元运算规则以及应用场景？

规则：为真时的结果 if 判定条件 else 为假时的结果

```应用场景：在赋值变量的时候，可以直接加判断，然后赋值`

11、Python3和Python2中 int 和 long的区别？

python2有非浮点数准备的int和long类型。int类型最大值不能超过sys.maxint，而且这个最大值是平台相关的。

可以通过在数字的末尾附上一个Ｌ来定义长整型，显然，它比int类型表示的数字范围更大。在python3里，

只有一种整数类型int,大多数情况下，和python２中的长整型类似。

12、xrange和range的区别？

python２里，有两种方法获得一定范围内的数字：range(),返回一个列表，还有xrange(),返回一个迭代器。

python3　里，range()返回迭代器，xrange()不再存在。

13、字符串、列表、元组、字典每个常用的5个方法？

字符串：repleace,strip,split,reverse,upper,lower,join.....

列表：append,pop,insert,remove,sort,count,index.....

元组：index,count,__len__(),__dir__()

字典：get,keys,values,pop,popitems,clear,update,items.....

14、lambda表达式格式以及应用场景？

表达式格式：lambda后面跟一个或多个参数，紧跟一个冒号，以后是一个表达式。冒号前是参数，冒号后是返回值。例如：lambda x : 2x

应用场景：经常与一些内置函数相结合使用，比如说map(),filter(),sorted(),reduce()等

15、简述Python的深浅拷贝以及应用场景？

copy()：浅copy，浅拷贝指仅仅拷贝数据集合的第一层数据

deepcopy():深copy,深拷贝指拷贝数据集合的所有层

16、Python垃圾回收机制？

python采用的是引用计数机制为主，标记-清除和分代收集(隔代回收、分代回收)两种机制为辅的策略

计数机制

Python的GC模块主要运用了引用计数来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”

解决容器对象可能产生的循环引用的问题。通过分代回收以空间换取时间进一步提高垃圾回收的效率。

标记-清除：

标记-清除的出现打破了循环引用，也就是它只关注那些可能会产生循环引用的对象

缺点：该机制所带来的额外操作和需要回收的内存块成正比。

隔代回收

原理：将系统中的所有内存块根据其存活时间划分为不同的集合，每一个集合就成为一个“代”，

垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说，活得越长的对象，就越不可能是垃圾，

就应该减少对它的垃圾收集频率。那么如何来衡量这个存活时间：通常是利用几次垃圾收集动作来衡量，

如果一个对象经过的垃圾收集次数越多，可以得出：该对象存活时间就越长。

17、python的可变类型和不可变类型？

不可变类型（数字、字符串、元组、不可变集合）

可变类型（列表、字典、可变集合）

18、求结果：

v = dict.fromkeys(['k1','k2'],[])

v['k1'].append(666)

print(v)

v['k1'] = 777

print(v)

答案：{'k1':[666],'k2':[666]}

{'k1':777,'k2':[666]}

解析：formkeys()默认参数为可变数据类型时有坑

19、求结果：

def num():

return [lambda x: i*x for i in range(4)]

print([m(2) for m in num()])

答案：[6, 6, 6, 6]

解析： 问题的本质在与python中的属性查找规则，LEGB（local，enclousing，global，bulitin），

在上面的例子中，i就是在闭包作用域（enclousing），而Python的闭包是 迟绑定 ，

这意味着闭包中用到的变量的值，是在内部函数被调用时查询得到的

所以：[lambda x: i*x for i in range(4)]打印出来是含有四个内存地址的列表，每个内存地址中的i

在在本内存中都没有被定义，而是通过闭包作用域中的i值，当for循环执行结束后，i的值等于3，所以

再执行[m(2) for m in num()]时，每个内存地址中的i值等于3，当x等于2时，打印出来的结果都是6，

从而得到结果[6, 6, 6, 6]。

20、一行代码实现9*9乘法表。

lis = ['%s*%s=%s'%(i,j,i*j) for i in range(1,10) for j in range(i,10)]

21、如何安装第三方模块？以及用过哪些第三方模块？

pip3 imstall 模块名

django，Matplotlib，Tornado，PyGame

22、至少列举8个常用模块都有那些？

os,sys,time,random,re,hashlib,logging,json,pickle....

23、re的match和search区别？

match:从字符串的开头位置匹配，必须以此为开头

search:从开头开始查，找到符合的就返回结果

24、什么是正则的贪婪匹配？

正则表达式一般趋向于最大长度匹配

25、求结果：

a. [ i % 2 for i in range(10) ] ===>[0,1,0,1,0,1,0,1,0,1]

b. ( i % 2 for i in range(10) )===>返回一个生成器的内存地址

26、求结果：

a. 1 or 2 =========>1

b. 1 and 2 ========>2

c. 1 < (2==2)======>false

d. 1 < 2 == 2======>ture

27、比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别？

a = [1,2,3]正常的列表

b = [(1),(2),(3)] 虽然列表的每个元素加上了括号，但是当括号内只有一个元素并且没有逗号时，其数据类型是元素本身的数据类型

b = [(1,),(2,),(3,)]列表中的元素类型都是元组类型

28、如何在函数中设置一个全局变量 ?

使用python的内置语法 globals 全局变量

29、logging模块的作用？以及应用场景？

logging模块的作用：

（1）程序调试

（2）了解软件程序运行情况，是否正常

（3）软件程序运行故障分析与问题定位

应用场景：网站的运维工作，程序实时监控

30、请用代码简答实现stack 。

def Stack(object):

def __init__(self):

self.stack = []

def push(self,value):

# 进栈

self.stack.append(value)

def pop(self):

# 出栈

if self.stack:

self.stack.pop()

else:

raise LookupError('stack is empty!')

def is_empty(self):

# 查看stack是否为空

reture bool(self.stack)

def top(self):

# 取出stack中最新的值

return self.stack[-1]

31、常用字符串格式化哪几种？

1、%s %d

2、format格式化输出

3、print(f'内容{变量名}')

32、简述 生成器、迭代器、可迭代对象 以及应用场景？

生成器：在 Python 中，一边循环一边计算的机制，称为 生成器（generator），

通过next()取值，两种表现形式1、将列表生成式的[]改为()2、含有yield关键字的函数

应用场景：优化代码，节省内存

迭代器：是访问集合元素的一种方式。迭代器同时实现了__iter__和__next__方法

可迭代对象：只要实现了__iter__方法的对象就是可迭代对象

33、用Python实现一个二分查找的函数。

lis = [0, 1, 3, 4, 5, 6, 7, 9, 10, 11,12,16,17]

def two_find(x, lis, start=0, end=None):

if end == None:end = len(lis) - 1

num = (end - start) // 2 + start

if end > start:

if lis[num] > x:

return two_find(x, lis, start=start, end=num)

elif lis[num] < x:

return two_find(x, lis, start=num + 1, end=end)

elif lis[num] == x:

return num

elif lis[end] == x:return end

else:return None

print(two_find(17, lis))

34、谈谈你对闭包的理解？

在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。

但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。

35、os和sys模块的作用？

os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;

sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

36、谈谈你对面向对象的理解？

面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，

不存在的也可以创造出来。对象是特征和技能的结合，其中特征和技能分别对应对象的数据属性和方法属性。

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，

面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。

37、Python面向对象中的继承有什么特点？

（1）在继承中基类的构造(__init__()方法)不会被自动调用，它需要在其派生类的构造中亲自专门调用。

（2）在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。

  区别于在类中调用普通函数时并不需要带上self参数

（3）Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。(先在本类中查找调用的方法，找不到才去基类中找)

38、面向对象深度优先和广度优先是什么？

Python的类可以继承多个类，那么其寻找类方法的方式有两种：

当类是经典类时(主要在python2版本中的没有主动继承object的类)，多继承情况下，会按照深度优先方式查找

当类是新式类时(python3版本中的所有类和python2中主动继承object的类)，多继承情况下，会按照广度优先方式查找

简单点说就是：经典类是纵向查找，新式类是横向查找

39、面向对象中super的作用？

（1）super在面向对象继承类中代指父类，书写方法super(类名,self).属性或者方法或super().属性或者方法

（2）super方法可以增加类之间调用的灵活性，当父类名发生变化时不必修改

（3）super方法在类的多继承时可以简化代码，避免代码冗余

（4）super机制里可以保证公共父类仅被执行一次，执行的顺序遵循MRO，广度优先查询方法

40、静态方法和类方法区别？

静态方法：是既不是用类中的属性又不使用对象中的属性，由类或者对象调用的方法，依赖python装饰器@staticmethod来实现

类方法：只使用类中的静态变量，一般都是由类调用，依赖python装饰器@classmethod来实现

41、列举面向对象中的特殊成员以及应用场景？

__call__：对象的构造方法，对象加上()，可以触发这个类的__call__方法。

__len__：内置函数的len函数是依赖类中的__len__方法

__eq__：判断值是否相等的时候依赖__eq__方法

__hash__:判断hash值是否相等的时候依赖__hash__方法(拓展：set的去重机制其实就是根据__hash__和__eq__方法实现的)

__str__：和str() print() %s 都是息息相关的，返回值一定是字符串类型

__repr__：和 repr() %r都是息息相关的，在没有__str__方法时，__repr__可以完全取代__str__。

__del__ 析构方法，对应着一个对象的删除之前执行的内容

42、什么是反射？以及应用场景？

定义：通过用字符串数据类型的变量名来访问这个变量的值，在python面向对象中的反射,通过字符串的形式操作对象相关的属性或方法.

应用场景：用于处理通过用户输入，文件读取，或者网络传输所得到的字符串形式的指令来完成对应的操作

43、metaclass作用？以及应用场景？

metaclass，直译为元类，简单的解释就是：当我们定义了类以后，就可以根据这个类创建出实例，

所以：先定义类，然后创建实例。但是如果我们想创建出类呢？那就必须根据metaclass创建出类，

所以：先定义metaclass，然后创建类。换句话说，你可以把类看成是metaclass创建出来的“实例”

44、什么是面向对象的mro

MRO(Method Resolution Order 方法解析顺序)是面向对象中用于查询类的多继承的继承顺序的方法，

它是基于算法来实现的，不同的算法实现的MRO的顺序不同

45、什么是断言？应用场景？

assert 条件,'自定义错误提示(可有可无)' 例：assert 1 == 0,'这是一个低级的错误'

合约式设计是断言的经典应用，在一个正确的程序里，所有的前置条件和后置条件都将得到处理。

46、使用代码实现查看列举目录下的所有文件。

方法一：递归处理

import os

url = r'C:\Users\Mr.Wang\PycharmProjects\\untitled\前段学习'

def check_file(url,li = []):

if os.path.isdir(url):

file_list = os.listdir(url)

for ret in file_list:

base_url = os.path.join(url,ret)

if os.path.isfile(base_url):

li.append(ret)

else: check_file(base_url)

return li

else:return os.path.basename(url)

方法二：堆栈的思想处理

import os

url = r'C:\Users\Mr.Wang\PycharmProjects\\untitled\python基础'

lis = [url]

while lis:

url = lis.pop()

ret_list = os.listdir(url)

for name in ret_list:

abs_path = os.path.join(url,name)

if os.path.isdir(abs_path):

lis.append(abs_path)

else:print(name)

47、代码实现六位随机验证码

import random

s = ''

for i in range(6):

num = random.randint(0,9)

alpha1 = chr(random.randint(65,90))

alpha2 = chr(random.randint(97,122))

ret = random.choice([num,alpha1,alpha2])

s += str(ret)

print(s)

48、代码实现随机发红包功能

import random

def red_packge(money,num):

li = random.sample(range(1,money*100),num-1)

li.extend([0,money*100])

li.sort()

return [(li[index+1]-li[index])/100 for index in range(num)]

ret = red_packge(100,10)

print(ret)

import random

def red_packge(money,num):

li = random.sample(range(1,money*100),num-1)

li.extend([0,money*100])

li.sort()

for index in range(num):

yield (li[index+1]-li[index])/100

ret = red_packge(100,10)

print(ret)

49、请尽可能列举python列表的成员方法，并给出列表操作的答案：

（1） a=[1, 2, 3, 4, 5], a[::2]=？ a[-2:]=？

a[::2]=[1,3,5],

a[-2:] = [4,5]

（2）一行代码实现对列表a中的偶数位置的元素进行加3后求和？

sum([i+3 for i in a[::2]])

（3）将列表a的元素顺序打乱，再对a进行排序得到列表b，然后把a和b按元素顺序构造一个字典d。

import random

random.shuffle(a)

b=a.sort()

d={}

for i in range(len(a)):d[a[i]] = b[i]

看完后，麻烦小伙伴们点个赞呗，有需要Python学习资料的小伙伴吗?我整理了一套Python资料和PDF文档，感兴趣的可以在下方留言或者私信我哦