【直通BAT面试试题库集锦】函数面试题

函数的运用是最为常见的，如果面试的时候基础不扎实很容易出错，那么下面跟着上海老男孩IT教育【直通BAT面试试题库集锦】函数面试题。

函数面试题
enumerate 的作用是什么?

# 答案
'''
enumerate函数是将一个可迭代对象中元素，按元素顺序每个增加一个索引值，将其组成一个索引序列，利用它可以同时获得索引和值，这样做的目的是为了将一个可迭代对象中元素组成一个“索引,值”对便于后续操作。
'''
lambda 表达式格式以及应用场景?

# 答案

# 匿名就是没有名字
def func(x,y,z=1): return x+y+z
# 匿名
lambda x,y,z=1:x+y+z # 与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字 func=lambda x,y,z=1:x+y+z

func(1,2,3)
# 让其有名字就没有意义,与内置函数配合一起使用
Python 递归的最大层数?

# 答案
'''
 最大数为998
'''

列表推导式和生成器表达式 [i % 2 for i in range(10)] 和 (i % 2 for i inrange(10)) 输出结果分别是什么?

print([i % 2 for i in range(10)])
print((i % 2 for i in range(10)))
列举常见的内置函数?

# 答案
'''
数学类型
abs(a) : 求取绝对值。abs(-1)
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3])
sum(list) : 求取list元素的和。sum([1,2,3]) >>> 6
sorted(list) : 排序，返回排序后的list。
len(list) : list长度,len([1,2,3])
divmod(a,b): 获取商和余数。divmod(5,2) >>> (2,1)
pow(a,b) : 获取乘方数。pow(2,3) >>> 8
round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14
range(a[,b]) : 生成一个a到b的数组,左闭右开。range(1,10) >>> [1,2,3,4,5,6,7,8,9]

类型转换
int(str) : 转换为int型。int('1') >>> 1
float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
str(int) : 转换为字符型。str(1) >>> '1'
bool(int) : 转换为布尔类型。str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬虫', 'utf-8') >>> b'\xe7\x88\xac\xe8\x99\xab'
list(iterable) : 转换为list。list((1,2,3)) >>> [1,2,3]
iter(iterable)：返回一个可迭代的对象。iter([1,2,3]) >>>
dict(iterable) : 转换为dict。dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一个枚举对象。
tuple(iterable) : 转换为tuple。tuple([1,2,3]) >>>(1,2,3)
set(iterable) : 转换为set。set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
hex(int) : 转换为16进制。hex(1024) >>> '0x400'
oct(int) : 转换为8进制。oct(1024) >>> '0o2000'
bin(int) : 转换为2进制。bin(1024) >>> '0b10000000000'
chr(int) : 转换数字为相应ASCI码字符。chr(65) >>> 'A'
ord(str) : 转换ASCI字符
为相应的数字。ord('A') >>> 65

相关操作
eval() : 执行一个表达式，或字符串作为运算。eval('1+1') >>> 2
exec() : 执行python语句。exec('print("Python")') >>> Python
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。filter(lambda x: x>3, [1,2,3,4,5,6]) >>>
map(func, *iterable) : 将func用于每个iterable对象。map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
zip(*iterable) : 将iterable分组合并。返回一个zip对象。list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
type()：返回一个对象的类型。
id()：返回一个对象的唯一标识值。
hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。hash('python') >>> 7070808359261009780
help()：调用系统内置的帮助系统。
isinstance()：判断一个对象是否为该类的一个实例。
issubclass()：判断一个类是否为另一个类的子类。
globals() : 返回当前全局变量的字典。
next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(sequence) ：生成一个反转序列的迭代器。reversed('abc') >>> ['c','b','a']
'''
filter、map、reduce 的作用?

# 答案
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 
filter(lambda x: x>3, [1,2,3,4,5,6]) 
>>>

map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, 
map(lambda a,b: a+b, [1,2,3,4], [5,6,7])
>>> [6,8,10]
                       
reduce(): 函数会对参数序列中元素进行累积。
reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数                                                
>>> 15
一行代码实现 9*9 乘法表

# 答案
'''
print('\n'.join(['\t'.join(["%2s*%2s=%2s"%(j,i,i*j) for j in range(1,i+1)]) for i in range(1,10)]))
'''
什么是闭包?

闭包函数（closure function）指的是定义在一个函数内部的函数，被外层函数包裹着，其特点是可以访问到外层函数中的名字，如下inner函数就是一个闭包函数。

def outer():
    num = 1
    def inner():
        print(num) # 内层函数中不存在num 但可以访问到外层的num
    return inner # 基于函数对象的概念我们可以将内层函数返回到外界使用，从而打破函数调用的层级限制，但无论在何处调用，作用域的嵌套关系都是以定义阶段为准的，所以外界得到的不仅仅是一个函数对象（inner），在该函数外还包裹了一层作用域，这使得该函数无论在何处调用，都是访问自己外层包裹的作用域中的名字num

func = outer() # func == inner  func指向的是inner的内存地址，但是func本身确实一个全局变量，可以在任意位置调用func，但无论在何处调用func，都需要按照定义阶段作用域的嵌套关系去查找名字

num=1000
func() #输出结果：1
使用生成器编写 fib 函数, 函数声明为 fib(max), 输入一个参数 max 值, 使得 该函数可以这样调用。

for i in range(0,100):
 print fib(1000)

# 并产生如下结果(斐波那契数列),1,1,2,3,5,8,13,21...

# 答案
def fib():
    i,k=1,0
    while 1:
        j=i+k
        yield j
        i=k
        k=j
for fn in fib():
    if fn>1000:
        break
    else:
        print(fn)
一行代码, 通过 filter 和 lambda 函数输出以下列表索引为基数对应的元素。

list_a=[12,213,22,2,2,2,22,2,2,32]

# 答案
l = filter(lambda x:x in list_a,[i for i in range(len(list_a))])
print(list(l))
写一个base62encode函数,62进制。

# 即:0123456789AB..Zab..z(10 个数字+26 个大写字母+26 个小写字母)。

# 答案
def base62Encode(n):
    s = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
    lst = []
    while n > 0:
        lst.append(n % 62) # 58
        n = n // 62

    lst = lst[::-1]
    result = ""
    for item in lst: # 58
        result += s[item]

    return result
  
print(base62Encode(58))

# 结果
w
请实现一个装饰器,限制该函数被调用的频率,如10秒一次

# 答案
import time
def time_pay(func):

    def inner(*args, **kwargs):
        for line in range(10):
            print(line + 1)
            time.sleep(1)

        res = func(*args, **kwargs)

        return res

    return inner

@time_pay
def func1():
    print('from func1...')
    
func1()
请实现一个装饰器,通过一次调用使函数重复执行5次。

# 答案
def again_func(func):

    def inner(*args, **kwargs):

        for line in range(5):

            func(*args, **kwargs)

    return inner

@again_func
def func1():
    print('from func1...')

func1()
python 一行 print 出 1~100 偶数的列表, (列表推导式, filter 均可)

# 答案
print([i for i in range(1, 101) if i % 2 == 0])

print(list(filter(lambda x: x % 2 == 0, range(1, 101))))
解释生成器与函数的不同,并实现和简单使用generator

# 答案
'''
生成器和函数的主要区别在于函数return avalue，生成器yield  a  value，同时标记或记忆point of the yield 以便在下次调用时从标记点恢复执行，yield使用函数转换成生成器，而生成器反过来有返回迭代器。
'''
*arg 和**kwarg 作用?

*args用来接收溢出的位置参数，将接收的参数组织成元祖 
**kwargs用来接收溢出的关键字参数，将接受的参数组织成字典
请写出打印结果:

# 例 1
def func(a,b=[]):
    b.append(a)
    print(b)
func(1)
func(1)
func(1)
func(1)

# 例 2
def func(a,b={}):
    b[a] = 'v'
    print(b)
    
func(1)
func(2)

# 答案:
'''
例1:
[1]
[1, 1]
[1, 1, 1]
[1, 1, 1, 1]

例2:
{1: 'v'}
{1: 'v', 2: 'v'}

'''
简述yield和yieldfrom关键字。

# 答案:
'''
yield:
 当一个函数中出现yield关键字的时候，那么这个函数就是一个生成器。可以用for循环或者next()函数来迭代。

yield from:
 简单地说，yield from  generator 。实际上就是返回另外一个生成器
''
以下代码输出结果为:

# 调用上下文如下
collapse = True
processFunc = collapse and (lambda s:" ".join(s.split())) or (lambda s:s)
print(processFunc("i\tam\ntest\tobject !"))

collapse = False
processFunc = collapse and (lambda s:" ".join(s.split())) or (lambda s:s)
print(processFunc("i\tam\ntest\tobject !"))
# 以上代码会在控制台输出什么?

# 答案：
'''
i am test object !
i am
test object !
'''
请给出下面代码的输出结果

a = 1
def fun(a):
    a=2

fun(a)
print(a)

a = []
def fun(a):
    a.append(1)
fun(a)
print(a)

# 答案
1
[1]

什么是lambda函数,下面这段代码的输出是什么

nums = range(2,20)
for i in nums:
    nums = filter(lambda x:x==i or x % i, nums)
print(list(nums))

# 答案:
'''
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
'''
指出下面程序存在的问题

def Lastllindextem(src, index):
    '''请返回传入 src 使用空格或者"\"切分后的倒数第 index 个子串'''
    return src.split('\')[-index]

# 答案
\会是转义符的，会有问题，需要\\
有一个列表[3,4,1,2,5,6,6,5,4,3,3]请写一个函数,找出该列表中没有重复的数的总和。

def func(l):
    res = []
    sum_s = 0
    for i in l:
        if i not in res:
            res.append(i)
            sum_s += i

    return sum_s

list1 = [3, 4, 1, 2, 5, 6, 6, 5, 4, 3, 3]

print(func(list1))  # 21
求打印结果

arr = [1,2,3]
def bar():
  arr+=[5]

  bar()
print(arr)
'''
A.  error
B.  [5]
C. [1,2,3]
D. [1,2,3,5]
'''
# 答案
A
请给出下面代码片段的输出

def say_hi(func):
    def wrapper(*args, **kwargs):
        print("HI")
        ret = func(*args, **kwargs)
        print("BYE")
        return re
    return wrapper

def say_yo(func):
    def wrapper(*args, **kwargs):
        print("YO")
        return func(*args, **kwargs)
    return wrapper

@say_hi
@say_yo
def func():
    print("ROCK & ROLL")
func()

# 答案
'''
HI
YO
ROCK & ROLL
BYE
'''
map(str,[1,2,3,4,5,6,7,8,9]) 输出是什么?

print(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))  #

# 答案
'''
Python装饰器（decorator）在实现的时候，有一些细节需要被注意。例如，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变）。这样有时候会对程序造成一些不便，例如笔者想对flask框架中的一些函数添加自定义的decorator，添加后由于函数名和函数的doc发生了改变，对测试结果有一些影响。

所以，Python的functools包中提供了一个叫wraps的decorator来消除这样的副作用。写一个decorator的时候，最好在实现之前加上functools的wrap，它能保留原有函数的名称和docstring。
'''
请给出下面代码片段的输出

def test():
  try:
   raise ValueError("something wrong")
  except ValueError as e:
    print("Error occurred")
    return
  finally:
    print("Done")
    
test()

# 答案
Error occurred
Done
下面的函数,哪些会输出1,2,3三个数字

def func1():
    for i in range(3):
        print(i)
        a_list = [0, 1, 2]

    for i in a_list:
        print(i + 1)

def func2():
    i = 1

    while i < 3:
        print(i)

        i += 1

def func3():
    for i in range(3):
        print(i + 1)

# 答案
func3()
以下函数需要在其中引用一个全局变量k,请填写语句

def fun():
   ________
  k=k+1
  
# 答案:
global k
请把以下函数转化为python lambda匿名函数

def add(x,y):
  return x+y

# 答案
print(lambda x, y: x + y)
阅读以下代码,并写出程序的输出结果

my_dict = {"a":0,"b":1} 2.
def func(d): 
  d["a"]=1 
  return d
  
func(my_dict) 
my_dict["c"]=2 
print(my_dict)

# 答案
{'a': 1, 'b': 1, 'c': 2}
填空题

 # 有函数定义如下
def calc(a,b,c,d=1,e=2):
  return (a+b)*(c-d)+e

# 请分别写出以下标号代码的输出结果, 如果出错请写出 Error
print(calc(1,2,3,4,5)) # ____2
print(calc(1,2,3)) # ____8
print(calc(1,2)) # ____报错 missing 1 required positional argument: 'c'
print(calc(1,2,3,e=4)) # ____10
print(calc(e=4, c=5, a=2,b=3)) # ____24 
print(calc(1,2,3, d=5, 4)) # ____SyntaxError
下列函数的输出结果

def add_end(l=[]):
    l.append("end")
    return l

print(add_end())  # 输出什么
print(add_end())  # 再次调用输出什么? 为什么

# 答案
'''
['end']
['end', 'end']  # 函数在定义阶段参数l就指向了[]的内存地址
'''
可变参数定义*args,**kwargs的区别是什么？并且写出下边代码的输入内容

def foo(*args, **kwargs):
    print("args=", args)
    print("kwargs=", kwargs)
    print("-----------------")

if __name__ == '__main__':
    foo(1, 2, 3, 4)
    foo(a=1, b=2, c=3)
    foo(1, 2, 3, 4, a=1, b=2, c=3)
    foo("a", 1, None, a=1, b='2', c=3)
    
# 答案:
'''
args= (1, 2, 3, 4)
kwargs= {}
-----------------
args= ()
kwargs= {'a': 1, 'b': 2, 'c': 3}
-----------------
args= (1, 2, 3, 4)
kwargs= {'a': 1, 'b': 2, 'c': 3}
-----------------
args= ('a', 1, None)
kwargs= {'a': 1, 'b': '2', 'c': 3}
'''
请写出log实现(主要功能时打印函数名)

@log
def now():
  print("2019-07-25")
  
now()

# 输出
'''
call now()
2019-07-25
'''
Python 如何定义一个函数

A. class ( arg1, arg2, ...) 
B. function (arg1,arg2,...)
C. def (arg1, arg2,...)
D. def ( arg1, arg2...)

# 答案:
C
选择代码运行结果

country_counter = {}
def addone(country):
  if country in country_counter:
    country_counter[country] += 1
  else:
    country_counter[country] = 1
    
addone("Japan")
addone("china")
print len(country_counter)

'''
A.  0
B.  1
C.  2
D.  3
E.  4
'''

# 答案
C
选择输出结果

def doff(arg1, *args):
  print(type(args))
  
doff("applea", "bananas", "cherry")

A.str
B.int
C.tuple
D.list
E.dict

# 答案:
C
下面程序的输出结果是

d = lambda p:p*2 
t = lambda p:p*3

x = 2
x = d(x)
x = t(x)
x = d(x)
print(x)

# 答案
24
以下代码输出是什么,请给出答案并解释

def multipliers():
  return [lambda x:x*i for i in range(4)] 
  
print([m(2) for m in multipliers()])

# 答案:
 [6，6，6，6]
 闭包函数延迟绑定问题。
# 请修改 multipliers 的定义来产生期望的结果
def multipliers():
  return [lambda x, i=i:x*i for i in range(4)] 
print([m(2) for m in multipliers()])
写函数

'''
有一个数据结构如下所示，请编写⼀个函数从该结构数据中返回由指定的字段和对应的值组成的字典。如果指定字段不存在，则跳过该字段。
'''
data:{
    "time":"2016-08-05T13:13:05",
    "some_id":"ID1234",
    "grp1":{"fld1":1, "fld2":2,},
    "xxx2":{"fld3":0, "fld4":0.4,},
  "fld6":11,
  "fld7": 7,
  "fld46":8
}

# fields:由"|"连接的以 fld 开头的字符串, 如 fld2|fld7|fld29

# 答案一:
def select(data, fields):
    result = {}
    field_lst = fields.split('|')
    for key in data:
        if key in field_lst:
            result[key] = data[key]
        elif type(data[key]) == dict:
            res = select(data[key], fields)
            result.update(res)
    return result

data = {"time": "2016-08-05T13:13:05",
        "some_id": "ID1234",
        "grp1": {"fld1": 1, "fld2": 2},
        "xxx2": {"fld3": 0, "fld5": 0.4},
        "fld6": 11,
        "fld7": 7,
        "fld46": 8}
fields = 'fld2|fld3|fld7|fld19'
print(select(data, fields))

# 答案二:
def select(data,fields,result = {}):
    field_lst = fields.split('|')
    for key in data:
        if key in field_lst:
            result[key] = data[key]
        elif type(data[key]) == dict:
            select(data[key], fields)
    return result
data={"time":"2016-08-05T13:13:05",
    "some_id":"ID1234",
    "grp1":{ "fld1":1,"fld2":2},
    "xxx2":{ "fld3":0,"fld5":0.4},
    "fld6":11,
    "fld7":7,
    "fld46":8}
fields = 'fld2|fld3|fld7|fld19'
select(data,fields)
print(select(data,fields))
谈谈你对闭包的理解？

闭包(closure)是函数式编程的重要的语法结构。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。 当一个内嵌函数引用其外部作作用域的变量,我们就会得到一个闭包. 总结一下,创建一个闭包必须满足以下几点:

必须有一个内嵌函数

内嵌函数必须引用外部函数中的变量

外部函数的返回值必须是内嵌函数

Python函数调用的时候参数的传递方式是值传递还是引用传递？

Python的参数传递有：位置参数、默认参数、可变参数、关键字参数。
函数的传值到底是值传递还是引用传递，要分情况：
不可变参数用值传递：

像整数和字符串这样的不可变对象，是通过拷贝进行传递的，因为你无论如何都不可能在原处改变
不可变对象

可变参数是引用传递的：
比如像列表，字典这样的对象是通过引用传递、和C语言里面的用指针传递数组很相似，可变对象
能在函数内部改变。
对缺省参数的理解 ？

缺省参数指在调用函数的时候没有传入参数的情况下，调用默认的参数，在调用函数的同时赋值时， 所传入的参数会替代默认参数。 *args 是不定长参数，他可以表示输入参数是不确定的，可以是任意多个。 **kwargs 是关键字参数，赋值的时候是以键 = 值的方式，参数是可以任意多对在定义函数的时候 不确定会有多少参数会传入时，就可以使用两个参数。

为什么函数名字可以当做参数用?

Python中一切皆对象，函数名是函数在内存中的空间，也是一个对象。

Python中pass语句的作用是什么？

在编写代码时只写框架思路，具体实现还未编写就可以用 pass 进行占位，使程序不报错，不会进 行任何操作。

有这样一段代码，print c会输出什么，为什么？

a = 10
b = 20
c = [a]
a = 15
答：10对于字符串、数字，传递是相应的值。
map函数和reduce函数？

①从参数方面来讲： map()包含两个参数，第一个参数是一个函数，第二个是序列（列表 或元组）。其中，函数（即 map 的第一个参数位置的函数）可以接收一个或多个参数。 reduce()第一个参数是函数，第二个是序列（列表或元组）。但是，其函数必须接收两个参数。 ②从对传进去的数值作用来讲： map()是将传入的函数依次作用到序列的每个元素，每个元素都是独自被函数“作用”一次 。 reduce()是将传人的函数作用在序列的第一个元素得到结果后，把这个结果继续与下一个元素作用 （累积计算）。

递归函数停止的条件？

递归的终止条件一般定义在递归函数内部，在递归调用前要做一个条件判断，根据判断的结果选择
是继续调用自身，还是 return;返回终止递归。
终止的条件：
1.判断递归的次数是否达到某一限定值
2.判断运算的结果是否达到某个范围等，根据设计的目的来选择
回调函数，如何通信的?

回调函数是把函数的地址作为参数传递给另一个函数，将整个函数当作一个对象，赋值给调用的函
数。
Python主要的内置数据类型都有哪些？print dir( ‘a ’) 的输出？

内建类型：布尔类型、数字、字符串、列表、元组、字典、集合；
输出字符串‘a’的内建方法；
print(list(map(lambda x: x * x, [y for y in range(3)])))的输出？

1. [0， 1， 4]
hasattr() getattr() setattr() 函数使用详解？

hasattr(object, name)函数：

判断一个对象里面是否有name属性或者name方法，返回bool值，有name属性(方法)返回True， 否则返回False。 注意：name要使用引号括起来。

1. class function_demo(object):
2.     name = 'demo'
3.     def run(self):
4.         return "hello function"
5. functiondemo = function_demo()
6. res = hasattr(functiondemo, 'name')  #判断对象是否有name 属性，True
7. res = hasattr(functiondemo, "run") #判断对象是否有run方法，True
8. res = hasattr(functiondemo, "age") #判断对象是否有age属性，Falsw
9. print(res)
getattr(object, name[,default]) 函数：

获取对象object的属性或者方法，如果存在则打印出来，如果不存在，打印默认值，默认值可选。 注意：如果返回的是对象的方法，则打印结果是：方法的内存地址，如果需要运行这个方法，可以在后 面添加括号()。

1. functiondemo = function_demo()
2. getattr(functiondemo, 'name') #获取name属性，存在就打印出来--- demo
3. getattr(functiondemo, "run") #获取run方法，存在打印出 方法的内存地址--->
4. getattr(functiondemo, "age") #获取不存在的属性，报错如下：
5. Traceback (most recent call last):
6.   File "/Users/liuhuiling/Desktop/MT_code/OpAPIDemo/conf/OPCommUtil.py", line 39, in
7.     res = getattr(functiondemo, "age")
8. AttributeError: 'function_demo' object has no attribute 'age'
9. getattr(functiondemo, "age", 18)  #获取不存在的属性，返回一个默认值
setattr(object,name,values)函数：

给对象的属性赋值，若属性不存在，先创建再赋值

1．class function_demo(object):
2．    name = 'demo'
3．    def run(self):
4．        return "hello function"
5．functiondemo = function_demo()
6．res = hasattr(functiondemo, 'age')  # 判断age属性是否存在，False
7．print(res)
8．setattr(functiondemo, 'age', 18 )  #对age属性进行赋值，无返回值
9．res1 = hasattr(functiondemo, 'age') #再次判断属性是否存在，True
综合使用：

1．class function_demo(object):
2．    name = 'demo'
3．    def run(self):
4．        return "hello function"
5．functiondemo = function_demo()
6．res = hasattr(functiondemo, 'addr') # 先判断是否存在if res:
7．    addr = getattr(functiondemo, 'addr')
8．    print(addr)else:
9．    addr = getattr(functiondemo, 'addr', setattr(functiondemo, 'addr', '北京首都'))
10．    #addr = getattr(functiondemo, 'addr', '美国纽约')
11．    print(addr)
reduce(lambda x,y: x*y, range(1,n+1)) 注意：Python3中取消了该函数。

什么是lambda函数？有什么好处？

lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数 1、lambda 函数比较轻便，即用即仍，很适合需要完成一项功能，但是此功能只在此一处使用， 连名字都很随意的情况下； 2、匿名函数，一般用来给 filter， map 这样的函数式编程服务; 3、作为回调函数，传递给某些应用，比如消息处理

下面这段代码的输出结果将是什么？请解释。

def multipliers():
 return [lambda x : i * x for i in range(4)]
 print [m(2) for m in multipliers()]
上面代码输出的结果是[6， 6， 6， 6] (不是我们想的[0， 2， 4， 6])。 上述问题产生的原因是Python闭包的延迟绑定。这意味着内部函数被调用时，参数的值在闭包内 进行查找。因此，当任何由multipliers()返回的函数被调用时， i的值将在附近的范围进行查找。那时， 不管返回的函数是否被调用，for循环已经完成，i被赋予了最终的值3。 因此，每次返回的函数乘以传递过来的值3，因为上段代码传过来的值是2，它们最终返回的都是6。下面是解决这一问题的一些方法。 一种解决方法就是用Python生成器。

def multipliers():
for i in range(4): yield lambda x :
i * x
另外一个解决方案就是创造一个闭包，利用默认函数立即绑定。

def  multipliers():
 return [lambda x， i=i : i * x for i in range(4)]
什么是lambda函数？它有什么好处？写一个匿名函数求两个数的和？

"""
lambda 函数是匿名函数；使用 lambda 函数能创建小型匿名函数。这种函数得名于省略了用 def
声明函数的标准步骤；
"""

# 答案
f = lambda x，y:x+y
print(f(2017，2018))
说说python中装饰器、迭代器的用法；描述下dict的items()方法与iteritems()方法的不同；

# 答案
'''
装饰器是指对函数执行过程，做一些扩展，甚至可以更改本身函数的执行迭代器是指遵循迭代器协议的对象，这类对象在被for循环时，每次迭代生成下一个项，不用一开始就生成整个列表在python3中不存在iteritems，items方法返回可迭代对象在python2中items()返回[(key,value)]的列表对象，iteritems()返回迭代器对象，iteritems()循环时不可以增删dict的内容
'''
def(a, b=[])这种写法有什么陷阱?

# 答案
'''
函数的第二个默认参数是一个list，当第一次执行的时候实例化了一个list，第二次执行还是用第一次执行的时候实例化的地址存储，所以三次执行的结果就是 [1, 1, 1] ，想每次执行只输出[1] ，默认参数应该设置为None。
'''
如何判断一个值是函数还是方法?

from types import MethodType,FunctionType

print(isinstance('1', FunctionType))  # False
print(isinstance(lambda x:x, FunctionType))  # True
请编写一个函数实现将IP地址转换成一个整数。

'''
如 10.3.9.12 转换规则为:
   10 00001010
   3 00000011
   9 00001001 12 00001100
再将以上二进制拼接起来计算十进制结果:00001010 00000011 00001001 000 01100 = ?
'''
def text(b):

    list_str=b.split(" ")
    new_str=[]
    for i in list_str:
        new_str.append(str(int(i,2)))
    return ".".join(new_str)

print(text("00001010 00000011 00001001 00001100"))
填空题: 补全代码

'''
若要将 N 个 task 分配给 N 个 worker 同时去完成, 每个 worker 分别都可以承 担这 N 个 task,但费用不同. 下面的程序用回溯法计算总费用最小的一种工作分 配方案, 在该方案中, 为每个 worker 分配 1 个 task.程序中,N 个 task 从 0 开 始顺序编号, N 个 worker 也从 0 开始顺序编号, 主要的变量说明如下:

    - ci:将任务 i 分配给 worker j 的费用
    - task[i]: 值为 0 表示 task i 未分配, 值为 j 表示 task,i 分配给 worker j
    - worker[k] 值为 0 表示未分配 task, 值为 1 表示 worker k 已分配 task;
    - mincost: 最小总费用

'''

# 写个函数接收一个文件夹名称作为参数, 显示文件夹中文件的路径, 以及 其中包含文件夹中文件的路径。
N=8
mincosr = 65535 
worker = []
task = []
temp = []
c=[]

def plan(k, cost):
  global mincosr
  if __(1)__ and cost         mincosr = cost
        for i in range(N):
          temp[i] = task[i]
   else:
      for i in range(N):
        if worker[i] ==0 and __(2)__:
        worker[i] = 1
        task[k] = __(3)__
      plan(__(4)__,cost+c[k][i]) 
      __(5)__
      task[k] = 0

def main():
  for i in range(N):
    worker.append(0)
        task.append(0)
        temp.append(0)
        c.append(0)
    for j in range(N):
        print("请输入 worker"+str(i)+"完成 task" + str(j)+"的花费")
        input_value = input()
    c[i].append(int(input_value))

plan(0,0)
 
print('\n 最小费用: '+str(mincosr)) 

for i in range(N):
  print("Task"+str(i)+"is assigned to Worker" + str(temp[i]) )

if __name__ == "__main__":
  main()