Python面试笔试题Word文件下载.docx
《Python面试笔试题Word文件下载.docx》由会员分享，可在线阅读，更多相关《Python面试笔试题Word文件下载.docx（17页珍藏版）》请在冰豆网上搜索。
class
是否是类型参数
classinfo
的子类
issubclass（class,
classinfo）
参数
--
类。
返回值
如果
是
的子类返回
True，否则返回
False。
而在题目中b并不是一个类,所以报错。
我们先理清楚静态函数、类函数分别是什么？
静态方法是一种普通函数，就位于类定义的命名空间中，它不会对任何实例类型进行操作。
使用装饰器@staticmethod定义静态方法。
类对象和实例都可以调用静态方法。
类方法是将类本身作为对象进行操作的方法。
类方法使用@classmethod装饰器定义，其第一个参数是类，约定写为cls。
缺省参数是指在调用函数的时候没有传入参数的情况下，调用默认的参数，在调用函数的同时赋值时，所传入的参数会替代默认参数。
*args是不定长参数，可以表示输入参数是不确定的，可以任意多个
**kwargs是关键词参数，赋值的时候是以键=值的方式，参数是可以任意多对。
以上两个的使用是在定义函数的时候不确定会传入多少参数时使用。
什么是鸭子类型？
当看到一只鸟，走起来像鸭子、游泳起来像鸭子、叫起来像鸭子那么这只鸟就可以被称之为鸭子
∙关注点在对象的行为，而不是类型（ducktyping）
∙比如file,StringIO,socket对象都支持read/write方法（filelikeobject）
∙比如定义了
_iter_
魔术方法的对象可以使用for
鸭子类型更关注接口而非类型。
什么是monkeypatch？
那些地方用到了？
自己如何实现？
∙所谓猴子补丁就是运行时替换
∙gevent库需要修改内置的socket
fromgeventimportmonkey;
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]<
b=['
a'
'
b'
c'
]<
d={k:
vfork,vinzip（b,a）}<
print（d）<
∙返回生成器:
（iforiinrange（10）ifi%2==0）
Python2/3的差异点
∙print成为函数
∙编码问题,Python3不再有Unicode对象,默认str就是Unicode
Unicode（给人看的）
->
encode
字节串（给计算机看的）
传输的时候使用字节串,操作的时候使用Unicode
∙Python3除法返回浮点数
∙类型注解
hello（name:
str）
str:
'
hello'
+
name
∙优化的super（）方便调用父类函数
∙高级解包操作:
a,b,*res=range（10）
∙限定关键词参数
∙Python3重新抛出异常不会丢失栈信息（raisefrom）
∙一切返回迭代器:
range,zip,map,dict.values
∙yieldform链接子生成器
∙asyncio内置库,asyn/await原生协程支持异步编程
兼容Python2/3的工具
∙six模块
∙2to3等工具转换代码
∙_future_
函数-以下代码分别输出什么?
Python如何传参？
#
代码1
flist（l）:
l.append（0）
print（l）
l
[]
flist（l）
代码2
fstr（s）:
s
+=
print（s）
hehe'
flist（s）
∙Python唯一支持的参数传递是共享传参,函数形参获得实参中各个引用的副本。
∙Python可变/不可变:
不可变对象->
bool/int/float/tuple/str/frozenset
可变对象->
list/dict/set
测试例子1
clear_list（l）:
ll
[1,2,3]
clear_list（ll）
print（ll）
默认参数只计算一次。
测试例子2
flist（l=[1]）:
l.append
（1）
flist（）
[1,
1]
1,
函数-Python*args**kwargs都是什么？
∙用来处理可变参数
∙args被打包成tuple
∙kwargs被打包成dict
Python异常机制-什么是Python异常？
Python使用异常处理错误（有些语言使用错误码）
∙BaseException
∙SystemExit/KeyboardInterrupt/GeneratorExit
∙Exception
Python异常机制-什么时候需要捕获异常
∙网络请求（超时、连接错误等）
∙资源访问（权限问题,资源不存在）
∙代码逻辑（越界访问,keyerror）
Python异常机制-如何处理异常?
try:
fun
-
可能会抛出异常的代码
except
（Exception1,
Exception2）
as
e:
可以捕获多个异常并处理
异常处理代码
else:
pass
异常没有发生时候的代码逻辑
finally:
无论异常有没有发生都会执行的代码，一般处理资源的关闭和释放
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（）
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
printid（test1）,id（test2）
#方法二:
使用装饰器,建立过实例的就放到instances里面,下次建立的时候先检查里面有没有
defSingleTon（cls,*args,**kwargs）:
instances={}
printinstances
def_singleton（）:
ifclsnotininstances:
instances[cls]=cls（*args,**kwargs）
returninstances[cls]
return_singleton
@SingleTon
classLastClass（object）:
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）
classTestClass（object）:
__metaclass__=SignalTon
test1.a=2
#方法四:
共享属性
所谓单例就是所有的引用（实例，对象）拥有相同的属性和方法，同一个类的实例天生都会有相同的方法，那我们只需要保证同一个类所产生的实例都具有相同的属性。
所有实例共享属性最简单直接的方法就是共享__dict__属性指向。
_state={}
def__new__（cls,*args,**kwargs）:
obj=object.__new__（cls,*args,**kwargs）
obj.__dict__=cls._state
returnobj
#方法五:
使用同一个模版
#写在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:
]
str="
H
"
printstr
printleftStrip（str,'
'
printrightStrip（str,'
#输出
H
5.super的原理
#阅读下面的代码，它的输出结果是什么？
classA（object）:
def__init__（self）:
print"
enterA"
super（A,self）.__init__（）
#new
leaveA"
classB（object）:
enterB"
super（B,self）.__init__（）
leaveB"
classC（A）:
enterC"
super（C,self）.__init__（）
leaveC"
classD（A）:
enterD"
super（D,self）.__init__（）
leaveD"
classE（B,C）:
enterE"
super（E,self）.__init__（）
#change
leaveE"
classF（E,D）:
enterF"
super（F,self）.__init__（）
leaveF"
enterF
enterE
enterB
enterC
enterD
enterA
leaveA
leaveD
leaveC
leaveB
leaveE
leaveF
6.闭包
常用的装饰器就是闭包的一种
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},{"
b"
30},{"
c"
25}]
alist.sort（key=lambda:
x:
-x.get（"
））
printalist
8.合并两个列表排除重复元素
用简洁的方法合并alist=[‘a’,’b’,’c’,’d’,’e’,’f’]
blist=[‘x’,’y’,’z’,’e’,’f’]并且元素不能重复
alist=['
d'
e'
f'
blist=['
x'
y'
z'
defmerge_list（*args）:
s=set（）
foriinargs:
s=s.union（i）
returns
merge_list（alist,blist）
9.打乱一个排好序的列表
fromrandomimportshuffle
alist=range（10）
print（alist）
shuffle（alist）
10.简单的实现一个栈结构stack
classStack（object）:
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（）
11.输入一个日期,返回时一年中的哪一天
fromda
升级会员 