Python面试题（练习一）

1.Python的可变类型和不可变类型？

可变类型：list、dict（列表和字典）

不可变类型：数字、字符串、元组

2.求结果:

v = dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v)    # {'k1': [666], 'k2': [666]} 
v['k1'] = 777 
print(v) # {'k1': 777, 'k2': [666]}

3.求结果：

你将如何修改 multipliers 的定义来产生期望的结果

答案

以上代码的输出是 [6, 6, 6, 6] （而不是 [0, 2, 4, 6]）。

这个的原因是 Python 的闭包的后期绑定导致的 late binding，这意味着在闭包中的变量是在内部函数被调用的时候被查找。所以结果是，当任何 multipliers() 返回的函数被调用，在那时，i 的值是在它被调用时的周围作用域中查找，到那时，无论哪个返回的函数被调用，for 循环都已经完成了，i 最后的值是 3，因此，每个返回的函数 multiplies 的值都是 3。因此一个等于 2 的值被传递进以上代码，它们将返回一个值 6 （比如： 3 x 2）。

（顺便说下，正如在 The Hitchhiker’s Guide to Python 中指出的，这里有一点普遍的误解，是关于 lambda 表达式的一些东西。一个 lambda 表达式创建的函数不是特殊的，和使用一个普通的 def 创建的函数展示的表现是一样的。）

这里有两种方法解决这个问题。

最普遍的解决方案是创建一个闭包，通过使用默认参数立即绑定它的参数。例如：

def multipliers(): return [lambda x, i=i : i * x for i in range(4)]

4.filter、map、reduce的作用？

L1 = list(filter(lambda x:x%2==1,range(20)))
print(L1)
L2 = list(map(lambda x:x%2==1,range(20)))
print(L2)
L4 = list(map(lambda x:x*x,range(20)))
print(L4)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
[False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361

　如果用filter的话，说明匿名函数lambda给出的是个筛选条件，从1到19中筛选出奇数来，但这里如果用map的话，就好像变成了它判断对错的条件，只打印true和false。

　map一般的用法如下，参数有一个函数一个序列，将右边的序列经过左边的函数变换，生成新的序列。

   在python3中已将其从全局空间移除，现被放置在functools的模块里，用之前需要引入  from functools import reduce

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

print ("\n".join("\t".join(["%s*%s=%s" %(x,y,x*y) for y in range(1, x+1)]) for x in range(1, 10)))

6、re的match和search区别？

match与search函数的功能一样，match匹配字符串开始的第一个位置，search是在字符串全局匹配第一个符合规则的。

import re
str = "this is a str"
a = re.match('th',str)
b = re.search("is",str)
print(a)    # <_sre.SRE_Match object; span=(0, 2), match='th'>
print(b)    # <_sre.SRE_Match object; span=(2, 4), match='is'>

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

尽可能多的去匹配符合规则的字符，非贪婪模式后面加?（尽可能少的匹配）


8、求结果：


　　a. [ i % 2 for i in range(10) ]
 b. ( i % 2 for i in range(10) )


a = [i for i in range(10)]
print(a) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b = (i for i in range(10))
print(b)    # <generator object <genexpr> at 0x0212D180>

9、求结果：


　　a. 1 or 2
 　　b. 1 and 2
 　　c. 1 < (2==2)
 　　d. 1 < 2 == 2

print(1 or 2)   # 1 
print(1 and 2) # 2
print(1 < (2==2))   # False
print(1<2==2)   # True

10、def func(a,b=[]) 这种写法有什么坑？

def funx(a,b=[]):
    print(a,b)
b=[1,2] 
funx(2,b)   # 2 [1, 2]
b.append([3,4])
funx(3,b)   # 3 [1, 2, [3, 4]]

每次调用 funx 函数，b 并不是空

11、如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?

a = ['1','2','3']
b = []
for i in a:
    b.append(int(i))
print(b)

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

print(type([1,2,3][0]))     # <class 'int'>
print(type([(1),(2),(3)][0]))   # <class 'int'>
print(type([(1,),(2,),(3,)][0]))    # <class 'tuple'>

13、如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?

print(list(map(lambda x: x*x ,range(1,11))))
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

14、如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?

str = '1,2,3'
a = []
for num in str.split(','):
    a.append(int(num))
print(a)

15、一行代码实现删除列表中重复的值 ?

print(list(set([1,1,1,2,2,3,4,4,5])))
#  [1, 2, 3, 4, 5]

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

def funx():
    global a
    a += 1
    print(a)

a = 2
funx()  # 3

funx 可以访问函数外的全局变量 a

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

class Stack(object):
    def __init__(self):
        self.stack = []

    def push(self,value):   # 进栈
        self.stack.append(value)

    def pop(self):　　# 出栈
        if self.stack:
            return self.stack.pop()
        else:
            raise LookupError('stack is empty!')

    def is_empty(self): # 返回栈 是否为空
        return bool(self.stack)

    def top(self):  # 返回栈中最新元素
        if self.stack:
            return self.stack[-1]
        else:
            return 'stack is empty!'

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

'''
Python 中格式化有三种：
'''
# 需一个个的格式化
print('Hello %s' % ('Petrolero'))
# 不需要一个个的格式化，可以利用字典的方式，缩短时间
print('Hello %(name)s' % {'name':'petrolero'})
# 可读性强
print('Hello {name}'.format(name='petrolero'))