python基础⾯试题（⼀）
第⼀阶段⾯试题
⼀、Python基础
1. continue和 break有什么区别？
答案：
break和continue都是⽤来控制循环结构的。
1. break：提前终⽌循环可以使⽤break来完成。break完全结束⼀个循环，跳出循环体执⾏循环后⾯的语句。
2. continue：理解为continue是跳过当次循环中剩下的语句，执⾏下⼀次循环。
3. 区别：continue只终⽌本次循环，break则完全终⽌循环
2.Python 中的作⽤域？
答案：
Python 中，⼀个变量的作⽤域总是由在代码中被赋值的地⽅所决定的。
当 Python 遇到⼀个变量的话他会按照这样的顺序进⾏搜索：
本地作⽤域（Local）→当前作⽤域被嵌⼊的本地作⽤域（Enclosing locals）
→全局/模块作⽤域（Global）→内置作⽤域（Built-in）
3. 谈谈对闭包的理解？
答案：
闭包(closure)是函数式编程的重要的语法结构。闭包也是⼀种组织代码的结构，
它同样提⾼了代码的可重复使⽤性。
当⼀个内嵌函数引⽤其外部作作⽤域的变量，我们就会得到⼀个闭包. 总结⼀下,
创建⼀个闭包必须满⾜以下⼏点:
必须有⼀个内嵌函数
内嵌函数必须引⽤外部函数中的变量
外部函数的返回值必须是内嵌函数
感觉闭包还是有难度的,⼏句话是说不明⽩的，还是查查相关资料.
重点是函数运⾏后并不会被撤销，就像16题的instance字典⼀样，当函数运⾏完
后,instance 并不被销毁,⽽是继续留在内存空间⾥.这个功能类似类⾥的类变
量，只不过迁移到了函数上.
闭包就像个空⼼球⼀样，你知道外⾯和⾥⾯，但你不知道中间是什么样.
4. Python ⾥的拷贝？理解引⽤和 copy(),deepcopy()的区别。
答案：python 定义数组
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值，传对象的引⽤
c = py(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
a.append(5) #修改对象 a
a[4].append('c') #修改对象 a 中的['a', 'b']数组对象
print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d
输出结果：
a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c = [1, 2, 3, 4, ['a', 'b', 'c']]
d = [1, 2, 3, 4, ['a', 'b']]
5. Python 垃圾回收机制？
答案：
Python GC 主要使⽤引⽤计数（reference counting）来跟踪和回收垃圾。在引
⽤计数的基础上，通过“标记-清除”（mark and sweep）解决容器对象可能产
⽣的循环引⽤问题，通过“分代回收”（generation collection）以空间换时
间的⽅法提⾼垃圾回
6.什么是 lambda 函数？它有什么好处?
答案：
lambda 表达式，通常是在需要⼀个函数，但是⼜不想费神去命名⼀个函数
的场合下使⽤，也就是指匿名函数
lambda 函数：⾸要⽤途是指点短⼩的回调函数
lambda [arguments]:expression
>>> a=lambdax,y:x+y
>>> a(3,11)
7.请写出⼀段 Python 代码实现删除⼀个list ⾥⾯的重复元素？
答案：
1. 使⽤ set 函数，set(list)
1. 使⽤ set 函数，set(list)
2. 使⽤字典函数，
>>>a=[1,2,4,2,4,5,6,5,7,8,9,0]
>>> b={}
>>>b=b.fromkeys(a)
>>>c=list(b.keys())
>>> c
8.Python ⾥⾯如何拷贝⼀个对象？（赋值，浅拷贝，深拷贝的区别）
答案：
赋值（=），就是创建了对象的⼀个新的引⽤，修改其中任意⼀个变量都会影响到另⼀个。
浅拷贝：创建⼀个新的对象，但它包含的是对原始对象中包含项的引⽤（如果⽤
引⽤的⽅式修改其中⼀个对象，另外⼀个也会修改改变）{1，完全切⽚⽅法；2，
⼯⼚函数，如 list()；3，copy 模块的 copy()函数}
深拷贝：创建⼀个新的对象，并且递归的复制它所包含的对象（修改其中⼀个，
另外⼀个不会改变）{copy 模块的 deep.deepcopy()函数}
9.介绍⼀下 except 的⽤法和作⽤？
答案：
try…except…except…[else…][finally…]
执⾏ try 下的语句，如果引发异常，则执⾏过程会跳到 except 语句。对每个except 分⽀顺序尝试执⾏，如果引发的异常与 except 中的异常组匹配，执⾏相应的语句。
如果所有的 except 都不匹配，则异常会传递到下⼀个调⽤本代码的最⾼层 try代码中。
try 下的语句正常执⾏，则执⾏ else 块代码。如果发⽣异常，就不会执⾏
如果存在 finally 语句，最后总是会执⾏。
10.如何⽤ Python 来进⾏查询和替换⼀个⽂本字符串？
答案：
可以使⽤ re 模块中的 sub()函数或者 subn()函数来进⾏查询和替换，
格式：sub(replacement, string[,count=0])（replacement 是被替换成的⽂本，
string 是需要被替换的⽂本，count 是⼀个可选参数，指最⼤被替换的数量）
>>> import re
>>>p=repile(‘blue|white|red’)
>>>print(p.sub(‘colour’,'blue socks and red shoes’))
colour socks and colourshoes
>>>print(p.sub(‘colour’,'blue socks and red shoes’,count=1))
colour socks and redshoes
subn()⽅法执⾏的效果跟 sub()⼀样，不过它会返回⼀个⼆维数组，包括替换后
的新的字符串和总共替换的数量
11.Python ⾥⾯ match()和 search()的区别？
答案：
re 模块中 match(pattern,string[,flags])，检查 string 的开头是否与pattern 匹配。
re 模块中 re.search(pattern,string[,flags])，在 string 搜索 pattern 的第⼀个匹配值。
>>>print(re.match(‘super’, ‘superstition’).span())
(0, 5)
>>>print(re.match(‘super’, ‘insuperable’))
None
>>>print(re.search(‘super’, ‘superstition’).span())
(0, 5)
>>>print(re.search(‘super’, ‘insuperable’).span())
(2, 7)
12. Python ⾥⾯如何⽣成随机数？
答案：
random 模块
随机整数：random.randint(a,b)：返回随机整数 x,a<=x<=b
random.randrange(start,stop,[,step])：返回⼀个范围在(start,stop,step)
之间的随机整数，不包括结束值。
随机实数：random.random( )：返回 0 到 1 之间的浮点数
random.uniform(a,b)：返回指定范围内的浮点数
13. 如何在⼀个 function ⾥⾯设置⼀个全局的变量？
答案：
解决⽅法是在 function 的开始插⼊⼀个 global 声明：
def f():
global x
14. 单引号，双引号，三引号的区别?
答案：
单引号和双引号是等效的，如果要换⾏，需要符号(\)，三引号则可以直接换
⾏，并且可以包含注释
如果要表⽰ Let’s go 这个字符串
如果要表⽰ Let’s go 这个字符串
单引号：s4 = ‘Let\’s go’
双引号：s5 = “Let’s go”
s6 = ‘I realy like“python”!’
这就是单引号和双引号都可以表⽰字符串的原因
15.Python2 和 3 的区别？
答案：
print 不再是语句，⽽是函数，⽐如原来是 print 'abc' 现在是 print('abc')
但是 python2.6+ 可以使⽤ from __future__ import print_function 来实现相同功能
在 Python 3 中，没有旧式类，只有新式类，也就是说不⽤再像这样 class
Foobar(object): pass 显式地⼦类化 object
但是最好还是加上. 主要区别在于 old-style 是 classtype 类型⽽ new-style 是type 类型
原来 1/2（两个整数相除）结果是 0，现在是 0.5 了
python 2.2+ 以上都可以使⽤ from __future__ import division 实现改特性, 同时注
意 // 取代了之前的 / 运算
新的字符串格式化⽅法 format 取代%
错误, 从 python2.6+ 开始已经在 str 和 unicode 中有该⽅法, 同时 python3 依然⽀持 % 算符
xrange 重命名为 range
同时更改的还有⼀系列内置函数及⽅法, 都返回迭代器对象, ⽽不是列表或者
元组, ⽐如 filter, map, dict.items 等
!=取代 < >
python2 也很少有⼈⽤ < > 所以不算什么修改
long 重命名为 int
不完全对, python3 彻底废弃了 long+int 双整数实现的⽅法, 统⼀为 int , ⽀持⾼精度整数运算.
except Exception, e 变成 except (Exception) as e
只有 python2.5 及以下版本不⽀持该语法. python2.6 是⽀持的. 不算新东西
exec 变成函数
类似 print() 的变化, 之前是语句.
16.下⾯代码会输出什么：
def f(x,l=[]):
for i in range(x):
l.append(i*i)
print l
f(2)
f(3,[3,2,1])
f(3)
答案：
[0, 1]
[3, 2, 1, 0, 1, 4]
[0, 1, 0, 1, 4]
17.这两个参数是什么意思：*args，**kwargs？我们为什么要使⽤它们？
答案：
如果我们不确定要往函数中传⼊多少个参数，或者我们想往函数中以列表和元组
的形式传参数时，那就使要⽤*args；
如果我们不知道要往函数中传⼊多少个关键词参数，或者想传⼊字典的值作为关
键词参数时，那就要使⽤**kwargs。
args和kwargs这两个标识符是约定俗成的⽤法，你当然还可以⽤*bob和**billy，
但是这样就并不太妥。
下⾯是具体的⽰例：
def f(*args,**kwargs): print args, kwargs
l = [1,2,3]
t = (4,5,6)
d = {'a':7,'b':8,'c':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) # () {'a': 1, 'c': 3, 'b': 2}
f(a=1,b=2,c=3,zzz="hi") # () {'a': 1, 'c': 3, 'b': 2, 'zzz': 'hi'}
f(a=1,b=2,c=3,zzz="hi") # () {'a': 1, 'c': 3, 'b': 2, 'zzz': 'hi'}
f(1,2,3,a=1,b=2,c=3) # (1, 2, 3) {'a': 1, 'c': 3, 'b': 2}
f(*l,**d) # (1, 2, 3) {'a': 7, 'c': 9, 'b': 8}
f(*t,**d) # (4, 5, 6) {'a': 7, 'c': 9, 'b': 8}
f(1,2,*t) # (1, 2, 4, 5, 6) {}
f(q="winning",**d) # () {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
f(1,2,*t,q="winning",**d) # (1, 2, 4, 5, 6) {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
def f2(arg1,arg2,*args,**kwargs): print arg1,arg2, args, kwargs
f2(1,2,3) # 1 2 (3,) {}
f2(1,2,3,"groovy") # 1 2 (3, 'groovy') {}
f2(arg1=1,arg2=2,c=3) # 1 2 () {'c': 3}
f2(arg1=1,arg2=2,c=3,zzz="hi") # 1 2 () {'c': 3, 'zzz': 'hi'}
f2(1,2,3,a=1,b=2,c=3) # 1 2 (3,) {'a': 1, 'c': 3, 'b': 2}
f2(*l,**d) # 1 2 (3,) {'a': 7, 'c': 9, 'b': 8}
f2(*t,**d) # 4 5 (6,) {'a': 7, 'c': 9, 'b': 8}
f2(1,2,*t) # 1 2 (4, 5, 6) {}
f2(1,1,q="winning",**d) # 1 1 () {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
f2(1,2,*t,q="winning",**d) # 1 2 (4, 5, 6) {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
19.简要描述 Python 的垃圾回收机制（garbage collection）。
答案：
Python 在内存中存储了每个对象的引⽤计数（reference count）。如果计数值变成 0，那么相应的对象就会⼩时，分配给该对象的内存就会释放出来⽤作他⽤。偶尔也会出现引⽤循环（reference cycle）。垃圾回收器会定时寻这个循环，并将其回收。举个例⼦，假设有两个对象 o1 和 o2，⽽且符合 o1.x =
= o2 和o2.x == o1 这两个条件。如果 o1 和 o2 没有其他代码引⽤，那么它们就不应该继续存在。但它们的引⽤计数都是 1。
Python 中使⽤了某些启发式算法（heuristics）来加速垃圾回收。例如，越晚创建的对象更有可能被回收。对象被创建之后，垃圾回收器会分配它们所属的代（generation）。每个对象都会被分配⼀个代，⽽被分配更年轻代的对象是优先被处理的
20.简述函数式编程
答案：
在函数式编程中，函数是基本单位，变量只是⼀个名称，⽽不是⼀个存储单元。
除了匿名函数外，Python 还使⽤ fliter(),map(),reduce(),apply()函数来⽀持函数式编程。
21.什么是匿名函数，匿名函数有什么局限性？
答案：
匿名函数，也就是 lambda 函数，通常⽤在函数体⽐较简单的函数上。匿名函数
顾名思义就是函数没有名字，因此不⽤担⼼函数名冲突。不过 Python 对匿名函
数的⽀持有限，只有⼀些简单的情况下可以使⽤匿名函数。
22.如何捕获异常，常⽤的异常机制有哪些？
答案：
如果我们没有对异常进⾏任何预防，那么在程序执⾏的过程中发⽣异常，就会中断程序，调⽤ python 默认的异常处理器，并在终端输出异常信息。pt. ..finally 语句：当 try 语句执⾏时发⽣异常，回到 try 语句层，寻后⾯是否有 except 语句。到 except 语句后，会调⽤这个⾃定义的异常处理器。except 将异常处理完毕后，程序继续往下执⾏。finally 语句表⽰，⽆论异常发⽣与否，finally 中的语句都要执⾏。
assert 语句：判断 assert 后⾯紧跟的语句是 True 还是 False，如果是 True 则继续执⾏ print，如果是 False 则中断程序，调⽤默认的异常处理器，同时输出a ssert 语句逗号后⾯的提⽰信息。
with 语句：如果 with 语句或语句块中发⽣异常，会调⽤默认的异常处理器处理，但⽂件还是会正常关闭。
23.去除列表中的重复元素？
答案：
#⽤集合
list(set(l))
#⽤字典
l1 = ['b','c','d','b','c','a','a']
l2 = {}.fromkeys(l1).keys()
print l2
1
2
3
l1 = ['b','c','d','b','c','a','a']
l2 = {}.fromkeys(l1).keys()
print l2
#⽤字典并保持顺序
l1 = ['b','c','d','b','c','a','a']
l2 = list(set(l1))
l2.sort(key=l1.index)
print l2
#列表推导式
l1 = ['b','c','d','b','c','a','a']
l2 = []
[l2.append(i) for i in l1 if not i in l2]
24.变态台阶问题
24.变态台阶问题
⼀只青蛙⼀次可以跳上 1 级台阶，也可以跳上 2 级……它也可以跳上 n 级。求该青蛙跳上⼀个 n 级的台阶总共有多少种跳法
答案：
第⼀种⽅法：台阶问题/斐波纳挈
fib = lambda n: n if n <= 2 else fib(n - 1) + fib(n - 2)
第⼆种记忆⽅法
def memo(func):
cache = {}
def wrap(*args):
if args not in cache:
cache[args] = func(*args)
return cache[args]
return wrap
@ memo
def fib(i):
if i < 2:
return 1
return fib(i-1) + fib(i-2)
第三种⽅法
def fib(n):
a, b = 0, 1
for _ in xrange(n):
a, b = b, a + b
return b
25.Python中list和tuples的差别是什么？
答案：
列表⾥的内容是可以改变的，增删改都可以，tuple则不⾏；
python中字典的key必须是可哈希的，不可变的所以tuple可以作为字典的键，⽽list不⾏；
对于使⽤场景tuple适合⼀些只读的数据，如python链接mysql得到的结果就是⽤tuple，⽽list则在列表长度不固定或者需要有变动的数据中使⽤tuple的性能⽐list 好⼀些，tuple⽐list更省内存
26.代码举例什么是decorator。
答案：
decorator是⼀个装饰器函数，作⽤是⽤来包装另⼀个函数。
装饰器函数出⼊的是⼀个函数返回的也是⼀个函数。
def fn(fc):
def f():
print('<a>'+fc()+'</a>')
return f
@fn
def f2():
return '我是⼀个超链接'
f2()  #<a>我是⼀个超链接</a>
27.单引号，双引号，三引号的区别
答案：
单引号和双引号是等效的，如果要换⾏，需要符号(\)，三引号则可以直接换⾏，并且可以包含注释
如果要表⽰Let’s go 这个字符串
单引号：s4 = ‘Let\’s go’
双引号：s5 = “Let’s go”
s6 = ‘I realylike“python”!’
这就是单引号和双引号都可以表⽰字符串的原因了
28.请⽤⾃⼰的算法，按升序合并如下两个List , 并去除重复的元素
List1 = [2,3,8,4,9,5,6]
List2 = [5,6,10,17,11,2]
答案：
29.有⼀个多层嵌套的列表 A = [1,2,[3,4,[‘434’,[…]]]]，请写⼀段代码遍历A中的美个元素并打印出来.
答案：
30.⽤⾃⼰的话说明迭代器和⽣成器，它们之间的关系？
答案：
迭代器：指的是⼀个重复的过程，每⼀次重复称为⼀次迭代，并且每⼀次重复的结果是下⼀次重复的初始值
⽣成器：只要在函数体内出现yield关键字，那么再执⾏函数就不会执⾏函数代码，会得到⼀个结果，该结果就是⽣成器
31.Python是如何进⾏内存管理的?
答案：
python内部使⽤引⽤计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引⽤，即引⽤计数，当对象被创建时就创建了⼀个引⽤计数，当对象不

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。