2025年Python面试笔试题

第一題如下两段代码，运行結束後的成果是什么？与否相似？原因是什么？代码一代码二第二題4G内存怎么讀取一种5G的数据？第三題浅述深浅拷贝答案第一題成果不相似第一段成果為:[{'num':0},{'num':1},{'num':2},{'num':3},{'num':4},{'num':5},{'num':6},{'num':7},{'num':8},{'num':9}]第二段成果為:[{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9},{'num':9}]字典是可变类型，這裏l.append(a)相称于执行了浅拷贝,每变化一次a中num的值,所有a的值都将变化第二題实現措施有两种。实現措施一:措施一的实現思绪是通過生成器,一次讀取少許数据,原则答案是根据文献实現，這裏給出的例子是咸魚學习bobby老師的課程時记录的例子,不懂得怎样使用生成器完毕這個需求的朋友可以参照:实現措施二:在linux系统下使用split可以分割文献,對于多行文献可以使用按行分割的方式,對于單行的大文献可以采用按文献大小分割。按文献行数分割:split-l300large_file.logsmallfile_prefix按文献大小分割:split-b10mlarge_file.logsmallfile_prefix之後再按文献讀取即可。第一題下图中的打印成果分别是什么？第二題Python中静态措施、类措施、组员函数作用是什么？第三題說說對缺省参数的理解？*args是什么？**kwargs是什么？答案第一題前三個是True,最终一种會报錯。具前三個為何输出True,不理解的可以参照下图:图来源于bobby老師的异步IO编程課件最终一种為何报錯，我們可以先看下issubclass的使用方法:issubclass措施用于判断参数

class

与否是类型参数

classinfo

的子类

issubclass(class,

classinfo)

参数

class

--

类。

classinfo

--

类。

返回值

假如

class

是

classinfo

的子类返回

True，否则返回

False。

而在題目中b并不是一种类,因此报錯。第二題我們先理清晰静态函数、类函数分别是什么？静态措施是一种一般函数，就位于类定义的命名空间中，它不會對任何实例类型進行操作。使用装饰器@staticmethod定义静态措施。类對象和实例都可以调用静态措施。类措施是将类自身作為對象進行操作的措施。类措施使用@classmethod装饰器定义，其第一种参数是类，约定写為cls。第三題缺省参数是指在调用函数的時候没有传入参数的状况下，调用默认的参数，在调用函数的同步赋值時，所传入的参数會替代默认参数。*args是不定長参数，可以表达输入参数是不确定的，可以任意多种**kwargs是关键詞参数，赋值的時候是以键=值的方式，参数是可以任意多對。以上两個的使用是在定义函数的時候不确定會传入多少参数時使用。什么是鸭子类型？當看到一只鳥，走起来像鸭子、游泳起来像鸭子、叫起来像鸭子那么這只鳥就可以被称之為鸭子关注點在對象的行為，而不是类型(ducktyping)例如file,StringIO,socket對象都支持read/write措施(filelikeobject)例如定义了

_iter_

魔术措施的對象可以使用for鸭子类型更关注接口而非类型。什么是monkeypatch？那些地方用到了？自已怎样实現？所谓猴子补丁就是运行時替代gevent库需要修改内置的socketfromgeventimportmonkey;monkey.patch_socket()自已实現猴子补丁:import

time

print(time.time())

def

_time():

return

1234

time.time

=

_time

print(time.time)什么是自省？运行時判断一种對象的类型能力Python一切皆對象，用type,id,isinstance获取對象类型信息Inspect模块提供了更多获取對象信息的函数什么是列表或字典推导？类似:

[iforiinrange(10)ifi%2==0]一种迅速生成list/dict/set的措施,用来替代map/filter

python<br/>a=[1,2,3]<br/>b=['a','b','c']<br/>d={k:vfork,vinzip(b,a)}<br/>print(d)<br/>返回生成器:

(iforiinrange(10)ifi%2==0)Python2/3的差异點print成為函数编码問題,Python3不再有Unicode對象,默认str就是UnicodeUnicode(給人看的)

->

encode

->

字节串(給计算机看的)

传播的時候使用字节串,操作的時候使用UnicodePython3除法返回浮點数类型注解def

hello(name:

str)

->

str:

return

'hello'

+

name优化的super()以便调用父类函数高级解包操作:

a,b,*res=range(10)限定关键詞参数Python3重新抛出异常不會丢失栈信息(raisefrom)一切返回迭代器:range,zip,map,dict.valuesyieldform链接子生成器asyncio内置库,asyn/await原生协程支持异步编程兼容Python2/3的工具six模块2to3等工具转换代码_future_函数-如下代码分别输出什么?Python怎样传参？#

代码1

def

flist(l):

l.append(0)

print(l)

l

=

[]

flist(l)

flist(l)#

代码2

def

fstr(s):

s

+=

'a'

print(s)

s

=

'hehe'

flist(s)

flist(s)Python唯一支持的参数传递是共享传参,函数形参获得实参中各個引用的副本。Python可变/不可变:不可变對象->bool/int/float/tuple/str/frozenset

可变對象->list/dict/set#

测试例子1

def

clear_list(l):

l

=

[]

ll

=

[1,2,3]

clear_list(ll)

print(ll)

#

[1,2,3]默认参数只计算一次。#

测试例子2

def

flist(l=[1]):

l.append(1)

print(l)

flist()

flist()

#

[1,

1]

#

[1,

1,

1]函数-Python*args**kwargs都是什么？用来处理可变参数args被打包成tuplekwargs被打包成dictPython异常机制-什么是Python异常？Python使用异常处理錯误(有些語言使用錯误码)BaseExceptionSystemExit/KeyboardInterrupt/GeneratorExitExceptionPython异常机制-什么時候需要捕捉异常网络祈求(超時、连接錯误等)资源访問(权限問題,资源不存在)代码逻辑(越界访問,keyerror)Python异常机制-怎样处理异常?try:

#

fun

-

也許會抛出异常的代码

except

(Exception1,

Exception2)

as

e:

#

可以捕捉多种异常并处理

#

异常处理代码

else:

#

pass

异常没有发生時候的代码逻辑

finally:

#

pass

無论异常有無发生都會执行的代码，一般处理资源的关闭和释放Python异常机制-怎样自定义异常?继承Exception实現自定义异常給异常加上某些附加信息处理某些业务有关的特定异常(raiseMyException)GIL-什么是CPythonGIL?Cpython解释器的内存管理并不是线程安全保护多线程状况下對Python對象進行访問Cpython使用简朴的所机制防止多种线程同步执行字节码GIL影响是？GIL限制了程序的多核执行同一時间只能有一种线程执行字节码CPU密集程序难以运用多核优势IO期间會释放GIL,對IO密集程序影响不大怎样规避GIL影响？CPU密集可以使用多進程+進程池IO密集使用多线程/协程cython扩展怎样剖析程序性能？二八定律,大部分時间耗時在少許代码上内置的profile/cprofile等工具使用pyflame的火焰图工具什么是生成器生成器就是可以生成值得函数當一种函数裏有了yield关键字就成了生成器生成器可以挂起执行并且保持目前执行的状态服务器端优化措施数据构造与算法优化数据库层:索引优化,慢查询消除,批量操作減少IO,Nosql网络IO:批量操作,pipline操作減少IO缓存:使用内存数据库redis异步:asyncio,celery并发:gevent、多线程為何写單元测试?防止三無代码(無文档,無注释,無單测)保证代码逻辑的對的性單测影响设计,易测代码往往是高内聚低耦合的回归测试,防止改一处整個服务不可用單元测试库有哪些？nose/pytest较為常用moke模块用来模拟替代网络祈求coverage记录测试覆盖率1.怎样反向迭代一种序列#假如是一种list,最快的措施使用reverse

tempList=[1,2,3,4]

tempList.reverse()

forxintempList:

printx#假如不是list,需要手動重排

templist=(1,2,3,4)

foriinrange(len(templist)-1,-1,-1):

printtemplist[i]2.怎样查询和替代一种文本中的字符串#最简朴的措施使用replace()

tempstr="helloyouhellopythonareyouok"

printtempstr.replace("you","python")#還可以使用正则,有個sub()

tempstr="helloyouhellopythonareyouok"

importre

rex=r'(hello|Use)'

printre.sub(rex,"Bye",tempstr)3.使用python实現單例模式#措施一:可以使用__new__措施

#在__new__措施中把类实例绑定到类变量_instance上，假如cls._instance為None表达该类還没有实例化過，实例化该类并返回。假如cls_instance不為None表达该类已实例化，直接返回cls_instance

classSingleTon(object):

def__new__(cls,*args,**kwargs):

ifnothasattr(cls,'_instance'):

cls._instance=object.__new__(cls,*args,**kwargs)

returncls._instance

classTestClass(SingleTon):

a=1

test1=TestClass()

test2=TestClass()

printtest1.a,test2.a

test1.a=2

printtest1.a,test2.a

printid(test1),id(test2)#措施二:使用装饰器,建立過实例的就放到instances裏面,下次建立的時候先检查裏面有無

defSingleTon(cls,*args,**kwargs):

instances={}

printinstances

def_singleton():

ifclsnotininstances:

instances[cls]=cls(*args,**kwargs)

printinstances

returninstances[cls]

return_singleton

@SingleTon

classLastClass(object):

a=1

test1=LastClass()

printtest1.a

test2=LastClass()

printtest2.a#措施三:使用__metaclass__(元类)有关元类看看這個吧;

classSignalTon(type):

def__init__(cls,name,bases,dict):

super(SignalTon,cls).__init__(name,bases,dict)

cls._instance=None

def__call__(cls,*args,**kwargs):

ifcls._instanceisNone:

cls._instance=super(SignalTon,cls).__call__(*args,**kwargs)

returncls._instance

classTestClass(object):

__metaclass__=SignalTon

test1=TestClass()

test2=TestClass()

test1.a=2

printtest1.a,test2.a

printid(test1),id(test2)#措施四:共享属性

所谓單例就是所有的引用（实例，對象）拥有相似的属性和措施，同一种类的实例天生都會有相似的措施，那我們只需要保证同一种类所产生的实例都具有相似的属性。所有实例共享属性最简朴直接的措施就是共享__dict__属性指向。

classSingleTon(object):

_state={}

def__new__(cls,*args,**kwargs):

obj=object.__new__(cls,*args,**kwargs)

obj.__dict__=cls._state

returnobj

classTestClass(SingleTon):

a=1

test1=TestClass()

test2=TestClass()

printtest1.a,test2.a

test1.a=2

printtest1.a,test2.a

printid(test1),id(test2)

#措施五:使用同一种模版

#写在mysingleton.py中

classMy_Singleton(object):

deffoo(self):

pass

my_singleton=My_Singleton()

#写在要使用這個实例的py文献裏面,在不一样的引用的地方都引用相似的实例,以此实現單例模式

frommysingletonimportmy_singleton

my_singleton.foo()4.重新实現str.strip()defrightStrip(tempStr,splitStr):

endindex=tempStr.rfind(splitStr)

whileendindex!=-1andendindex==len(tempStr)-1:

tempStr=tempStr[:endindex]

endindex=tempStr.rfind(splitStr)

returntempStr

defleftStrip(tempStr,splitStr):

startindex=tempStr.find(splitStr)

whilestartindex==0:

tempStr=tempStr[startindex+1:]

startindex=tempStr.find(splitStr)

returntempStr

str="

H

"

printstr

printleftStrip(str,'')

printrightStrip(str,'')

#输出

H

H

H5.super的原理#阅讀下面的代码，它的输出成果是什么？

classA(object):

def__init__(self):

print"enterA"

super(A,self).__init__()

#new

print"leaveA"

classB(object):

def__init__(self):

print"enterB"

super(B,self).__init__()

#new

print"leaveB"

classC(A):

def__init__(self):

print"enterC"

super(C,self).__init__()

print"leaveC"

classD(A):

def__init__(self):

print"enterD"

super(D,self).__init__()

print"leaveD"

classE(B,C):

def__init__(self):

print"enterE"

super(E,self).__init__()

#change

print"leaveE"

classF(E,D):

def__init__(self):

print"enterF"

super(F,self).__init__()

#change

print"leaveF"

#输出

enterF

enterE

enterB

enterC

enterD

enterA

leaveA

leaveD

leaveC

leaveB

leaveE

leaveF6.闭包常用的装饰器就是闭包的一种

defmake_adder(addend):

defadder(addend):

returnaddend+addend

returnadder

P1=make_adder(5)

P2=make_adder(4)

printp1(10)

#输出15

printp2(10)

#输出14闭包（Closure）是詞法闭包（LexicalClosure）的简称，是引用了自由变量的函数。這個被引用的自由变量将和這個函数一同存在，虽然已經离開了发明它的环境也不例外

7.給列表中的字典排序list對象alist[{“name”:”a”,”age”:20},{“name”:”b”,”age”:30},{“name”:”c”,”age”:25}]按照age從大到小排序alist=[{"name":"a","age":20},{"name":"b","age":30},{"name":"c","age":25}]

alist.sort(key=lambda:x:-x.get("age"))

printalist8.合并两個列表排除反复元素用简洁的措施合并alist=[‘a’,’b’,’c’,’d’,’e’,’f’]

blist=[‘x’,’y’,’z’,’e’,’f’]并且元素不能反复alist=['a','b','c','d','e','f']

blist=['x','y','z','e','f']

defmerge_list(*args):

s=set()

foriinargs:

s=s.union(i)

print(s)

returns

merge_list(alist,blist)9.打乱一种排好序的列表fromrandomimportshuffle

alist=range(10)

print(alist)

shuffle(alist)

print(alist)10.简朴的实現一种栈构造stackclassStack(object):

def__init__(self):

self.value=[]

defpush(self,x):

self.value.append(x)

defpop(self):

self.value.pop()

stack=Stack()

stack.push(1)

stack.push(2)

stack.push(3)

print(stack.value)

stack.pop()

print(stack.value)11.输入一种曰期,返回時一年中的哪一天fromdatetimeimportdatetime

defwhich_day(year,month,day):

return(datetime(year,month,day)-datetime(year,1,1)).days+1

print(which_day(,1,15))12.把字符串”k1:1|k2:2|k3:3”处理成python字典的形式:{k1:1,k2:2,k3:3}defstring_to_dict(string):

d={}

forkvinstring.split("|"):

k,v=kv.split(":")

ifv.isdigit():

v=int(v)

d[k]=v

returnd

print(string_to_dict("k1:1|k2:2|k3:3"))13.判断输入的值与否在矩阵之中(杨氏矩阵)在一种二维数组之中,每一行都按照從走到右递增的次序排序,每一列到按照從上到下的次序排序.請完毕一种函数,输入這样的一种二维手术和一种整数,判断数组中与否具有该整数#处理数组矩阵

arr=[[1,4,7,10,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]]

defget_num(num,data=None):

whiledata:

ifnum>data[0][-1]:

deldata[0]

elifnum<data[0][-1]:

data=list(zip(*data))

deldata[-1]

data=list(zip(*data))