python面试的100题（19）

61.如何在function里面设置一个全局变量

Python中有局部变量和全局变量，当局部变量名字和全局变量名字重复时，局部变量会覆盖掉全局变量。

如果要给全局变量在一个函数里赋值，必须使用global语句。global VarName的表达式会告诉Python， VarName是一个全局变量，这样Python就不会在局部命名空间里寻找这个变量了。

我们在全局命名空间里定义一个变量money。我们再在函数内给变量money赋值，然后Python会假定money是一个局部变量。然而，我们并没有在访问前声明一个局部变量money，结果就是会出现一个UnboundLocalError的错误。取消global语句的注释就能解决这个问题。

62.对缺省参数的理解 ？

缺省参数指在调用函数的时候没有传入参数的情况下，调用默认的参数，在调用函数的同时赋值时，所传入的参数会替代默认参数。

参考地址：https://blog.csdn.net/liulin1207/article/details/80889995

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

在实际使用中，我们有时希望将函数作为参数传递给另一个方法使用。

比如装饰器实际就是函数调用函数

使用函数当做入参

那就可以把方法名A当做入参传递给方法B，调用的时候直接用【方法名()】来调用方法内容

使用函数当做入参，函数本身包含参数

如果要调用的方法A有参数怎么办呢？在定义B方法的时候，也将参数传进去，然后调用方法的时候使用【方法名(参数1，参数2)】

使用函数当做入参，函数本身包含不确定个数的入参

如果要调用的方法的入参个数不确定，可以使用*args或**args。但是一定要把*args放到最后面

参考地址：https://www.cnblogs.com/meitian/p/6756665.html

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

pass语句什么也不做，一般作为占位符或者创建占位程序，pass语句不会执行任何操作，比如：
while False:
pass
pass通常用来创建一个最简单的类：
class MyEmptyClass:
pass
pass在软件设计阶段也经常用来作为TODO，提醒实现相应的实现，比如：
def initlog(*args):
pass #please implement this

参考地址：https://www.cnblogs.com/DjangoBlog/p/3501479.html

68.如何交换两个变量的值？

方法一:(所有语言都可以通过这种方式进行交换变量)
　　通过新添加中间变量的方式，交换数值.
　　下面通过一个demo1函数进行演示：

def demo1(a,b):
    temp = a
    a = b
    b = temp
    print(a,b)

方法二：（此方法是Python中特有的方法）

　　　　直接将a， b两个变量放到元组中，再通过元组按照index进行赋值的方式进行重新赋值给两个变量。

　　　　下面通过一个demo2函数进行演示:

def demo2(a,b):
    a,b = b,a
    print(a,b)

方法三：

　　通过简单的逻辑运算进行将两个值进行互换

　　下面通过一个demo3函数进行演示:

def demo3(a, b):
    a = a + b
    b = a - b
    a = a - b
    print(a, b)

方法四：

　　通过异或运算 将两个值互换 异或运算的原理是根据二进制中的  "1^1=0 1^0=1 0^0=0"

　　下面通过一个demo4函数进行演示:

def demo4(a,b):
    a = a^b
    b = a^b  # b = (a^b)^b = a
    a = a^b  # a = (a^b)^a = b
    print(a,b)

参考地址：https://www.cnblogs.com/aydenwang/p/9398826.html

69.map函数和reduce函数？

1、python3的map函数
map()函数接收两个参数，一个是函数，一个是Iterable（可迭代对象），map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator（迭代器）返回。
举例说明，比如我们有一个函数f(x)=x2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

上述代码中f是一个map对象，r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。 
不对r进行list函数的话，输出结果如下：

def f(n):
    return n*n
r = map(f,[1,2,3])
print(r)

结果：

<map object at 0x000001FB4EC5D240>

map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['', '', '', '', '', '', '', '', '']

2、python3的reduce函数

reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方说对一个序列求和，就可以用reduce实现：

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     digits = {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '': 8, '': 9}
...     return digits[s]
...
>>> reduce(fn, map(char2num, ''))
13579

参考地址：https://blog.csdn.net/jin970505/article/details/79919263

70.回调函数，如何通信的?

在计算机程序设计中，回调函数，或简称回调（Callback），是指通过函数参数传递到其它代码的，某一块可执行代码的引用。这一设计允许了底层代码调用在高层定义的子程序。

有两种类型的回调函数：即blocking callbacks (also known as synchronous callbacks or just callbacks) and deferred callbacks (also known as asynchronous callbacks).

那么，在python中如何实现回调函数呢，看代码：

def my_callback(input):
    print "function my_callback was called with %s input" % (input,)

def caller(input, func):
    func(input)

for i in range(5):
    caller(i, my_callback)

参考地址：https://www.cnblogs.com/berlin-sun/p/callbackinpython.html

71.Python主要的内置数据类型都有哪些？ print dir( ‘a ’) 的输出？

python的数据类型有

int 整型、bool 布尔、str 字符串、list 列表、tuple 元组、dict 字典、float 浮点型小数

print(dir("a"))的输出是

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

输出字符串‘a’的内建方法；

参考地址：https://www.cnblogs.com/blog-rui/p/9858803.html

72.map(lambda x:xx，[y for y in range(3)])的输出？

lambda原型为：lambda 参数:操作(参数)

lambda函数也叫匿名函数，即没有具体名称的函数，它允许快速定义单行函数，可以用在任何需要函数的地方。这区别于def定义的函数。

lambda与def的区别：

1）def创建的方法是有名称的，而lambda没有。

2）lambda会返回一个函数对象，但这个对象不会赋给一个标识符，而def则会把函数对象赋值给一个变量（函数名）。

3）lambda只是一个表达式，而def则是一个语句。

4）lambda表达式” : “后面，只能有一个表达式，def则可以有多个。

5）像if或for或print等语句不能用于lambda中，def可以。

6）lambda一般用来定义简单的函数，而def可以定义复杂的函数。
将一个 list 里的每个元素都平方：

map( lambda x: x*x, [y for y in range(10)] )

这个写法要好过

def sq(x):
    return x * x

map(sq, [y for y in range(10)])

因为后者多定义了一个（污染环境的）函数，尤其如果这个函数只会使用一次的话。

进一步讲，匿名函数本质上就是一个函数，它所抽象出来的东西是一组运算。这是什么意思呢？类比

a = [1, 2, 3]

和

f = lambda x : x + 1

我们会发现，等号右边的东西完全可以脱离等号左边的东西而存在，等号左边的名字只是右边之实体的标识符。如果能习惯 [1, 2, 3] 单独存在，那么 lambda x : x + 1 也能单独存在其实也就不难理解了，它的意义就是给「某个数加一」这一运算本身。

现在回头来看 map() 函数，它可以将一个函数映射到一个可枚举类型上面。沿用上面给出的 a 和 f，可以写

map(f, a)

也就是将函数 f 依次套用在 a 的每一个元素上面，获得结果 [2, 3, 4]。现在用 lambda 表达式来替换 f，就变成：

map( lambda x : x + 1, [1, 2, 3] )

会不会觉得现在很一目了然了？尤其是类比

a = [1, 2, 3]
r = []
for each in a:
    r.append(each+1)

参考地址：https://i.cnblogs.com/EditPosts.aspx?opt=1

73.hasattr() getattr() setattr() 函数使用详解？

hasattr(object, name)
判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。
需要注意的是name要用括号括起来

  >>> class test():
  ...     name="xiaohua"
  ...     def run(self):
  ...             return "HelloWord"
  ...
 >>> t=test()
  >>> hasattr(t, "name") #判断对象有name属性
  True
  >>> hasattr(t, "run")  #判断对象有run方法
 True
 >>>

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

 1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> getattr(t, "name") #获取name属性，存在就打印出来。
 8 'xiaohua'
 9 >>> getattr(t, "run")  #获取run方法，存在就打印出方法的内存地址。
10 <bound method test.run of <__main__.test instance at 0x0269C878>>
11 >>> getattr(t, "run")()  #获取run方法，后面加括号可以将这个方法运行。
12 'HelloWord'
13 >>> getattr(t, "age")  #获取一个不存在的属性。
14 Traceback (most recent call last):
15   File "<stdin>", line 1, in <module>
16 AttributeError: test instance has no attribute 'age'
17 >>> getattr(t, "age","")  #若属性不存在，返回一个默认值。
18 ''

setattr(object, name, values)
给对象的属性赋值，若属性不存在，先创建再赋值。

 1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> hasattr(t, "age")   #判断属性是否存在
 8 False
 9 >>> setattr(t, "age", "")   #为属相赋值，并没有返回值
10 >>> hasattr(t, "age")    #属性存在了
11 True
12 >>>

一种综合的用法是：判断一个对象的属性是否存在，若不存在就添加该属性

1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> getattr(t, "age")    #age属性不存在
 8 Traceback (most recent call last):
 9   File "<stdin>", line 1, in <module>
10 AttributeError: test instance has no attribute 'age'
11 >>> getattr(t, "age", setattr(t, "age", "")) #age属性不存在时，设置该属性
12 ''
13 >>> getattr(t, "age")  #可检测设置成功
14 ''
15 >>>

参考地址：https://www.cnblogs.com/cenyu/p/5713686.html

74.一句话解决阶乘函数？

def factorial(num):
    j = 1
    for i in range(1,num+1):
        j = j*i
    print(j)

num = int(input("请输入阶乘数字："))
factorial(num)

参考地址：https://www.cnblogs.com/gengyi/p/7967076.html

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

lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的匿名函数

好处：
1、lambda 函数比较轻便，即用即删除，很适合需要完成一项功能，但是此功能只在此一处使用，
连名字都很随意的情况下；
2、匿名函数，一般用来给 filter， map 这样的函数式编程服务;
3、作为回调函数，传递给某些应用，比如消息处理

一、lambda函数的语法

　lambda语句中，冒号前是参数，可以有0个或多个，用逗号隔开，冒号右边是返回值。lambda语句构建的其实是一个函数对象。

　1》无参数：

f = lambda:'Hello python lambda'
f()
#'Hello python lambda'

2》有参数，无默认值

f = lambda x,y: x*y
f(6,7)
#

3》有参数，有默认值

f = lambda x=5, y=8: x*y
f()
#
f(5,6)
#

4》和map, reduce, filter连用

foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]

print filter(lambda x: x % 3 == 0, foo)#python 2.x
list( filter(lambda x: x % 3 == 0, foo) )#python 3.x
#[18, 9, 24, 12, 27]

print map(lambda x: x * 2 + 10, foo)#python 2.x
list( map(lambda x: x * 2 + 10, foo) )#python 3.x
#[14, 46, 28, 54, 44, 58, 26, 34, 64]

from functools import reduce#python 3.x need import reduce
reduce(lambda x, y: x + y, foo)
#

参考地址：https://www.cnblogs.com/lmh001/p/9790378.html