头条Python面试题3文档格式.docx
《头条Python面试题3文档格式.docx》由会员分享,可在线阅读,更多相关《头条Python面试题3文档格式.docx(14页珍藏版)》请在冰豆网上搜索。
![头条Python面试题3文档格式.docx](https://file1.bdocx.com/fileroot1/2023-1/21/90ff7560-fca7-47a8-ab17-087680e9a0ef/90ff7560-fca7-47a8-ab17-087680e9a0ef1.gif)
importos
forsChildinos.listdir(sPath):
sChildPath=os.path.join(sPath,sChild)
ifos.path.isdir(sChildPath):
print_directory_contents(sChildPath)
else:
printsChildPath
特别要注意以下几点:
∙命名规范要统一。
如果样本代码中能够看出命名规范,遵循其已有的规范。
∙递归函数需要递归并终止。
确保你明白其中的原理,否则你将面临无休无止的调用栈(callstack)。
∙我们使用os模块与操作系统进行交互,同时做到交互方式是可以跨平台的。
你可以把代码写成sChildPath=sPath+'
/'
+sChild,但是这个在Windows系统上会出错。
∙熟悉基础模块是非常有价值的,但是别想破脑袋都背下来,记住Google是你工作中的良师益友。
∙如果你不明白代码的预期功能,就大胆提问。
∙坚持KISS原则!
保持简单,不过脑子就能懂!
∙说明面试者对与操作系统交互的基础知识
∙递归真是太好用啦
问题3
阅读下面的代码,写出A0,A1至An的最终值。
A0=dict(zip(('
a'
'
b'
c'
d'
e'
),(1,2,3,4,5)))A1=range(10)A2=[iforiinA1ifiinA0]A3=[A0[s]forsinA0]A4=[iforiinA1ifiinA3]A5={i:
i*iforiinA1}A6=[[i,i*i]foriinA1]
A0={'
:
1,'
3,'
2,'
5,'
4}A1=[0,1,2,3,4,5,6,7,8,9]A2=[]A3=[1,3,2,5,4]A4=[1,2,3,4,5]A5={0:
0,1:
1,2:
4,3:
9,4:
16,5:
25,6:
36,7:
49,8:
64,9:
81}A6=[[0,0],[1,1],[2,4],[3,9],[4,16],[5,25],[6,36],[7,49],[8,64],[9,81]]
∙列表解析(listcomprehension)十分节约时间,对很多人来说也是一个大的学习障碍。
∙如果你读懂了这些代码,就很可能可以写下正确地值。
∙其中部分代码故意写的怪怪的。
因为你共事的人之中也会有怪人。
问题4
Python和多线程(multi-threading)。
这是个好主意码?
列举一些让Python代码以并行方式运行的方法。
Python并不支持真正意义上的多线程。
Python中提供了多线程包,但是如果你想通过多线程提高代码的速度,使用多线程包并不是个好主意。
Python中有一个被称为GlobalInterpreterLock(GIL)的东西,它会确保任何时候你的多个线程中,只有一个被执行。
线程的执行速度非常之快,会让你误以为线程是并行执行的,但是实际上都是轮流执行。
经过GIL这一道关卡处理,会增加执行的开销。
这意味着,如果你想提高代码的运行速度,使用threading包并不是一个很好的方法。
不过还是有很多理由促使我们使用threading包的。
如果你想同时执行一些任务,而且不考虑效率问题,那么使用这个包是完全没问题的,而且也很方便。
但是大部分情况下,并不是这么一回事,你会希望把多线程的部分外包给操作系统完成(通过开启多个进程),或者是某些调用你的Python代码的外部程序(例如Spark或Hadoop),又或者是你的Python代码调用的其他代码(例如,你可以在Python中调用C函数,用于处理开销较大的多线程工作)。
为什么提这个问题
因为GIL就是个混账东西(A-hole)。
很多人花费大量的时间,试图寻找自己多线程代码中的瓶颈,直到他们明白GIL的存在。
问题5
你如何管理不同版本的代码?
答案:
版本管理!
被问到这个问题的时候,你应该要表现得很兴奋,甚至告诉他们你是如何使用Git(或是其他你最喜欢的工具)追踪自己和奶奶的书信往来。
我偏向于使用Git作为版本控制系统(VCS),但还有其他的选择,比如subversion(SVN)。
因为没有版本控制的代码,就像没有杯子的咖啡。
有时候我们需要写一些一次性的、可以随手扔掉的脚本,这种情况下不作版本控制没关系。
但是如果你面对的是大量的代码,使用版本控制系统是有利的。
版本控制能够帮你追踪谁对代码库做了什么操作;
发现新引入了什么bug;
管理你的软件的不同版本和发行版;
在团队成员中分享源代码;
部署及其他自动化处理。
它能让你回滚到出现问题之前的版本,单凭这点就特别棒了。
还有其他的好功能。
怎么一个棒字了得!
问题6
下面代码会输出什么:
deff(x,l=[]):
foriinrange(x):
l.append(i*i)
printl
f
(2)f(3,[3,2,1])f(3)
[0,1][3,2,1,0,1,4][0,1,0,1,4]
呃?
第一个函数调用十分明显,for循环先后将0和1添加至了空列表l中。
l是变量的名字,指向内存中存储的一个列表。
第二个函数调用在一块新的内存中创建了新的列表。
l这时指向了新生成的列表。
之后再往新列表中添加0、1、2和4。
很棒吧。
第三个函数调用的结果就有些奇怪了。
它使用了之前内存地址中存储的旧列表。
这就是为什么它的前两个元素是0和1了。
不明白的话就试着运行下面的代码吧:
l_mem=[]
l=l_mem#thefirstcallforiinrange
(2):
printl#[0,1]
l=[3,2,1]#thesecondcallforiinrange(3):
printl#[3,2,1,0,1,4]
l=l_mem#thethirdcallforiinrange(3):
printl#[0,1,0,1,4]
问题7
“猴子补丁”(monkeypatching)指的是什么?
这种做法好吗?
“猴子补丁”就是指,在函数或对象已经定义之后,再去改变它们的行为。
举个例子:
importdatetimedatetime.datetime.now=lambda:
datetime.datetime(2012,12,12)
大部分情况下,这是种很不好的做法-因为函数在代码库中的行为最好是都保持一致。
打“猴子补丁”的原因可能是为了测试。
mock包对实现这个目的很有帮助。
为什么提这个问题?
答对这个问题说明你对单元测试的方法有一定了解。
你如果提到要避免“猴子补丁”,可以说明你不是那种喜欢花里胡哨代码的程序员(公司里就有这种人,跟他们共事真是糟糕透了),而是更注重可维护性。
还记得KISS原则码?
答对这个问题还说明你明白一些Python底层运作的方式,函数实际是如何存储、调用等等。
另外:
如果你没读过mock模块的话,真的值得花时间读一读。
这个模块非常有用。
问题8
这两个参数是什么意思:
*args,**kwargs?
我们为什么要使用它们?
如果我们不确定要往函数中传入多少个参数,或者我们想往函数中以列表和元组的形式传参数时,那就使要用*args;
如果我们不知道要往函数中传入多少个关键词参数,或者想传入字典的值作为关键词参数时,那就要使用**kwargs。
args和kwargs这两个标识符是约定俗成的用法,你当然还可以用*bob和**billy,但是这样就并不太妥。
下面是具体的示例:
deff(*args,**kwargs):
printargs,kwargs
l=[1,2,3]t=(4,5,6)d={'
7,'
8,'
9}
f()f(1,2,3)#(1,2,3){}f(1,2,3,"
groovy"
)#(1,2,3,'
groovy'
){}f(a=1,b=2,c=3)#(){'
2}f(a=1,b=2,c=3,zzz="
hi"
)#(){'
zzz'
'
hi'
}f(1,2,3,a=1,b=2,c=3)#(1,2,3){'
2}
f(*l,**d)#(1,2,3){'
7,'
9,'
8}f(*t,**d)#(4,5,6){'
8}f(1,2,*t)#(1,2,4,5,6){}f(q="
winning"
**d)#(){'
q'
winning'
'
8}f(1,2,*t,q="
**d)#(1,2,4,5,6){'
8}
deff2(arg1,arg2,*args,**kwargs):
printarg1,arg2,args,kwargs
f2(1,2,3)#12(3,){}f2(1,2,3,"
)#12(3,'
){}f2(arg1=1,arg2=2,c=3)#12(){'
3}f2(arg1=1,arg2=2,c=3,zzz="
)#12(){'
}f2(1,2,3,a=1,b=2,c=3)#12(3,){'
f2(*l,**d)#12(3,){'
8}f2(*t,**d)#45(6,){'
8}f2(1,2,*t)#12(4,5,6){}f2(1,1,q="
**d)#11(){'
8}f2(1,2,*t,q="
**d)#12(4,5,6){'
有时候,我们需要往函数中传入未知个数的参数或关键词参数。
有时候,我们也希望把参数或关键词参数储存起来,以备以后使用。
有时候,仅仅是为了节省时间。
问题9
下面这些是什么意思:
@classmethod,
@staticmethod,
@property?
回答背景知识
这些都是装饰器(decorator)。
装饰器是一种特殊的函数,要么接受函数作为输入参数,并返回一个函数,要么接受一个类作为输入参数,并返回一个类。
@标记是语法糖(syntacticsugar),可以让你以简单易读得方式装饰目标对象。
@my_decoratordefmy_func(stuff):
do_thingsIsequivalentto
defmy_func(stuff):
do_things
my_func=my_decorator(my_func)
你可以在本网站上找到介绍装饰器工作原理的教材。
真正的答案
@staticmethod和@property这三个装饰器的使用对象是在类中定义的函数。
下面的例子展示了它们的用法和行为:
classMyClass(object):
def__init__(self):
self._some_property="
propertiesarenice"
self._some_other_property="
VERYnice"
defnormal_method(*args,**kwargs):
print"
callingnormal_method({0},{1})"
.format(args,kwargs)
@classmethod
defclass_method(*args,**kwargs):
callingclass_method({0},{1})"
@staticmethod
defstatic_method(*args,**kwargs):
callingstatic_method({0},{1})"
@property
defsome_property(self,*args,**kwargs):
callingsome_propertygetter({0},{1},{2})"
.format(self,args,kwargs)
returnself._some_property
@some_property.setter
callingsome_propertysetter({0},{1},{2})"
self._some_property=args[0]
defsome_other_property(self,*args,**kwargs):
callingsome_other_propertygetter({0},{1},{2})"
returnself._some_other_property
o=MyClass()#未装饰的方法还是正常的行为方式,需要当前的类实例(self)作为第一个参数。
o.normal_method#<
boundmethodMyClass.normal_methodof<
__main__.MyClassinstanceat0x7fdd2537ea28>
>
o.normal_method()#normal_method((<
),{})
o.normal_method(1,2,x=3,y=4)#normal_method((<
1,2),{'
y'
4,'
x'
3})
#类方法的第一个参数永远是该类
o.class_method#<
boundmethodclassobj.class_methodof<
class__main__.MyClassat0x7fdd2536a390>
o.class_method()#class_method((<
o.class_method(1,2,x=3,y=4)#class_method((<
#静态方法(staticmethod)中除了你调用时传入的参数以外,没有其他的参数。
o.static_method#<
functionstatic_methodat0x7fdd25375848>
o.static_method()#static_method((),{})
o.static_method(1,2,x=3,y=4)#static_method((1,2),{'
#@property是实现getter和setter方法的一种方式。
直接调用它们是错误的。
#“只读”属性可以通过只定义getter方法,不定义setter方法实现。
o.some_property#调用some_property的getter(<
__main__.MyClassinstanceat0x7fb2b70877e8>
(),{})#'
propertiesarenice'
#“属性”是很好的功能
o.some_property()#callingsome_propertygetter(<
(),{})#Traceback(mostrecentcalllast):
#File"
<
stdin>
line1,in<
module>
#TypeError:
str'
objectisnotcallable
o.some_other_property#callingsome_other_propertygetter(<
VERYnice'
#o.some_other_property()#callingsome_other_propertygetter(<
o.some_property="
#callingsome_propertysetter(<
__main__.MyClassobjectat0x7fb2b7077890>
('
o.some_property#callingsome_propertygetter(<
o.some_other_property="
verygroovy"
#Traceback(mostrecentcalllast):
#AttributeError:
can'
tsetattribute
(),{})
问题10
阅读下面的代码,它的输出结果是什么?
classA(object):
defgo(self):
goAgo!
defstop(self):
stopAstop!
defpause(self):
raiseException("
NotImplemented"
)
classB(A):
super(B,self).go()
goBgo!
classC(A):
super(C,self).go()
goCgo!
super(C,self).stop()
stopCstop!
classD(B,C):
super(D,self).go()
goDgo!
super(D,self).stop()
stopDstop!
waitDwait!
classE(B,C):
pass
a=A()b=B()c=C()d=D()e=E()
#说明下列代码的输出结果
a.go()b.go()c.go()d.go()e.go()
a.stop()b.stop()c.stop()d.stop()e.stop()
a.pause()b.pause()c.pause()d.pause()e.pause()
输出结果以注释的形式表示:
a.g