python面试的100题（19）

时间 2019-11-11

标签 python 面试栏目 Python 繁體版

原文原文链接

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

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

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

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

62.对缺省参数的理解？

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

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

65.为何函数名字能够当作参数用?

在实际使用中，咱们有时但愿将函数做为参数传递给另外一个方法使用。

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

使用函数当作入参api

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

使用函数当作入参，函数自己包含参数app

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

使用函数当作入参，函数自己包含不肯定个数的入参ssh

若是要调用的方法的入参个数不肯定，可使用*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 thisasync

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

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函数？

一、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]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

二、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': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
...     return digits[s]
...
>>> reduce(fn, map(char2num, '13579'))
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")  #若属性不存在，返回一个默认值。
18 '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", "18")   #为属相赋值，并无返回值
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", "18")) #age属性不存在时，设置该属性
12 '18'
13 >>> getattr(t, "age")  #可检测设置成功
14 '18'
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 函数是一个能够接收任意多个参数(包括可选参数)而且返回单个表达式值的匿名函数

好处：
一、lambda 函数比较轻便，即用即删除，很适合须要完成一项功能，可是此功能只在此一处使用，
连名字都很随意的状况下；
二、匿名函数，通常用来给 filter， map 这样的函数式编程服务;
三、做为回调函数，传递给某些应用，好比消息处理

1、lambda函数的语法

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

　1》无参数：

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

2》有参数，无默认值

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

3》有参数，有默认值

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

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)
#139

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